DEV Community: Eduardo Betim Rosa

Guia de Estudo Go 1

Eduardo Betim Rosa — Tue, 13 May 2025 21:52:25 +0000

Guia de Estudo: Linguagem de Programação Go

Este guia abrange os principais conceitos da linguagem Go (Golang), desde fundamentos até tópicos avançados como concorrência e gerenciamento de pacotes.

📌 Conceitos Fundamentais

Variáveis e Tipos de Dados

Declaração: Use var com tipo explícito ou := para inferência
Escopo: Variáveis podem ser globais ou locais
Valor Zero: Valores padrão para tipos não inicializados
Tipos Numéricos: int, float, uint com vários tamanhos
Conversão: Requer conversão explícita entre tipos

Estruturas de Controle

Condicionais: if, if-else com possível instrução curta
Switch: Simplifica múltiplas condições
Loops: Único tipo for com várias variações
Controle de Loop: break, continue, range

🧩 Estruturas de Dados

Fatias e Matrizes

Característica	Matriz	Fatia
Tamanho	Fixo	Dinâmico
Redimensionamento	Não	Sim
Subjacente	-	Matriz

Operações comuns: append(), copy(), fatiamento

Mapas

Coleções chave-valor não ordenadas
Acesso com map[key], verificação com value, ok := map[key]
Pacote maps para utilitários (Go 1.21+)

🛠️ Funcionalidades Avançadas

Funções

Variádicas: Aceitam número variável de argumentos (...)
Anônimas: Funções sem nome atribuíveis a variáveis
defer: Execução adiada até o retorno da função
Métodos: Associados a tipos (structs)

Concorrência

go minhaFuncao()  // Goroutine
ch := make(chan int)  // Canal

// Exemplo com WaitGroup
var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    // trabalho concorrente
}()
wg.Wait()

📦 Gerenciamento de Pacotes

Módulos Go

go mod init [caminho]
go mod tidy (gerencia dependências)
Estrutura típica:

   /projeto
     go.mod
     go.sum
     /cmd
     /pkg
     /internal

🔍 Quiz Rápido

Matriz vs Fatia: Matriz tem tamanho fixo, fatia é dinâmica
Declaração curta: x := 42
Valor zero: 0 para int, 0.0 para float
defer: Execução adiada, útil para limpeza
range: Índice/valor para fatias, chave/valor para mapas

📚 Glossário

Termo	Definição
Goroutine	Função leve concorrente
Channel	Mecanismo de comunicação entre goroutines
Mutex	Sincronização para acesso seguro
Zero Value	Valor padrão de tipos não inicializados
pprof	Ferramenta de análise de desempenho

🚀 Próximos Passos

Explore pacotes padrão como net/http para web
Pratique concorrência com canais e WaitGroups
Experimente criação de pacotes customizados

Este guia oferece uma visão geral abrangente da linguagem Go. Para aprofundamento, consulte a documentação oficial.

Guia de Estudo Go 2

Eduardo Betim Rosa — Tue, 13 May 2025 21:48:52 +0000

Guia de Estudo: Linguagem de Programação Go

Este guia de estudo sobre a linguagem de programação Go, com foco em conceitos fundamentais, estruturas de controle, manipulação de dados e pacotes padrão.

Variáveis e Tipos de Dados

Declaração de Variáveis: Variáveis podem ser declaradas usando a palavra-chave var com um tipo explícito ou usando a declaração curta :=, onde o Go infere o tipo.

Variáveis Globais vs. Locais: Variáveis declaradas fora de qualquer função são globais; variáveis declaradas dentro de uma função são locais.

Valor Zero: Variáveis não inicializadas em Go são automaticamente atribuídas o valor zero de seu tipo de dado. Para um int é 0, para um float64 é 0.0.

Tipos de Dados Numéricos: Incluem inteiros (assinados e não assinados, com tamanhos específicos como int8, int16, int32, int64, além do int e uint dependentes da máquina), e pontos flutuantes (float32, float64). uint8 é um alias para byte.

Inferência de Tipo: Go pode inferir o tipo de uma variável a partir do valor atribuído durante a declaração curta :=.

Conversão de Tipo: A conversão explícita de tipo é necessária ao converter entre tipos de dados numéricos para garantir o resultado desejado, especialmente em operações como divisão.

Estruturas de Controle

if/if-else: Usado para execução condicional. Pode incluir uma instrução curta antes da condição, com variáveis declaradas dentro do escopo do if.

