Vá para o curso

Os fundamentos: pacotes, variáveis, tipos, constantes, operadores e entrada/saída com o pacote fmt.

1. 1.1Variáveis e tiposvar, a declaração curta `:=`, tipos básicos (int, float64, string, bool) e o conceito de tipagem estática.~10 min
2. 1.2Valor zero e conversões de tipoCada variável possui um valor padrão; as conversões são explícitas (`int(x)`, `string(b)`).~10 min
3. 1.3Constantes e iota`const`, constantes não digitadas e o padrão `iota` para gerar enumerações legíveis.~10 min
4. 1.4OperadoresAritmética, comparação, lógica e bit a bit; precedência e diferenças de outras línguas.~8 min
5. 1.5Entrada/saída com fmt`fmt.Println`, `fmt.Printf`, formatar verbos (`%d`, `%s`, `%v`, `%T`) e quando preferir um em vez do outro.~10 min

Decisões e repetições: if com instruções init, o único `for`, opção idiomática e tratamento de erros explícito.

1. 2.1instruções if, else e initO `if v := f(); v > 0 { ... }` e por que Go não tem operador ternário.~10 min
2. 2.2para: o único loopAs três formas de `for`: três cláusulas, condição única (= while) e infinita; usando `break` e `continue`.~10 min
3. 2.3para... alcanceIterar sobre fatias, mapas e strings; o valor retornado é uma cópia, quando ignorar o índice ou valor com `_`.~10 min
4. 2.4Interruptor idiomáticoSem falhas implícitas, expressões complexas em casos, alternam sem uma condição como uma cadeia de if.~10 min
5. 2.5Erros: o padrão `if err != nil`Erros são valores; o padrão fundamental `if err != nil { return err }` e por que Go não tem exceções.~12 min

Funciona como cidadãos de primeira classe: assinaturas, retornos múltiplos, parâmetros variados, fechamentos e `defer`.

1. 3.1Assinatura e parâmetrosSintaxe `func name(p type) type`, passagem por valor por padrão, parâmetros do mesmo tipo agrupados.~10 min
2. 3.2Retornos múltiplos e retornos nomeadosRetornando vários valores (`value, err`), o padrão de retorno nomeado e quando NÃO usá-lo.~12 min
3. 3.3Funções variáveis`func sum(nums ...int) int`, espalhando uma fatia com `slice...`, exemplos do stdlib.~10 min
4. 3.4Fechamentos e funções como valoresFunções anônimas que capturam variáveis do contexto envolvente; adaptador e padrões de fábrica.~12 min
5. 3.5`defer`: limpeza garantidaAdiar a execução até o retorno; o padrão `defer f.Close()`, ordem LIFO, pegadinhas dentro dos loops.~12 min

Matrizes, fatias (a estrutura mais importante), mapas, runas dentro de strings e classificação.

1. 4.1Matrizes de comprimento fixoSintaxe `[N]T`, por que arrays reais raramente são usados ​​em Go, conversão de array em fatia.~8 min
2. 4.2Fatias: a estrutura idiomática`make`, `append`, len/cap, fatiamento `s[a:b]`, compartilhamento do array subjacente e quando copiar.~15 min
3. 4.3Mapas: chaves e valoresDeclaração, acesso vírgula-ok (`v, ok := m[k]`), `delete`, iteração não determinística.~12 min
4. 4.4Strings, bytes e runasStrings são bytes UTF-8; `range` produz runas; `len()` conta bytes, não caracteres.~12 min
5. 4.5Classificando com o pacote sort`sort.Ints`, `sort.Strings`, `sort.Slice` com função de comparação, estabilidade.~10 min

Tipos de dados compostos: estruturas, métodos em receptores de valor ou ponteiro, composição (sem herança) e tags.

1. 5.1Definindo e usando uma estrutura`type Person struct {Nome string; Age int }`, inicialização posicional vs nomeada, estruturas anônimas.~12 min
2. 5.2Métodos: valor vs receptor de ponteiro`func (p Pessoa) Olá()` vs `func (p *Person) Renomear(n string)`; quando usar um ou outro.~14 min
3. 5.3Composição (incorporação)Go não tem herança: você compõe incorporando um tipo dentro de outro. Promoção do método.~12 min
4. 5.4Tags de campo e JSON`json:"name,omitempty"`, empacotamento/desempacotamento com `encoding/json`, erros comuns.~12 min
5. 5.5O padrão de construtor `New...`Go não tem construtores: a convenção é uma função `NewT(...) *T` que valida e retorna erros.~10 min

Interfaces estruturais (sem implementos explícitos), asserções, opções de tipo e as interfaces padrão `Stringer` e `error`.

