O documento apresenta uma introdução à linguagem de programação Go. Ele discute a história e criadores da linguagem, suas principais características como tipagem estática e concorrência, e fornece exemplos de código como "Hello World" e variáveis. O documento também lista recursos online para iniciar com a linguagem Go.

1. Introdução a
linguagem Go
Allisson Azevedo
http://allissonazevedo.com
FLISol Campina Grande 2015

2. História
• 2007 - Design
• Robert Griesemer (HotSpot/V8)
• Rob Pike (Unix/UTF-8)
• Ken Thompson (Unix/UTF-8/B e C)
• 2009 - Open Source
• http://golang.org/doc/faq#history

3. Características
• Compilada
• Tipagem estática
• Sintaxe simples
• Visibilidade pela primeira letra do símbolo
• Concorrência (Goroutines)
• Garbage collector
• Ótima biblioteca padrão

4. The Gopher

5. Quem esta usando?
https://speakerdeck.com/ftmamud/golang

6. Por onde iniciar?
• http://golang.org/doc/install
• http://tour.golang.org/
• http://play.golang.org/
• http://www.golang-book.com/
• http://www.golangbootcamp.com/

7. Hello World
// Definição do pacote
package main
// Import do pacote fmt
import "fmt"
// Definição da função main
func main() {
// Executa a função Println do pacote fmt
fmt.Println("Hello World")
}

8. Variavéis
package main
import "fmt"
var nome string
func main() {
nome = "Allisson"
fmt.Println("Olá " + nome)
// retorna Olá Allisson
}

9. Variavéis
package main
import "fmt"
var nome string = "Allisson"
func main() {
fmt.Println("Olá " + nome)
// retorna Olá Allisson
}

10. Variavéis
package main
import "fmt"
var nome = "Allisson"
func main() {
fmt.Println("Olá " + nome)
// retorna Olá Allisson
}

11. Variavéis
package main
import "fmt"
func main() {
nome := "Allisson"
fmt.Println("Olá " + nome)
// retorna Olá Allisson
}

12. Variavéis
package main
import "fmt"
var (
nome = "Allisson"
sobrenome = "Azevedo"
)
func main() {
fmt.Println("Olá " + nome + " " + sobrenome)
// retorna Olá Allisson Azevedo
}

13. Variavéis
package main
import "fmt"
var (
nome, sobrenome = "Allisson", "Azevedo"
)
func main() {
fmt.Println("Olá " + nome + " " + sobrenome)
// retorna Olá Allisson Azevedo
}

14. Variavéis
package main
import "fmt"
var (
nome, sobrenome = "Allisson", "Azevedo"
idade = 32
)
func main() {
fmt.Println("Olá " + nome + " " + sobrenome)
// retorna Olá Allisson Azevedo
fmt.Println(32)
// retorna 32
}

15. Constantes
package main
import "fmt"
const Pi = 3.14
const (
StatusOK = 200
StatusNotFound = 404
)
func main() {
fmt.Println(Pi)
// retorna 3.14
fmt.Println(StatusOK)
// retorna 200
fmt.Println(StatusNotFound)
// retorna 404
}

16. Pacotes e Imports
package main
import "fmt"
import "log"
func main() {
log.Println("Iniciando o programa")
fmt.Println("Hello World")
}

17. Pacotes e Imports
package main
import (
"fmt"
"log"
)
func main() {
log.Println("Iniciando o programa")
fmt.Println("Hello World")
}

18. Pacotes e Imports
package main
// go get code.google.com/p/go-uuid/uuid
import (
"code.google.com/p/go-uuid/uuid"
"fmt"
"log"
)
func main() {
log.Println("Iniciando o programa")
fmt.Println("Hello World")
fmt.Println(uuid.NewRandom())
}

19. Funções
package main
import "fmt"
func soma(x, y int) int {
return x + y
}
func main() {
fmt.Print("2 + 2 = ")
fmt.Println(soma(2, 2))
}

