Paquetes, Modulos y Herramientas en Go — Curso Go #8

1// Archivo: main.go
2package main // Este archivo pertenece al paquete "main"
3
4import "fmt" // Importar el paquete "fmt" de la biblioteca estandar
5
6func main() {
7    fmt.Println("Hola desde el paquete main")
8}

1package calculadora
2
3// Sumar es exportada - otros paquetes pueden usarla
4func Sumar(a, b int) int {
5    return a + b
6}
7
8// validar NO es exportada - solo se usa dentro de este paquete
9func validar(n int) bool {
10    return n >= 0
11}
12
13// Pi es una constante exportada
14const Pi = 3.14159
15
16// maxIntentos es una constante privada
17const maxIntentos = 5

1# Crear un directorio para tu proyecto
2mkdir mi-proyecto
3cd mi-proyecto
4
5# Inicializar el modulo
6go mod init github.com/tu-usuario/mi-proyecto
7
8# Esto crea el archivo go.mod

1module github.com/tu-usuario/mi-proyecto
2
3go 1.22

1# Descargar una dependencia
2go get github.com/gin-gonic/gin
3
4# Limpiar dependencias no usadas y descargar las que faltan
5go mod tidy
6
7# Ver todas las dependencias
8go list -m all
9
10# Actualizar una dependencia
11go get -u github.com/gin-gonic/gin
12
13# Actualizar todas las dependencias
14go get -u ./...

1mi-proyecto/
2  go.mod
3  main.go
4  utils/
5    math.go
6    strings.go

1// Archivo: utils/math.go
2package utils
3
4import "math"
5
6// DistanciaEuclidiana calcula la distancia entre dos puntos 2D
7func DistanciaEuclidiana(x1, y1, x2, y2 float64) float64 {
8    dx := x2 - x1
9    dy := y2 - y1
10    return math.Sqrt(dx*dx + dy*dy)
11}
12
13// EsPrimo verifica si un numero es primo
14func EsPrimo(n int) bool {
15    if n < 2 {
16        return false
17    }
18    for i := 2; i*i <= n; i++ {
19        if n%i == 0 {
20            return false
21        }
22    }
23    return true
24}

1// Archivo: utils/strings.go
2package utils
3
4import "strings"
5
6// Capitalizar pone en mayuscula la primera letra de cada palabra
7func Capitalizar(s string) string {
8    return strings.Title(s)
9}
10
11// ContarPalabras cuenta las palabras en un texto
12func ContarPalabras(s string) int {
13    campos := strings.Fields(s)
14    return len(campos)
15}

1// Archivo: main.go
2package main
3
4import (
5    "fmt"
6    "github.com/tu-usuario/mi-proyecto/utils"
7)
8
9func main() {
10    // Usar funciones de nuestro paquete utils
11    dist := utils.DistanciaEuclidiana(0, 0, 3, 4)
12    fmt.Printf("Distancia: %.2f\n", dist) // 5.00
13
14    fmt.Println(utils.EsPrimo(17))        // true
15    fmt.Println(utils.ContarPalabras("Hola mundo desde Go")) // 4
16}

1package main
2
3import (
4    "fmt"
5    "math"
6    "sort"
7    "strings"
8    "strconv"
9    "time"
10)
11
12func main() {
13    // strings
14    fmt.Println(strings.ToUpper("hola"))           // HOLA
15    fmt.Println(strings.Contains("golang", "go"))  // true
16    fmt.Println(strings.Split("a,b,c", ","))       // [a b c]
17    fmt.Println(strings.Join([]string{"x","y"}, "-")) // x-y
18
19    // strconv
20    num, _ := strconv.Atoi("42")
21    fmt.Println(num + 8) // 50
22    texto := strconv.Itoa(100)
23    fmt.Println(texto) // "100"
24
25    // math
26    fmt.Println(math.Max(10, 20))  // 20
27    fmt.Println(math.Ceil(3.2))    // 4
28
29    // sort
30    nums := []int{5, 3, 8, 1, 9}
31    sort.Ints(nums)
32    fmt.Println(nums) // [1 3 5 8 9]
33
34    // time
35    ahora := time.Now()
36    fmt.Println(ahora.Format("2006-01-02 15:04:05"))
37}

1# Instalar un paquete popular para APIs web
2go get github.com/gin-gonic/gin
3
4# Instalar un ORM
5go get gorm.io/gorm
6go get gorm.io/driver/sqlite
7
8# Instalar un paquete para variables de entorno
9go get github.com/joho/godotenv

1package main
2
3import (
4    "github.com/gin-gonic/gin"
5)
6
7func main() {
8    r := gin.Default()
9    r.GET("/", func(c *gin.Context) {
10        c.JSON(200, gin.H{"message": "Hola mundo"})
11    })
12    r.Run(":8080")
13}

1# Compilar y ejecutar
2go run main.go           # Compilar y ejecutar en un paso
3go build -o mi-app .     # Compilar a un binario ejecutable
4
5# Formatear codigo (obligatorio en Go)
6go fmt ./...             # Formatea todos los archivos del proyecto
7gofmt -w main.go         # Formatea un archivo especifico
8
9# Analisis estatico
10go vet ./...             # Detecta errores comunes que el compilador no encuentra
11
12# Testing
13go test ./...            # Ejecutar todos los tests
14go test -v ./...         # Tests con salida detallada
15go test -cover ./...     # Tests con reporte de cobertura
16go test -race ./...      # Tests con detector de race conditions
17
18# Documentacion
19go doc fmt               # Ver documentacion del paquete fmt
20go doc fmt.Println       # Ver documentacion de una funcion especifica
21
22# Dependencias
23go mod init modulo       # Inicializar modulo
24go mod tidy              # Limpiar dependencias
25go get paquete           # Descargar paquete

1mi-proyecto/
2  cmd/                  # Puntos de entrada (ejecutables)
3    server/
4      main.go
5    cli/
6      main.go
7  internal/             # Codigo privado (no importable por otros proyectos)
8    database/
9      connection.go
10    auth/
11      jwt.go
12  pkg/                  # Codigo publico (importable por otros proyectos)
13    validator/
14      email.go
15  config/               # Archivos de configuracion
16    config.go
17    config.json
18  go.mod
19  go.sum
20  README.md

1package main
2
3import (
4    "encoding/json"
5    "fmt"
6)
7
8type Usuario struct {
9    Nombre   string   "json:\"nombre\""
10    Email    string   "json:\"email\""
11    Edad     int      "json:\"edad\""
12    Activo   bool     "json:\"activo\""
13    Roles    []string "json:\"roles,omitempty\""
14    Password string   "json:\"-\""  // Nunca se serializa
15}
16
17func main() {
18    // Struct a JSON (Marshal)
19    usuario := Usuario{
20        Nombre: "Ana Garcia",
21        Email:  "[email protected]",
22        Edad:   28,
23        Activo: true,
24        Roles:  []string{"admin", "editor"},
25        Password: "secreto123",
26    }
27
28    jsonBytes, err := json.MarshalIndent(usuario, "", "  ")
29    if err != nil {
30        fmt.Println("Error:", err)
31        return
32    }
33    fmt.Println(string(jsonBytes))
34    // {
35    //   "nombre": "Ana Garcia",
36    //   "email": "[email protected]",
37    //   "edad": 28,
38    //   "activo": true,
39    //   "roles": ["admin", "editor"]
40    // }
41    // Nota: Password no aparece gracias a json:"-"
42
43    // JSON a Struct (Unmarshal)
44    jsonStr := "{\"nombre\":\"Carlos\",\"email\":\"[email protected]\",\"edad\":35,\"activo\":true}"
45    var usuario2 Usuario
46    err = json.Unmarshal([]byte(jsonStr), &usuario2)
47    if err != nil {
48        fmt.Println("Error:", err)
49        return
50    }
51    fmt.Printf("Nombre: %s, Email: %s\n", usuario2.Nombre, usuario2.Email)
52}

1package main
2
3import (
4    "fmt"
5    "os"
6)
7
8func getEnv(key, defaultValue string) string {
9    value := os.Getenv(key)
10    if value == "" {
11        return defaultValue
12    }
13    return value
14}
15
16func main() {
17    // Leer variables de entorno con valores por defecto
18    puerto := getEnv("PORT", "8080")
19    dbHost := getEnv("DB_HOST", "localhost")
20    dbName := getEnv("DB_NAME", "mi_base_datos")
21    entorno := getEnv("GO_ENV", "development")
22
23    fmt.Printf("Servidor en puerto: %s\n", puerto)
24    fmt.Printf("Base de datos: %s@%s\n", dbName, dbHost)
25    fmt.Printf("Entorno: %s\n", entorno)
26}

