Go Academy · Aula

Pacotes: organizando código Go

Declarações de pacotes, imports e nomes exportados

Pacotes: organizando código Go é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O que é um pacote?

Todo arquivo de código-fonte Go pertence a um pacote. O nome do pacote aparece no início de cada arquivo. Os pacotes agrupam códigos relacionados e controlam a visibilidade:

// file: math/calc.go
package math

// Exported — accessible from other packages (capital letter)
func Add(a, b int) int { return a + b }

// Unexported — package-private (lowercase)
func helper() int { return 42 }

Declaração do pacote e caminho de importação

O nome do pacote (curto) é diferente do caminho de importação (caminho completo do módulo/diretório):

// Import path: github.com/myapp/util/stringutil
// Package name: stringutil (last segment by convention)
package stringutil

func Reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

Importando pacotes

Utilize import para incluir outros pacotes. Go exige que todas as importações sejam utilizadas:

package main

import (
    "fmt"                         // standard library
    "strings"                     // standard library
    "github.com/myapp/util/math"  // third-party or local
)

func main() {
    fmt.Println(strings.ToUpper("hello"))
    fmt.Println(math.Add(1, 2))
}

Identificadores exportados e não exportados

Identificadores que começam com uma letra maiúscula são exportados (públicos). Os que começam com uma letra minúscula são não exportados (privados do pacote):

package server

// Exported: accessible from other packages
type Server struct {
    Addr    string   // exported field
    timeout int      // unexported field
}

// Exported method
func (s *Server) Start() error { return nil }

// Unexported helper
func (s *Server) listen() {}

O pacote main e a função main

O pacote main é especial — ele define um executável. A função main é o ponto de entrada:

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
    // Program starts here and ends here
}

// All other packages are libraries — no main() needed

Função init()

Cada pacote pode ter uma ou mais funções init(), que são executadas antes de main(), automaticamente e na ordem de declaração:

package config

import "fmt"

var DB string

func init() {
    DB = "localhost:5432/mydb"
    fmt.Println("config package initialized")
}

// init runs once when the package is first imported
// Multiple init() functions per file/package are allowed

Importação em branco para efeitos colaterais

Importe um pacote apenas pelos efeitos colaterais de sua função init(), usando o identificador em branco:

package main

import (
    "database/sql"
    _ "github.com/lib/pq"  // registers PostgreSQL driver via init()
)

func main() {
    db, err := sql.Open("postgres", "host=localhost dbname=test")
    _ = db
    _ = err
}

Importações com alias

Renomeie um pacote ao importá-lo para evitar colisões de nomes ou por concisão:

package main

import (
    "fmt"
    gomath "math"              // alias to avoid collision
    mymath "github.com/me/math"
)

func main() {
    fmt.Println(gomath.Sqrt(16))     // 4
    fmt.Println(mymath.Add(1, 2))    // 3
}

Convenções de nomenclatura de pacotes

Convenções de nomenclatura de pacotes Go:

Curto, em minúsculas e com uma única palavra: http, json, fmt
Coincida com o nome do diretório: util/stringutil/ → pacote stringutil
Não use sublinhados nem camelCase nos nomes dos pacotes
Evite nomes genéricos como util, common, helper
O nome do pacote faz parte do identificador: prefira http.Client a httplib.HTTPClient

Importações circulares

Go NOT permite importações circulares. O pacote A não pode importar B se B importar A. Resolva isso extraindo o código compartilhado para um terceiro pacote:

// WRONG: A imports B, B imports A — compile error
// package a imports "myapp/b"
// package b imports "myapp/a"

// SOLUTION: extract shared types to package c
// package a imports "myapp/c"
// package b imports "myapp/c"
// No circular dependency

Verificação rápida

O que torna um identificador exportado em Go?

Recapitulação: pacotes

Principais conceitos sobre pacotes:

Todo arquivo começa com package name
Maiúsculas = exportado (público), minúsculas = não exportado (privado do pacote)
Importe pelo caminho completo e utilize pelo nome curto do pacote
init() é executada automaticamente antes de main()
Importação em branco _ "pkg" apenas para efeitos colaterais
Importações circulares não são permitidas

Perguntas Frequentes

A aula “Pacotes: organizando código Go” é grátis?

Sim — o texto completo de “Pacotes: organizando código Go” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Pacotes: organizando código Go”?

Declarações de pacotes, imports e nomes exportados Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Pacotes: organizando código Go”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy