Conceptos básicos de la biblioteca estándar

10 ejemplos para empezar con la Biblioteca Estándar: 7 básicos y 3 intermedios.

Prerrequisitos

• Instala Go 1.26.x o posterior desde go.dev/dl.
• Crea un módulo: mkdir stdlib && cd stdlib && go mod init example.com/stdlib.
• Guarda cada fragmento como main.go (o un archivo de prueba donde se indique) y ejecútalo con go run . o go test.
• Los paquetes de la biblioteca estándar no necesitan go get; las rutas de importación como "fmt" se resuelven desde la toolchain.

Ejemplos básicos

1. Salida formateada con fmt

Imprime valores con formato predeterminado.

package main
 
import "fmt"
 
func main() {
    name, count := "widgets", 3
    fmt.Printf("shipped %d %s\n", count, name)
}

• Printf utiliza tokens de verbo (%d, %s, %v) como el formato estilo C.
• Println añade espacios entre operandos y una nueva línea al final.
• Prefiere fmt.Errorf con %w al envolver errores en código real.

Relacionado: La Biblioteca Estándar de Go: Baterías Incluidas - filosofía de la biblioteca estándar

2. Ayudantes de cadenas

Transforma e inspecciona cadenas sin bucles manuales.

package main
 
import (
    "fmt"
    "strings"
)
 
func main() {
    s := "  hello, Go  "
    fmt.Println(strings.TrimSpace(s))
    fmt.Println(strings.Contains(s, "Go"))
    fmt.Println(strings.Split("a,b,c", ","))
}

• strings opera sobre cadenas de bytes UTF-8; no es consciente de las runas para todas las funciones.
• TrimSpace elimina el espacio en blanco Unicode, no solo los espacios ASCII.
• Para la construcción intensiva, usa strings.Builder en lugar de += en bucles.

3. Analiza y formatea números

Convierte entre cadenas y tipos numéricos de forma segura.

package main
 
import (
    "fmt"
    "strconv"
)
 
func main() {
    n, err := strconv.Atoi("42")
    if err != nil {
        panic(err)
    }
    fmt.Println(n * 2)
 
    s := strconv.FormatFloat(3.14, 'f', 2, 64)
    fmt.Println(s)
}

• Atoi es un atajo para ParseInt(s, 10, 0).
• Siempre maneja los errores de las funciones Parse*; la entrada no válida es común en los límites de la API.
• FormatBool, FormatInt e Itoa cubren la serialización de salida.

4. Codifica y decodifica JSON

Serializa structs a JSON y viceversa.

package main
 
import (
    "encoding/json"
    "fmt"
)
 
type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}
 
func main() {
    u := User{ID: 1, Name: "Ada"}
    b, _ := json.Marshal(u)
    fmt.Println(string(b))
 
    var decoded User
    _ = json.Unmarshal(b, &decoded)
    fmt.Println(decoded.Name)
}

• Las etiquetas de struct controlan los nombres de los campos JSON y omitempty.
• json.NewEncoder y json.NewDecoder transmiten a io.Writer y io.Reader.
• json.Marshal devuelve []byte; no asumas un orden particular de claves en las comparaciones.

Relacionado: os, io, bufio & path/filepath - E/S en streaming detrás de JSON

5. Lee un archivo con os e io

Abre una ruta y lee su contenido.

package main
 
import (
    "fmt"
    "os"
)
 
func main() {
    data, err := os.ReadFile("notes.txt")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(data))
}

• os.ReadFile lee el archivo completo; usa streaming para entradas grandes.
• Comprueba os.IsNotExist(err) para distinguir archivos faltantes de errores de permisos.
• Siempre cierra los recursos abiertos con os.Open cuando no uses ReadFile.

6. Copia flujos con io

Mueve bytes entre lectores y escritores.

package main
 
import (
    "bytes"
    "fmt"
    "io"
    "strings"
)
 
