---

Guia de Referência Go: Do Básico ao Avançado

Este documento é um resumo consolidado dos principais conceitos da linguagem Go e seu ecossistema, ideal para quem está começando ou quer reforçar seus conhecimentos.

Última atualização: 05 de julho de 2025

Índice

1. Fundamentos da Linguagem Go
   • Estrutura de um Programa Básico
   • O Papel da func main
2. Gerenciamento de Dependências com Go Modules
   • A Importância do go.mod (A "Lista de Materiais")
   • O Papel do go.sum (O "Lacre de Segurança")
   • O Fluxo de Trabalho Correto
3. Concorrência com Goroutines
   • O que é uma Goroutine?
   • Exemplo Prático
4. Ferramentas Essenciais (go command)
5. Erros Comuns e Soluções
6. Boas Práticas com Git e GitHub
   • O que Enviar para o Repositório?
   • O que Ignorar (Exemplo de .gitignore)
7. Outros Conceitos de Desenvolvimento Discutidos

1. Fundamentos da Linguagem Go

Estrutura de um Programa Básico (Olá, Mundo!)

Todo programa executável em Go precisa de uma estrutura mínima para funcionar.

// 1. Declaração do pacote principal
package main

// 2. Importação de pacotes externos
import "fmt"

// 3. O ponto de entrada do programa
func main() {
    // 4. A ação a ser executada
    fmt.Println("Olá, Mundo!")
}

• package main: Define o código como um programa executável.
• import "fmt": Importa a biblioteca padrão fmt para formatação e impressão de texto.
• func main(): É a função que é executada quando o programa inicia.

O Papel da func main

Tecnicamente, func main é:

• O Ponto de Entrada (Entry Point): Onde o runtime do Go começa a executar o seu código.
• A Goroutine Principal: A primeira goroutine a rodar. O programa termina assim que ela finaliza.

---

2. Gerenciamento de Dependências com Go Modules

Go Modules é o sistema que gerencia as bibliotecas externas (dependências) do seu projeto.

A Importância do go.mod (A "Lista de Materiais")

Este arquivo é o manifesto do seu projeto. Ele é crucial porque:

• Define a identidade do seu projeto (module ...).
• Lista as versões exatas de todas as suas dependências diretas e indiretas (require ...).
• Garante Builds Reproduzíveis: Qualquer pessoa, em qualquer máquina, a qualquer momento, irá compilar o projeto usando as mesmas versões de dependências, evitando o problema do "na minha máquina funciona".

O Papel do go.sum (O "Lacre de Segurança")

Este arquivo contém as checksums (assinaturas criptográficas) de cada dependência. Ele garante que o código que você baixa é autêntico e não foi alterado ou corrompido.

O Fluxo de Trabalho Correto

1. Você adiciona um import "nome/do/pacote" no seu código .go.
2. Você roda o comando go mod tidy no terminal.
3. A ferramenta do Go inspeciona seu código, encontra o novo import, adiciona a dependência ao go.mod e ao go.sum, e baixa o código da biblioteca.

---

3. Concorrência com Goroutines

O que é uma Goroutine?

É a forma como o Go lida com tarefas concorrentes. Pense nela como uma "thread" extremamente leve e barata, gerenciada pelo runtime do Go, e não diretamente pelo sistema operacional. É possível ter milhões de goroutines rodando simultaneamente.

A criação é simples, usando a palavra-chave go.

Exemplo Prático

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    // WaitGroup é usado para esperar as goroutines terminarem.
    var wg sync.WaitGroup

    // Adiciona 1 ao contador do WaitGroup.
    wg.Add(1)
    
    // Inicia a função em uma nova goroutine.
    go func() {
        // Defer garante que Done() seja chamado ao final da função.
        defer wg.Done()
        fmt.Println("Executando em outra goroutine...")
        time.Sleep(1 * time.Second)
    }()

    fmt.Println("A main continua seu trabalho...")
    
    // Espera até que o contador do WaitGroup chegue a zero.
    wg.Wait()
    fmt.Println("A goroutine terminou. Fim do programa.")
}

---

4. Ferramentas Essenciais (go command)

A ferramenta go é o canivete suíço do desenvolvedor. Os comandos mais importantes são:

Comando	Descrição
go run	Compila e executa o programa. Ideal para testes rápidos.
go build	Apenas compila o programa, gerando um executável.
go test	Executa os testes do projeto.
go mod tidy	Sincroniza o go.mod com as importações do código.
go fmt	Formata o código-fonte automaticamente segundo as regras do Go.
go vet	Analisa o código em busca de erros e construções suspeitas.
go install	Compila e instala o binário em um diretório global.
go doc	Mostra a documentação de um pacote ou função.

---

5. Erros Comuns e Soluções

• Problema: go: no go files listed

  • Causa: Você está tentando rodar um comando go em uma pasta que não contém arquivos .go.
  • Solução: Use o comando cd para navegar até a pasta correta do seu projeto.

• Problema: could not import [pacote] (no required module provides package ...)

  • Causa: Você adicionou um import no seu código, mas não atualizou o go.mod.
  • Solução: Rode go mod tidy no terminal para que o Go adicione a nova dependência ao seu go.mod.

---

6. Boas Práticas com Git e GitHub

O que Enviar para o Repositório?

• SIM: Todos os seus arquivos de código (.go).
• SIM: O arquivo go.mod.
• SIM: O arquivo go.sum.
• SIM: O arquivo .gitignore e outros arquivos de configuração (README.md, Dockerfile, etc.).

O que Ignorar (Exemplo de .gitignore)

Crie um arquivo chamado .gitignore na raiz do projeto para dizer ao Git o que não deve ser enviado.

# Binários compilados
meu-projeto
meu-projeto.exe

# Arquivos de ambiente com segredos
.env

# Pastas de configuração de editores de código
.vscode/
.idea/

# Arquivos de log
*.log

---

7. Outros Conceitos de Desenvolvimento Discutidos

Durante nossa conversa, também abordamos brevemente outros tópicos relevantes para o desenvolvimento de software moderno:

• WebSockets: Permitem comunicação bidirecional e persistente entre cliente e servidor, ideal para aplicações em tempo real.
• Funções de Seta (JS): Diferem de funções anônimas principalmente no tratamento do this, que é herdado do escopo pai (léxico).
• TypeScript strictNullChecks: Força o tratamento explícito de valores null e undefined, evitando uma classe inteira de bugs.
• Arquitetura de Microsserviços: Trata serviços como componentes independentes que podem ser implantados e atualizados de forma autônoma.
• Aplicações CLI: Programas controlados por texto via linha de comando, valorizados pela eficiência e capacidade de automação.