1package main
2
3import (
4    "encoding/json"
5    "fmt"
6    "os"
7    "sort"
8    "strings"
9)
10
11// Config representa la configuracion de la aplicacion
12type Config struct {
13    AppName     string   "json:\"app_name\""
14    Version     string   "json:\"version\""
15    Port        int      "json:\"port\""
16    Debug       bool     "json:\"debug\""
17    AllowedHosts []string "json:\"allowed_hosts\""
18    Database    DBConfig "json:\"database\""
19}
20
21type DBConfig struct {
22    Host     string "json:\"host\""
23    Port     int    "json:\"port\""
24    Name     string "json:\"name\""
25    User     string "json:\"user\""
26    SSLMode  string "json:\"ssl_mode\""
27}
28
29func cargarConfig(ruta string) (Config, error) {
30    var config Config
31
32    data, err := os.ReadFile(ruta)
33    if err != nil {
34        return config, fmt.Errorf("no se pudo leer el archivo: %w", err)
35    }
36
37    err = json.Unmarshal(data, &config)
38    if err != nil {
39        return config, fmt.Errorf("JSON invalido: %w", err)
40    }
41
42    return config, nil
43}
44
45func validarConfig(config Config) []string {
46    var errores []string
47
48    if config.AppName == "" {
49        errores = append(errores, "app_name es obligatorio")
50    }
51    if config.Port < 1 || config.Port > 65535 {
52        errores = append(errores, "port debe estar entre 1 y 65535")
53    }
54    if config.Database.Host == "" {
55        errores = append(errores, "database.host es obligatorio")
56    }
57    if config.Database.Name == "" {
58        errores = append(errores, "database.name es obligatorio")
59    }
60
61    return errores
62}
63
64func mostrarReporte(config Config) {
65    separador := strings.Repeat("=", 50)
66
67    fmt.Println(separador)
68    fmt.Printf("  Aplicacion: %s v%s\n", config.AppName, config.Version)
69    fmt.Println(separador)
70    fmt.Printf("  Puerto:     %d\n", config.Port)
71    fmt.Printf("  Debug:      %v\n", config.Debug)
72
73    if len(config.AllowedHosts) > 0 {
74        sort.Strings(config.AllowedHosts)
75        fmt.Printf("  Hosts:      %s\n", strings.Join(config.AllowedHosts, ", "))
76    }
77
78    fmt.Println()
79    fmt.Println("  Base de datos:")
80    fmt.Printf("    Host:     %s:%d\n", config.Database.Host, config.Database.Port)
81    fmt.Printf("    Nombre:   %s\n", config.Database.Name)
82    fmt.Printf("    Usuario:  %s\n", config.Database.User)
83    fmt.Printf("    SSL:      %s\n", config.Database.SSLMode)
84    fmt.Println(separador)
85}
86
87func main() {
88    // Determinar la ruta del archivo de configuracion
89    ruta := "config.json"
90    if len(os.Args) > 1 {
91        ruta = os.Args[1]
92    }
93
94    fmt.Printf("Cargando configuracion desde: %s\n\n", ruta)
95
96    config, err := cargarConfig(ruta)
97    if err != nil {
98        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
99        os.Exit(1)
100    }
101
102    // Validar la configuracion
103    errores := validarConfig(config)
104    if len(errores) > 0 {
105        fmt.Println("Errores de validacion:")
106        for _, e := range errores {
107            fmt.Printf("  - %s\n", e)
108        }
109        os.Exit(1)
110    }
111
112    // Mostrar el reporte
113    mostrarReporte(config)
114    fmt.Println("Configuracion cargada correctamente.")
115}

1// config.json
2{
3  "app_name": "Mi API",
4  "version": "1.0.0",
5  "port": 8080,
6  "debug": true,
7  "allowed_hosts": ["localhost", "api.ejemplo.com"],
8  "database": {
9    "host": "localhost",
10    "port": 5432,
11    "name": "mi_base_datos",
12    "user": "admin",
13    "ssl_mode": "disable"
14  }
15}