switch: Simplifica múltiplas condições. A execução continua para o próximo case por padrão, a menos que break seja usado (ou um fallthrough).

Laços for: A única estrutura de laço em Go. Pode ser usada como um laço tradicional (com inicializador, condição e instrução pós), como um laço while (apenas com condição), como um laço infinito (for {}), ou com a palavra-chave range.

break: Sai de um laço.

continue: Pula a iteração atual de um laço.

range: Usado para iterar sobre coleções como fatias, mapas, strings e canais. Retorna o índice/chave e o valor para cada elemento. Pode-se usar _ para ignorar valores retornados indesejados.

Fatias e Matrizes

Matrizes: Têm um tamanho fixo definido no momento da criação.

Fatias: Semelhantes a matrizes, mas são redimensionáveis. Fatias são construídas sobre matrizes subjacentes.

Criação de Fatias: Podem ser criadas com literais (ex: []int{-1, 2, 1, -1, 2, -2}) ou usando make([]tipo, comprimento, capacidade).

Comprimento e Capacidade: O comprimento de uma fatia (len()) é o número de elementos que ela contém. A capacidade (cap()) é o número máximo de elementos que a fatia pode conter sem realocar a matriz subjacente. A capacidade geralmente dobra quando o comprimento excede a capacidade atual.

Seleção de Fatias: Elementos ou sub-fatias podem ser selecionados usando notação de fatiamento ([baixo:alto], [baixo:], [:alto], [baixo:alto:capacidade]).

append(): Usado para adicionar elementos a uma fatia. Pode expandir uma fatia de outro ao usar o operador ....

copy(): Copia elementos de uma fatia de origem para uma fatia de destino. O número de elementos copiados é o mínimo dos comprimentos das duas fatias.

Exclusão de Elementos: Não há uma função interna para excluir elementos de uma fatia sem usar pacotes adicionais; técnicas comuns envolvem usar append para construir uma nova fatia sem o elemento excluído.

Fatias de Byte: Uma fatia do tipo de dado byte ([]byte).

Pacote slices: Fornece funções utilitárias para trabalhar com fatias, como Clone(), Clip(), Replace(), Min(), Max(), Contains(), Sort(), Compact().

Mapas

Criação de Mapas: Mapas são coleções não ordenadas de pares chave-valor. Eles podem ser criados usando make(map[tipoChave]tipoValor).

Acesso a Elementos: Os elementos podem ser acessados usando a sintaxe aMap[chave]. A tentativa de acessar uma chave inexistente retorna o valor zero do tipo do valor sem erro.

Verificação de Existência: A sintaxe v, ok := aMap[k] retorna o valor associado à chave k (v) e um booleano (ok) indicando se a chave existia no mapa.

Mapas nil: Um mapa declarado sem inicialização é nil. A tentativa de armazenar em um mapa nil causará um panic.

Iteração: Mapas podem ser iterados usando o laço for com a palavra-chave range. Ele retorna a chave e o valor para cada elemento. A ordem de iteração não é garantida.

Pacote maps: Fornece funções utilitárias para trabalhar com mapas, adicionado na versão 1.21 do Go.

Funções

Declaração de Função: Funções são declaradas usando a palavra-chave func.

Parâmetros e Valores de Retorno: As funções podem aceitar zero ou mais parâmetros e retornar zero ou mais valores.

Funções Variádicas: Funções que aceitam um número variável de argumentos do mesmo tipo, usando o operador ... no tipo do último parâmetro. Esses argumentos são tratados como uma fatia dentro da função.

Funções Anônimas: Funções sem nome que podem ser atribuídas a variáveis ou usadas como literais.

defer: Uma instrução defer adia a execução de uma função até que a função circundante retorne. Isso é comumente usado para operações de limpeza como fechar arquivos ou desbloquear mutexes.

Métodos de Tipo: Funções associadas a um tipo específico (struct). Podem operar no valor do tipo (receptor de valor) ou em um ponteiro para o tipo (receptor de ponteiro). Receptores de ponteiro são necessários para modificar a instância do tipo.

Tratamento de Erros

Tipo error: A interface padrão em Go para representar erros. Funções que podem falhar geralmente retornam um valor de seu resultado usual e um valor do tipo error.

Verificação de Erros: A abordagem comum é verificar se o valor error retornado é nil (if err != nil). Um valor de nil indica sucesso; um valor não nil indica que ocorreu um erro.

Erros Sentinela: Variáveis de erro predefinidas que representam condições de erro específicas (ex: io.EOF, errors.New("mensagem")).

Erros Customizados: Podem ser criados implementando a interface error.

panic e recover: panic é usado para erros irrecuperáveis, interrompendo o fluxo normal do programa. recover é usado dentro de funções defer para capturar e lidar com um panic, permitindo que o programa continue.

Arquivos e I/O

Pacote os: Fornece funções para interagir com o sistema operacional, incluindo manipulação de arquivos (abrir, criar, obter informações). os.Args é uma fatia de strings contendo argumentos de linha de comando.

Pacote io: Define interfaces para operações de I/O, como io.Reader e io.Writer.

Pacote bufio: Implementa I/O com buffer, como bufio.NewReader.

Pacote csv: Fornece funcionalidade para ler e escrever arquivos CSV.

io.EOF: Um erro sentinela retornado quando o final de um arquivo ou stream é alcançado.

Concorrência

Goroutines: Funções leves e concorrentes executadas pelo runtime do Go. Criadas prefixando uma chamada de função com a palavra-chave go.

Canais: Canais fornecem um meio para goroutines se comunicarem e sincronizarem.

Canais sem Buffer: Têm capacidade zero. O envio e recebimento em um canal sem buffer bloqueiam até que a goroutine correspondente esteja pronta.

Canais com Buffer: Têm capacidade maior que zero. O envio para um canal com buffer bloqueia apenas quando o buffer está cheio. O recebimento de um canal com buffer bloqueia apenas quando o buffer está vazio.

Direcionalidade do Canal: Canais podem ser declarados como somente envio (chan<-) ou somente recebimento (<-chan).

Fechamento de Canais: Canais podem ser fechados usando close(). Tentar enviar para um canal fechado causará um panic. Receber de um canal fechado retornará o valor zero do tipo do canal e um booleano indicando que o canal está fechado (em uma atribuição de dois valores). Iterar sobre um canal fechado com range terminará quando todos os valores restantes forem recebidos.

Canais nil: Canais declarados sem inicialização são nil. Enviar para, receber de e fechar um canal nil causará um panic.

select: Usado com canais para esperar por múltiplas operações de comunicação. Ele bloqueia até que uma das operações case esteja pronta para ser executada. Uma cláusula default em um select é executada imediatamente se nenhuma outra operação estiver pronta.

Pacote sync: Fornece primitivas de sincronização como sync.Mutex e sync.WaitGroup.

sync.Mutex: Usado para proteger seções críticas de código, garantindo que apenas uma goroutine possa acessar dados compartilhados por vez. Lock() adquire o bloqueio, Unlock() libera o bloqueio. defer m.Unlock() é um padrão comum.

sync.WaitGroup: Usado para esperar que uma coleção de goroutines termine. Add() incrementa um contador, Done() decrementa o contador, Wait() bloqueia até que o contador seja zero.

Condição de Corrida: Ocorre quando múltiplas goroutines acessam dados compartilhados simultaneamente sem sincronização adequada, levando a resultados imprevisíveis. Mutexes são usados para evitar condições de corrida.

Sombreamento de Variáveis em Goroutines: Um problema comum onde goroutines em um laço podem capturar o valor final da variável do laço em vez do valor da iteração atual. Uma solução é criar uma nova variável dentro do laço para cada goroutine.

Pacotes e Módulos

Pacotes: A unidade de organização de código em Go. Um arquivo Go começa com package nome_do_pacote. main é um pacote especial para executáveis.

Importação de Pacotes: Pacotes são importados usando a palavra-chave import. Subdiretórios de pacotes padrão são importados usando a notação de barra (ex: net/http).

Módulos: Introduzidos no Go 1.11, módulos são a forma padrão de gerenciar dependências. Um módulo é definido por um arquivo go.mod, que lista as dependências do módulo.

Comandos go mod:

go mod init [caminho_do_módulo]: Inicializa um novo módulo e cria um arquivo go.mod. O caminho do módulo geralmente é o caminho para o repositório (ex: github.com/username/my-go-project).
go mod tidy: Baixa todas as dependências necessárias listadas no código-fonte e remove as não utilizadas. Estrutura do Workspace Go: Tradicionalmente, o código Go era organizado em um workspace definido pela variável de ambiente GOPATH, com subdiretórios bin, pkg e src. Embora os módulos tenham tornado GOPATH menos central, a estrutura de pacotes ainda segue padrões baseados em caminhos de repositório. Controle de Versão com Módulos: Os módulos Go usam versionamento semântico (major.minor.patch), prefixado com v. Mudanças de versão major (v2, v3, etc.) geralmente indicam incompatibilidades com versões anteriores.

Ferramentas e Utilitários

go run: Compila e executa um programa Go.

go doc: Exibe a documentação para pacotes ou símbolos.

tree(1): Um utilitário de linha de comando (não específico do Go) para exibir a estrutura de diretórios recursivamente.

Geração de Números Aleatórios: O pacote math/rand pode ser usado para gerar números pseudoaleatórios. É importante semear o gerador de números aleatórios (geralmente usando o tempo atual) para obter sequências diferentes a cada execução.

HTTP Server/Client: O pacote net/http fornece funcionalidade para criar servidores web e clientes HTTP.

API RESTful: Um estilo arquitetônico para APIs que usa solicitações HTTP para acessar e manipular recursos.

GraphQL: Uma linguagem de consulta para APIs e um runtime para atender a essas consultas com seus dados existentes. Define um esquema com tipos, consultas (Query), mutações (Mutation), etc.

Profile (pprof): Ferramentas integradas no Go para analisar o desempenho do programa (uso de CPU, memória). net/http/pprof fornece endpoints HTTP para acessar dados de profile. go tool pprof é usado para analisar os dados.

Tracing: Captura eventos durante a execução do programa para visualizar o fluxo de execução e gargalos. runtime/trace e net/http/pprof/trace são usados para tracing.

strconv: Pacote para converter strings de e para tipos de dados básicos (ex: Atoi para converter string para int, ParseFloat para converter string para float).

strings: Pacote que fornece funções utilitárias para manipulação de strings.

fmt: Pacote para I/O formatado (impressão). Printf permite formatação de saída usando verbos.

Quiz

Responda às seguintes perguntas em 2-3 frases cada.

Qual é a principal diferença entre uma matriz e uma fatia em Go, e como isso afeta seu uso?
Como você pode declarar uma variável local em Go e inicializá-la simultaneamente sem usar a palavra-chave var?
Explique o conceito de valor zero em Go e forneça exemplos para um tipo inteiro e um tipo de ponto flutuante.
Qual é a finalidade da palavra-chave defer em Go? Dê um exemplo de um caso de uso comum.
Como a palavra-chave range é usada com fatias e mapas, e o que ela retorna em cada caso?
Descreva a abordagem padrão para tratamento de erros em Go usando o tipo error.
O que são goroutines e como elas são iniciadas?
Qual é a diferença entre um canal sem buffer e um canal com buffer em Go?
Explique a finalidade de um sync.Mutex e como ele é usado para proteger dados compartilhados.
Como os módulos Go (go.mod) ajudam no gerenciamento de dependências?

Chave de Resposta do Quiz

A principal diferença é que uma matriz tem um tamanho fixo definido no momento da criação, enquanto uma fatia é redimensionável e construída sobre uma matriz subjacente. Isso torna as fatias mais flexíveis para coleções de dados de tamanho dinâmico.
Você pode usar a declaração curta de variável com o operador :=. Por exemplo, nome := "João" declara e inicializa uma variável string local chamada nome.
O valor zero é o valor padrão que o Go atribui a variáveis que não são explicitamente inicializadas. Para um int, o valor zero é 0. Para um float64, o valor zero é 0.0.
A palavra-chave defer adia a execução de uma função até que a função circundante retorne. Um caso de uso comum é garantir que os recursos (como arquivos ou bloqueios) sejam liberados, por exemplo, defer arquivo.Close().
Com fatias, range retorna o índice e o valor do elemento atual. Com mapas, range retorna a chave e o valor do par chave-valor atual.
A abordagem padrão envolve funções que retornam um valor regular e um valor do tipo error. O chamador verifica se o valor de error é nil para determinar se a operação foi bem-sucedida ou se ocorreu um erro.
Goroutines são funções leves e concorrentes que podem ser executadas simultaneamente. Elas são iniciadas prefixando uma chamada de função com a palavra-chave go, como em go minhaFuncao().
Um canal sem buffer tem capacidade zero e requer que o envio e o recebimento ocorram simultaneamente (bloqueia até que ambos estejam prontos). Um canal com buffer tem capacidade maior que zero, permitindo que os envios prossigam até que o buffer esteja cheio e os recebimentos prossigam até que o buffer esteja vazio.
Um sync.Mutex é usado para fornecer acesso exclusivo a dados compartilhados por múltiplas goroutines. Ele protege seções críticas de código usando Lock() antes de acessar os dados compartilhados e Unlock() depois, garantindo que apenas uma goroutine possa modificar os dados por vez.
Os módulos Go fornecem um sistema de gerenciamento de dependências que define as dependências de um projeto e suas versões no arquivo go.mod. Comandos como go mod tidy baixam e gerenciam essas dependências automaticamente, simplificando a construção e o compartilhamento de projetos.

Perguntas em Formato de Ensaio

Considere e prepare respostas detalhadas para as seguintes perguntas:

Discuta as diferentes maneiras de usar a estrutura de laço for em Go e forneça exemplos de cada uma, incluindo como a palavra-chave range é aplicada a diferentes tipos de dados.
Explique o conceito de gerenciamento de memória subjacente às fatias em Go, incluindo o relacionamento entre comprimento, capacidade e a matriz subjacente. Como as operações append e fatiamento afetam o comprimento e a capacidade de uma fatia?
Compare e contraste o tratamento de erros em Go usando o tipo error com mecanismos de tratamento de erros em outras linguagens de programação (se você tiver experiência). Discuta os benefícios e desvantagens da abordagem de Go.
Descreva como goroutines e canais trabalham juntos para permitir a concorrência em Go. Explique como os canais facilitam a comunicação e a sincronização entre goroutines e discuta o uso de canais sem buffer e com buffer.
Detalhe o processo de criação e uso de um pacote Go customizado. Inclua os passos para organizar o código, inicializar um módulo, gerenciar dependências e importar e usar o pacote em outro programa.

Glossário de Termos Chave

append(): Função interna para adicionar elementos a uma fatia.
Matriz: Uma coleção de elementos do mesmo tipo com um tamanho fixo.
Canal (Channel): Um canal de comunicação tipado através do qual goroutines podem enviar e receber valores.
Capacidade (Capacity): O número de elementos na matriz subjacente de uma fatia, começando no índice do primeiro elemento da fatia.
Condição de Corrida (Race Condition): Um problema de concorrência onde o resultado de um programa depende da ordem de execução de múltiplas goroutines acessando dados compartilhados.
Concorrência (Concurrency): A capacidade de um programa ter múltiplas tarefas em progresso ao mesmo tempo.
continue: Uma instrução usada em laços para pular a iteração atual.
copy(): Função interna para copiar elementos de uma fatia de origem para uma fatia de destino.
defer: Uma instrução que adia a execução de uma função até que a função circundante retorne.
Erro (Error): A interface padrão em Go para representar condições de erro.
Valor Zero (Zero Value): O valor padrão atribuído a variáveis não inicializadas em Go.
Laço for: A única estrutura de laço em Go, usada para iteração.
Goroutine: Uma função leve e concorrente executada pelo runtime do Go.
if: Uma instrução usada para execução condicional.
Inferência de Tipo (Type Inference): A capacidade do compilador Go de determinar o tipo de uma variável a partir de seu valor.
Comprimento (Length): O número de elementos atualmente em uma fatia.
sync.Mutex: Uma primitiva de sincronização usada para proteger seções críticas de código.
Módulo (Module): Uma coleção de pacotes Go, usada para gerenciamento de dependências. Definido por um arquivo go.mod.
panic: Um erro de runtime que interrompe o fluxo normal do programa.
Pacote (Package): A unidade fundamental de código em Go.
pprof: Ferramentas de profile em Go para analisar o desempenho.
range: Uma palavra-chave usada com o laço for para iterar sobre coleções.
recover: Uma função usada dentro de funções defer para capturar e lidar com um panic.
Fatia (Slice): Uma coleção tipada que é um segmento dinâmico de uma matriz subjacente.
switch: Uma instrução usada para executar blocos de código diferentes com base no valor de uma expressão.
Sincronização (Synchronization): Coordenar a execução de goroutines para evitar condições de corrida e garantir o comportamento correto.
Erros Sentinela (Sentinel Errors): Variáveis de erro predefinidas que representam condições de erro específicas.
Sombreamento de Variáveis (Variable Shadowing): Quando uma variável declarada em um escopo aninhado tem o mesmo nome que uma variável em um escopo externo.
Função Variádica (Variadic Function): Uma função que aceita um número variável de argumentos do mesmo tipo.
sync.WaitGroup: Uma primitiva de sincronização usada para esperar que um conjunto de goroutines termine.
Workspace Go: A estrutura de diretórios tradicional para organizar código Go (agora em grande parte substituída por módulos).