func main() {
    src := strings.NewReader("hello stream")
    var dst bytes.Buffer
    n, err := io.Copy(&dst, src)
    if err != nil {
        panic(err)
    }
    fmt.Println(n, dst.String())
}

• io.Copy almacena en búfer internamente; rara vez necesitas rebanadas de bytes manuales para trabajo tipo tubería.
• io.ReadAll vacía un lector en memoria; empareja con límites de tamaño en servidores.
• Muchos tipos de la biblioteca estándar implementan io.Reader o io.Writer.

7. Escanea un archivo línea por línea con bufio

Lee la entrada línea por línea con memoria mínima.

package main
 
import (
    "bufio"
    "fmt"
    "strings"
)
 
func main() {
    s := "line1\nline2\nline3\n"
    sc := bufio.NewScanner(strings.NewReader(s))
    for sc.Scan() {
        fmt.Println(sc.Text())
    }
    if err := sc.Err(); err != nil {
        panic(err)
    }
}

• Scanner divide por defecto en líneas; ScanLines es la función de división predeterminada.
• Comprueba sc.Err() después del bucle; Scan devuelve falso en EOF y en errores.
• Para el análisis delimitado por tokens (campos CSV), usa sc.Split con una función personalizada.

Relacionado: log, regexp & text/template - paquetes de procesamiento de texto

Ejemplos intermedios

8. Temporizadores y reloj monotónico

Mide el tiempo transcurrido sin distorsión del reloj de pared.

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    start := time.Now()
    time.Sleep(50 * time.Millisecond)
    fmt.Println(time.Since(start))
}

• time.Since utiliza una lectura monotónica cuando está disponible, por lo que los saltos del horario de verano no distorsionan las duraciones.
• time.ParseDuration acepta cadenas como "300ms" y "5m".
• Almacena instantes como time.Time, no como enteros Unix, a menos que serialices entre sistemas.

Relacionado: Integración de time, timezones y context - ubicaciones y plazos

9. Tiempo de espera de contexto

Cancela el trabajo cuando expira un plazo.

package main
 
import (
    "context"
    "fmt"
    "time"
)
 
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()
 
    select {
    case <-time.After(200 * time.Millisecond):
        fmt.Println("finished")
    case <-ctx.Done():
        fmt.Println("canceled:", ctx.Err())
    }
}

• Llama siempre a cancel() para liberar los recursos del temporizador, generalmente con defer.
• Pasa ctx como primer parámetro a las funciones que puedan bloquearse.
• context.WithCancel es apropiado cuando un evento externo (desconexión del cliente) debe detener el trabajo.

10. Servidor HTTP mínimo

Sirve HTTP con los valores predeterminados de net/http.

package main
 
import (
    "fmt"
    "net/http"
)
 
func main() {
    http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "hello")
    })
    fmt.Println("listening :8080")
    http.ListenAndServe(":8080", nil)
}

• http.HandleFunc se registra en http.DefaultServeMux; el código de producción a menudo usa http.NewServeMux.
• ListenAndServe se bloquea; configura tiempos de espera en http.Server antes de los despliegues de producción.
• Las funciones manejadoras reciben ResponseWriter y *Request; comprueba el método y la ruta dentro.

Relacionado: database/sql & net Package Family Overview - familia de paquetes net | net/http: Go's Batteries-Included HTTP Stack - modelo HTTP completo

Versiones de la pila: Esta página fue escrita para Go 1.26.x (predeterminado de Green Tea GC, go fix modernizers - verifica el parche en la compilación), chi (última versión - verifica en la compilación), gin (última versión - verifica en la compilación), echo (última versión - verifica en la compilación), google.golang.org/grpc (última versión - verifica en la compilación), sigs.k8s.io/controller-runtime (última versión - verifica en la compilación), kubebuilder (última versión - verifica en la compilación), tinygo (última versión - verifica los objetivos de la placa en la compilación), wazero (última versión - verifica en la compilación) y golangci-lint (última versión - verifica el conjunto de linters en la compilación).