1. 6.1Interfaces: definindo um comportamentoUma interface é um conjunto de métodos; quem os implementa o satisfaz automaticamente (digitação estática de pato).~12 min
2. 6.2Afirmação de tipo`v, ok := i.(*MyT)`, a forma vírgula-ok para evitar pânico, quando preferir uma afirmação a uma troca de tipo.~10 min
3. 6.3Interruptor de tipo`switch v := x.(type) { case int: ... }` para despachar no tipo de tempo de execução.~10 min
4. 6.4A interface StringerA implementação de `String() string` altera a forma como `fmt.Println` representa seu tipo.~10 min
5. 6.5A interface de erro`error` é apenas `Error() string`; criando erros personalizados, `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`.~14 min

Modelo de simultaneidade do Go: goroutines leves, canais para comunicação, `select`, sincronização e contexto.

1. 7.1Goroutines: paralelismo leve`go f()`, o custo de uma goroutine, por que main sai sem esperar e como sincronizar.~12 min
2. 7.2Canais: comunicação digitada`ch := make(chan int)`, `ch <- v`, `v := <-ch`, canais com buffer vs sem buffer, fechamento.~15 min
3. 7.3`select`: multiplexação de canaisAguarde o primeiro canal pronto, o caso `default` para evitar bloqueio, o padrão de timeout com `time.After`.~12 min
4. 7.4`sync.Mutex` e `sync.WaitGroup`Quando os canais não são suficientes: proteja o estado compartilhado com um Mutex, aguarde N goroutines com um WaitGroup.~14 min
5. 7.5`context.Context`: cancelamento e prazosPropague o cancelamento entre goroutines, `context.WithTimeout`, `ctx.Done()`, o padrão do primeiro parâmetro.~14 min

Os pacotes que você usará todos os dias: fmt, strings, strconv, io, os, time, encoding/json.

1. 8.1`fmt` avançado`Sprintf`, `Fprintf`, os verbos `%+v` e `%#v`, formatação de largura e precisão, os sinalizadores `-` e `0`.~10 min
2. 8.2`strings` e `strconv``strings.Contains/Split/Join/TrimSpace`, `strconv.Itoa/Atoi/ParseInt/FormatFloat`.~12 min
3. 8.3`io` e `os`: arquivos e streams`os.Open/Create/ReadFile/WriteFile`, as interfaces `io.Reader/Writer`, o padrão `defer f.Close()`.~14 min
4. 8.4O pacote `time``time.Now()`, durações, análise com o layout de referência `2006-01-02 15:04:05`, temporizadores e tickers.~12 min
5. 8.5`codificação/json``json.Marshal/Unmarshal`, tags struct, `json.Decoder/Encoder` para streams, erros de análise.~14 min

A ferramenta `go test`, testes baseados em tabelas, benchmarks, gerenciamento de dependências com `go mod` e tags de construção.

1. 9.1O pacote `testing`Arquivos `*_test.go`, funções `TestXxx(t *testing.T)`, `t.Error` vs `t.Fatal`, `go test ./...`.~12 min
2. 9.2Testes baseados em tabelaO padrão idiomático: uma fatia de estruturas anônimas com entradas e saídas esperadas, `t.Run(name, ...)` para subtestes.~14 min
3. 9.3Benchmarks e perfisfunções `BenchmarkXxx(b *testing.B)`, o `for i := 0; eu < b.N; i++` loop, `go test -bench=.`.~12 min
4. 9.4Vá módulos`go mod init`, `go get`, controle de versão de importação semântica, o arquivo de bloqueio `go.sum`, `go mod tidy`.~12 min
5. 9.5Crie restrições e tagsA diretiva `//go:build ...` para compilações multiplataforma, separando código de teste/integração, exemplos do mundo real.~10 min

Nomenclatura, tratamento avançado de erros, genéricos (Go 1.18+) e dois miniprojetos: uma CLI e um servidor HTTP.

1. 10.1Convenções e estilo de nomenclaturaPascalCase para exportações, camelCase para locais, nomes abreviados em escopos curtos, `gofmt` não é negociável.~10 min
2. 10.2Tratamento de erros idiomáticosErros do Sentinel (`io.EOF`), erros personalizados com `Unwrap`, encapsulamento com `%w`, quando usar `panic`.~14 min
3. 10.3Genéricos (Ir 1.18+)Parâmetros de tipo `func Map[T, U any](s []T, f func(T) U) []U`, restrições (`comparable`, custom), trade-offs.~15 min
4. 10.4Miniprojeto: uma CLI com sinalizadoresO pacote `flag`, comandos e subcomandos, códigos de saída, `log` vs `fmt` para saída.~18 min
5. 10.5Miniprojeto: um servidor HTTP`net/http`, manipulador e roteador mínimo, middleware como decoradores, desligamento elegante com contexto.~18 min