20. Funções
package main
import (
"fmt"
"strings"
)
func nomeSobrenome(nome string) (string, string) {
return strings.Split(nome, " ")[0], strings.Split(nome, " ")[1]
}
func main() {
nome, sobrenome := nomeSobrenome("Allisson Azevedo")
fmt.Println("Nome = " + nome)
fmt.Println("Sobrenome = " + sobrenome)
}

21. Funções
package main
import (
"fmt"
"strings"
)
func nomeSobrenome(nomeCompleto string) (nome, sobrenome string) {
nome = strings.Split(nomeCompleto, " ")[0]
sobrenome = strings.Split(nomeCompleto, " ")[1]
return
}
func main() {
nome, sobrenome := nomeSobrenome("Allisson Azevedo")
fmt.Println("Nome = " + nome)
fmt.Println("Sobrenome = " + sobrenome)
}

22. Ponteiros
package main
import "fmt"
func main() {
a := 10
b := a
c := &a
b = 20
*c = 30
fmt.Println(a)
// retorna 30
fmt.Println(b)
// retorna 20
fmt.Println(*c)
// retorna 30
}

23. Ponteiros
package main
import "fmt"
func zera1(valor int) {
valor = 0
}
func zera2(valor *int) {
*valor = 0
}
func main() {
valor := 10
zera1(valor)
fmt.Println(valor)
// retorna 10
zera2(&valor)
fmt.Println(valor)
// retorna 0
}

24. Structs
package main
import "fmt"
type Pessoa struct {
Nome string
Idade int
}
func main() {
pessoa := Pessoa{Nome: "Fulano", Idade: 1}
fmt.Println(pessoa.Nome)
fmt.Println(pessoa.Idade)
allisson := &pessoa
allisson.Nome = "Allisson"
allisson.Idade = 32
fmt.Println(pessoa.Nome)
fmt.Println(pessoa.Idade)
}

25. Structs
package main
import "fmt"
type Numero struct {
X int
}
func (n Numero) Dobro() int {
n.X = n.X * 2
return n.X
}
func (n *Numero) Dobro2() int {
n.X = n.X * 2
return n.X
}
func main() {
numero := Numero{X: 10}
fmt.Println(numero.Dobro())
fmt.Println(numero.X)
fmt.Println(numero.Dobro2())
fmt.Println(numero.X)
}

26. Structs
package main
import "fmt"
type Pessoa struct {
Nome string
}
type Funcionario struct {
Pessoa
Mat int
}
func main() {
funcionario := Funcionario{}
funcionario.Nome = "Allisson"
funcionario.Mat = 12345
fmt.Println(funcionario.Nome)
fmt.Println(funcionario.Mat)
}

27. Structs
package main
import "fmt"
type Pessoa struct {
Nome string
}
type Funcionario struct {
Pessoa
Mat int
}
func main() {
funcionario := Funcionario{Pessoa{Nome: "Allisson"}, 12345}
fmt.Println(funcionario.Nome)
fmt.Println(funcionario.Mat)
}

28. Interfacespackage main
import "fmt"
type FiguraGeometrica interface {
area() int
}
type Quadrado struct {
Lado int
}
func (q Quadrado) area() int {
return q.Lado * 2
}
type Retangulo struct {
Comprimento, Largura int
}
func (r Retangulo) area() int {
return r.Comprimento * r.Largura
}
func CalculaArea(f FiguraGeometrica) {
fmt.Println(f.area())
}
func main() {
quadrado := Quadrado{Lado: 5}
retangulo := Retangulo{Comprimento: 5, Largura: 10}
CalculaArea(quadrado)
CalculaArea(retangulo)
}

29. Tratamento de erros
package main
import (
"fmt"
"io/ioutil"
"log"
)
func main() {
file, err := ioutil.ReadFile("arquivo.invalido")
if err != nil {
log.Fatal(err)
}
fmt.Println(string(file))
}

30. Tratamento de erros
package main
import (
"errors"
"fmt"
"log"
)
func Dividir(x, y int) (int, error) {
if y == 0 {
return 0, errors.New("Proibida divisão por zero.")
}
return x / y, nil
}
func main() {
valor, err := Dividir(10, 0)
if err != nil {
log.Fatal(err)
}
fmt.Println(valor)
}

31. Defer
package main
import "fmt"
func main() {
defer fmt.Println("World")
fmt.Println("Hello")
}

32. Defer
package main
import (
"log"
"os"
)
func main() {
file, err := os.Create("teste.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
file.WriteString("Teste do defer")
}

33. Slices
package main
import "fmt"
func main() {
alunos := make([]string, 3)
fmt.Println(alunos)
alunos[0] = "Fulano"
alunos[1] = "Beltrano"
alunos[2] = "Cicrano"
fmt.Println(alunos)
alunos = append(alunos, "Zezinho")
fmt.Println(alunos)
fmt.Println(alunos[2:4])
}

34. Range
package main
import "fmt"
func main() {
alunos := make([]string, 3)
alunos[0] = "Fulano"
alunos[1] = "Beltrano"
alunos[2] = "Cicrano"
for i, value := range alunos {
fmt.Println("Posição:", i, "Valor:", value)
}
}

35. Maps
package main
import "fmt"
func main() {
m := make(map[string]int)
m["Allisson"] = 32
m["Chuck Norris"] = 75
fmt.Println(m["Allisson"])
fmt.Println(m["Chuck Norris"])
}

36. Maps
package main
import "fmt"
func main() {
m := map[string]int{
"Allisson": 32,
"Chuck Norris": 75,
}
fmt.Println(m["Allisson"])
fmt.Println(m["Chuck Norris"])
}

37. Maps
package main
import "fmt"
func main() {
m := make(map[string]int)
m["Teste"] = 30
fmt.Println("O valor é:", m["Teste"])
m["Teste"] = 31
fmt.Println("O valor é:", m["Teste"])
delete(m, "Teste")
fmt.Println("O valor é:", m["Teste"])
_, ok := m["Teste"]
if ok == false {
fmt.Println("O valor Teste não existe")
}
}

38. Maps
package main
import "fmt"
func main() {
m := make(map[string]int)
m["Allisson"] = 32
m["Chuck Norris"] = 75
for k, v := range m {
fmt.Println("Chave:", k, "Valor:", v)
}
}

39. Goroutines
package main
import (
"fmt"
"time"
)
func digaoi(s string) {
fmt.Println("Dizendo oi de:", s)
}
func main() {
go digaoi("Goroutine")
digaoi("Normal")
time.Sleep(100 * time.Millisecond)
}

40. Goroutines
package main
import (
"fmt"
"io/ioutil"
"log"
"net/http"
"time"
)
func fetch(s string) {
res, err := http.Get(s)
if err != nil {
log.Println("Não foi possível conectar com a url", s)
return
}
body, err := ioutil.ReadAll(res.Body)
fmt.Println("A página:", s, "Tem o tamanho de:", len(string(body)))
}
func main() {
go fetch("http://www.google.com.br")
fetch("http://www.uol.com.br")
time.Sleep(5000 * time.Millisecond)
}

41. Goroutinespackage main
import (
"fmt"
"io/ioutil"
"log"
"net/http"
)
func fetch(s string, channel chan string) {
res, err := http.Get(s)
if err != nil {
log.Println("Não foi possível conectar com a url", s)
return
}
body, err := ioutil.ReadAll(res.Body)
result := fmt.Sprintf("A página: %s, Tem o tamanho de %d", s, len(string(body)))
channel <- result
}
func main() {
channel := make(chan string)
go fetch("http://linuxmint.com/", channel)
go fetch("http://www.ubuntu.com/", channel)
go fetch("http://www.debian.org/", channel)
go fetch("http://www.opensuse.org/en/", channel)
go fetch("http://getfedora.org/", channel)
for i := 0; i < 5; i++ {
fmt.Println(<-channel)
}
}

42. HTTP Server
package main
import (
"io"
"net/http"
)
func index(w http.ResponseWriter, r *http.Request) {
io.WriteString(w, "Hello world!")
}
func main() {
http.HandleFunc("/", index)
http.ListenAndServe(":8080", nil)
}

43. Mais exemplos
• Thumbnail server
• Static http server
• Gogs.io

44. Obrigado!