Go Academy · Lección

Packages: organización del código Go

Declaraciones de package, imports y nombres exportados

Packages: organización del código Go es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

¿Qué es un paquete?

Cada archivo de código fuente de Go pertenece a un paquete. El nombre del paquete aparece al principio de cada archivo. Los paquetes agrupan código relacionado y controlan la visibilidad:

// 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 }

Declaración del paquete y ruta de importación

El nombre del paquete (corto) es diferente de la ruta de importación (ruta completa del módulo/directorio):

// 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)
}

Importar paquetes

Use import para incorporar otros paquetes. Go requiere que se utilicen todas las importaciones:

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 y no exportados

Los identificadores que comienzan con una letra mayúscula están exportados (son públicos). Los que comienzan con una letra minúscula no están exportados (son privados del paquete):

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() {}

El paquete main y func main

El paquete main es especial: define un ejecutable. La función main es el punto 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

Función init()

Cada paquete puede tener una o más funciones init(), que se ejecutan antes de main(), automáticamente y en el orden en que se declaran:

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

Importación en blanco para efectos secundarios

Importe un paquete únicamente por los efectos secundarios de su función init() mediante el identificador en blanco:

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
}

Importaciones con alias

Cambie el nombre de un paquete al importarlo para evitar conflictos de nombres o abreviarlo:

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
}

Convenciones para nombrar paquetes

Convenciones para nombrar paquetes en Go:

Cortos, en minúsculas y de una sola palabra: http, json, fmt
Coinciden con el nombre del directorio: util/stringutil/ → paquete stringutil
No use guiones bajos ni camelCase en los nombres de paquetes
Evite nombres genéricos como util, common y helper
El nombre del paquete forma parte del identificador: prefiera http.Client a httplib.HTTPClient

Importaciones circulares

Go NO permite importaciones circulares. El paquete A no puede importar B si B importa A. Resuélvalo extrayendo el código compartido a un tercer paquete:

// 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

Comprobación rápida

¿Qué hace que un identificador esté exportado en Go?

Resumen: paquetes

Conceptos clave sobre los paquetes:

Cada archivo comienza con package name
Mayúscula = exportado (público), minúscula = no exportado (privado del paquete)
Importe mediante la ruta completa y use el nombre corto del paquete
init() se ejecuta automáticamente antes de main()
Importación en blanco _ "pkg" únicamente para efectos secundarios
No se permiten importaciones circulares

Preguntas frecuentes

¿La lección «Packages: organización del código Go» es gratis?

Sí — el texto completo de «Packages: organización del código Go» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Packages: organización del código Go»?

Declaraciones de package, imports y nombres exportados Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Packages: organización del código Go»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy