Go para desenvolvedores

Golang para desenvolvedores Java, C e Python

Transcript

1. Go para desenvolvedores Alexandre Vicenzi Jonathan André Schweder
2. Go é • Open Source • Legível • Segura ◦ Type safety e Memory safe ◦ Não possui buffer overflows ◦ Não permite operações aritméticas com ponteiros (pointer arithmetic) • Compilada • Orientada a objetos (mas sem class, extends ou implements como no Java) • Controlada por GC • Estaticamente tipada • Parte da familía do C
3. Porque Go? • Escalabilidade • Concorrência • Simplicidade
4. Quem usa? • Google • Docker • SoundCloud • Canonical • CloudFlare • Mozilla • E muitas outras
5. Hello World package main import ( "fmt" ) func main() { fmt.Println("Hello Gopher!") }
6. Tipos • Numéricos ◦ int, uint, uintptr ◦ int8, int16, int32, int64 ◦ uint8, uint16, uint32, uint64 ◦ float32, float64 ◦ byte (alias for uint8) ◦ rune (alias for int32) ◦ complex64, complex128 • Strings ◦ string • Booleanos ◦ bool
7. Tipos (continuação) • Array • Slice • Map • Ponteiro • Função • Channel • Interface • Struct
8. Variáveis e constantes • Variáveis var x int var y = 1 z := 1 • Constantes const Yes = 1
9. Operadores • And a && b • Or a || b • Not !ok • Equal a == 0 • Not Equal a != 0
10. Fluxos de Controle • Não necessita de ( ) nas condições como no Java e C • { } são obrigatórios para delimitar o escopo • Condições ◦ If ▪ Variáveis podem ser declaradas na condição e terão escopo apenas dentro do if ◦ For ▪ break e continue ▪ while do C é for no Go ▪ Se omitir a condição do loop ele executará para sempre (while true do C) ◦ Switch ▪ Similar ao C e Java, porém só executa o case selecionado ▪ Não necessita de break no fim da condição, ele é implícito
11. If (exemplo) if i % 2 == 0 { // even } else { // odd } if i % 2 == 0 { // divisível por 2 } else if i % 3 == 0 { // divisível por 3 } if f, err := os.Open("f.txt"); err == nil { // abriu arquivo com sucesso } else { // erro ao abrir arquivo }
12. for { if i == 0 { continue } if i > 100 { break } i++ } For (exemplo) for i := 0; i <= 10; i++ { fmt.Println(i) } for k, v := range myMap { fmt.Println(k, v) }
13. Switch (exemplo) switch i { case 0: fmt.Println("Zero") case 1: fmt.Println("Um") case 2: fmt.Println("Dois") Default: fmt.Println("Outro") }
14. Arrays, Slices e Maps • Arrays (Tamanho Fixo) [5]int • Slices (Tamanho Variável) []int • Maps map[string]int
15. Funções • Podem retornar múltiplos valores func f() (int, err) • Variadic functions igual do C (número de argumentos variável) func fprint(format string, args ...interface{}) • Varíavels de retorno podem ser nomeadas func f() (value int, error err) • Omissão do tipo em argumentos do mesmo tipo em sequência func f(s1, s2, s3 string, value int) bool • Suporte a Closures (funções dentro de funções)
16. Ponteiros • Similar ao C var x *int y := new(int) z := &Foo{} • Não é permitido operações em cima do endereço var p *int = &a[0] var q = p+2 // não permitido • Existe o método new mas não o delete • Controlado pelo GC
17. Interfaces e Structs • Interfaces ◦ Contém apenas declaração de métodos (similar ao java) ◦ Duck typing • Structs ◦ Tipo que contém campos nomeados ◦ Suporte a métodos ◦ Incorporação de tipos
18. Interface (exemplo) // declaração type OpenCloser interface { Open() Close() } // implementação type Foo struct { } func (f *Foo) Open() {} func (f *Foo) Close() {}
19. Struct (exemplo) // declaração type Pessoa struct { Nome string Idade int } func (p *Pessoa) DeMaior() bool { return p.Idade >= 18 } // uso pessoa := &Pessoa{"João", 30} fmt.Println(pessoa.Nome) fmt.Println(pessoa.Idade) fmt.Println(pessoa.DeMaior())
20. Conversão de tipos • Sem conversão implícita • A expressão T(v) converte o valor v para o tipo T i := 42 f := float64(i) u := uint(f) • Type assertion (o tipo na esquerda deve ser obrigatoriamente uma interface) var i interface{} = 42 f := i.(float64) f, ok := i.(float64)
21. Defer, Panic & Recover • defer é um comando • panic e recover são funções • Defer agenda execução de uma função • Panic causa um runtime error (similar a throw new Exception() no Java) • Recover é usado para capturar runtime errors
22. Defer, Panic & Recover (exemplo) package main import "fmt" func main() { defer func() { str := recover() fmt.Println(str) }() panic("PANIC") }
23. Concorrência • Goroutines ◦ Funções que execução concorrentemente com outras ◦ Usa-se a keyword go para invocar uma função • Channels ◦ Permite a comunicação entre goroutines ◦ Útil para sincronizar execução ◦ O comando select funciona como um switch para channels ◦ Channels podem ser bufferizados ou não
24. Concorrência (exemplo) package main import ( "fmt" "time" ) func pinger(c chan string) { for i := 0; ; i++ { c <- "ping" } } func printer(c chan string) { for { msg := <- c fmt.Println(msg) time.Sleep(time.Second * 1) } } func main() { var c chan string = make(chan string) go pinger(c) go printer(c) var input string fmt.Scanln(&input) }
25. Conclusão • Go é ◦ Simples ◦ Legível ◦ Divertido • Interfaces são implícitas (duck typing) • Usa composição ao invés de herança • Concorrência é poderosa
26. Referencias • The Go Programming Language Specification • An Introduction to Programming in Go • Go for Javaneros • Go for C++ developers