Go é uma linguagem de programação imperativa, estruturada e concorrente desenvolvida pelo Google em 2009. Possui características como garbage collector, compilação rápida, baixo uso de memória e suporte a programação concorrente. Sua sintaxe é semelhante a C com tipagem estática, mas inclui recursos como canais e goroutines para facilitar a programação concorrente.

1. Go
Imperativa, Estruturada e Concorrente

2. Introdução
História
Motivação
Características

3. História
▪ Google ― 2009
▪ Open Source
▪ A lenda
▪ Compilador Experimental
▪ V1.0 ― 2012
Rob Pike Ken ThompsonRobert Griesemer

4. Motivação
▪ Frustração com linguagens e
ambientes existentes
▪ Compilação eficiente ou execução
eficiente ou facilidade de
programação
▪ Objetivos simples:
▫ ter a rapidez do C
▫ ser mais legível
▫ programadores mais produtivos

5. Características
▪ Garbage Collector
▪ Compila muito rápido
▪ Incrivelmente ‘leve’ em
termos de uso de memória
▪ Muito boa para programas
concorrentes

6. Nomenclatura

7. Nomenclatura
▪ A sintaxe é descrita usando EBNF
▪ 25 palavras-chave
▪ Nome antes de tipo
▪ Ponteiros (semelhante à C)
▫ Porém, sem aritmética
▪ Escopo estático
▫ Pacote, Função, For
▫ Bloco podem ser aninhados

8. Nomenclatura
▪ Visibilidade (diferentes pacotes)
▫ Nomes iniciados com
■ Maiúscula: são públicos
■ minúscula: são privados
▪ Não permite sobrecarga
▪ Ponto e vírgula invisível

9. Tipagem

10. Tipagem
▪ Tipagem estática
▪ Fortemente tipada
▪ Equivalência de tipos
▫ Equivalência de nome, não há
equivalência estrutural
Parece tipagem dinâmica
var x int = 5
var x = 5
x := 5

11. Tipagem
Tipos básicos:
▫ bool
▫ string
▫ int int8 int16 int32 int64
▫ uint uint8 uint16 uint32 uint64 uintptr
▫ byte (pseudônimo para uint8)
▫ rune (pseudônimo para int32)
(ponto de código Unicode)
▫ float32 float64
▫ complex64 complex128

12. Tipagem
▪ Tipos compostos
▫ Ponteiros
■ &(endereço de) e *(desreferenciação)
▫ Structs
■ Pode ser recursivo
▫ Matrizes
■ Não podem ser redimensionadas
▫ Slices
■ Dinamicamente redimensionada
■ Referência para matriz

13. Tipagem
▪ Tipos compostos
▫ Maps
▫ Interfaces
■ Conjunto de funções
▫ Funções
■ Mesmos parâmetros e mesmo tipo de
retorno
▫ Canais
■ Mecanismo para comunicação de
funções concorrentes

14. Funções
e algo mais...

15. Funções
▪ Go possui:
▫ Funções
▫ Procedimentos
▫ Métodos
▪ Passagem de parâmetro
▫ Padrão: por valor
▫ Por referência somente com ponteiro

16. Principais áreas de uso do GO
● Aplicações de Servidor
● Big Data
● Processamento de Imagem
● Núcleo de apps Web complexos
● Criptografia

17. Não possui
● Tratamento de exceção
● Herança de tipos
● Programação genérica
● Asserções
● Conversão numérica implícita
● Ternários (expressão ? uma coisa : outra coisa)
● Compilação com variáveis ou
importações não utilizadas

18. Mini-tutorial

19. Estruturas de Controle
Sem Parênteses
for i := 0; i < 10; i++ {
soma += i
}
if x < 0 {
return sqrt(-x) + "i"
}

20. Estruturas de Controle
Sem DO
Sem WHILE
func main() {
soma := 1
for soma < 1000 {
soma += soma
} // for é o while de Go
fmt.Println(soma)
}

21. Estruturas de Controle
IF e SWITCH aceitam instrução de
inicialização
if v := math.Pow(x, n); v<10 {
return v
}
switch os := runtime.GOOS; os {
case "darwin":
fmt.Println("OS X.")
case "linux":
fmt.Println("Linux.")
default:
// freebsd, openbsd,
// plan9, windows...
fmt.Printf("%s.", os)
}

22. Estruturas de Controle
Rótulo em BREAK e CONTINUE
busca:
for i := 0; i < len(tabuleiro); i++ {
for j := 0; j < len(tabuleiro[i]); j++ {
if (tabuleiro[i][j] == 9) {
Println("Achou bomba na linha ", i+1);
break busca;
}
}
}

23. Matrizes
func main() {
var a [2]string
a[0] = "Hello"
a[1] = "World"
fmt.Println(a[0], a[1])
fmt.Println(a)
primos := [6]int{2, 3, 5, 7, 11, 13}
fmt.Println(primos)
}

24. Slices
func main() {
primos := [6]int{2, 3, 5, 7, 11, 13}
var s []int = primos[1:4]
fmt.Println(s)
}

25. Interfaces e “Polimorfismo”
type Funcionário interface {
Id()
}
type Pessoa struct {
Nome string
}
//Esse método diz que o tipo T
//implementa a interface I,
//mas não precisamos explicitamente
//declarar isso
func (p Pessoa) Id() {
fmt.Println(p.Nome)
}
func main() {
var f Funcionário =
Pessoa{"hello"}
f.Id()
}

26. Outros detalhes
Funções com múltiplos retornos
func troca(x, y string) (string, string) {
return y, x
}
func main() {
a, b := troca("hello", "world")
fmt.Println(a, b)
}

27. Outros detalhes
Funções de primeira-classe
package main
import (
"fmt"
)
type StringFoo func() string
func ok() string{
return "tá OK"
}
func pegaUmaFuncao(foo StringFoo){
fmt.Printf("função foo retorna:
%vn", foo())
}
func main(){
pegaUmaFuncao(ok)
}

28. Outros detalhes
Funções variádicas
func soma(nums ...int) {
fmt.Print(nums, " ")
total := 0
for _, num := range nums {
total += num
}
fmt.Println(total)
}
func main() {
soma(1, 2)
soma(1, 2, 3)
nums := []int{1, 2, 3, 4}
soma(nums...)
}

29. Concorrência
▪ Goroutines
package main
import (
"fmt"
"time"
)
func dizer(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100*time.Millisecond)
fmt.Println(s)
}
}
func main() {
go dizer("world")
dizer("hello")
}

30. Concorrência
▪ Channels
package main
import "fmt"
func soma(s []int, c chan int) {
soma := 0
for _, v := range s {
soma += v
}
c <- soma //manda soma para c
}
func main() {
s := []int{7, 2, 8, -9, 4, 0}
c := make(chan int)
go soma(s[:len(s)/2], c)
go soma(s[len(s)/2:], c)
x, y := <-c, <-c // recebe de c
fmt.Println(x, y, x+y)
}

31. Obrigado!
Dúvidas?