Integración de time, zonas horarias y context

El paquete time de Go modela instantes, duraciones y eventos recurrentes.

context adjunta plazos y cancelación a esas operaciones para que los servidores detengan el trabajo cuando los clientes se desconectan o los presupuestos expiran.

Resumen

Usa time.Time para instantes de calendario y time.Duration para intervalos transcurridos.

Las lecturas del reloj monotónico evitan que los saltos del horario de verano corrompan las mediciones de Since.

Carga ubicaciones con time.LoadLocation para una visualización local correcta; almacena UTC en bases de datos.

Empareja context.WithTimeout con llamadas bloqueantes para que las goroutines salgan puntualmente.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
 
timer := time.NewTimer(500 * time.Millisecond)
defer timer.Stop()
 
select {
case <-timer.C:
    // trabajo
case <-ctx.Done():
    return ctx.Err()
}

Cuándo usar esto:

• Medir latencia con time.Since y time.Until.
• Programar reintentos, latidos o límites de tasa con time.Ticker.
• Respetar los plazos de HTTP y RPC a través de context.Context.
• Convertir marcas de tiempo entre UTC y oficinas regionales para su visualización.

Ejemplo de trabajo

package main
 
import (
    "context"
    "fmt"
    "time"
)
 
func fetchWithDeadline(ctx context.Context, url string) error {
    ctx, cancel := context.WithTimeout(ctx, 800*time.Millisecond)
    defer cancel()
 
    done := make(chan error, 1)
    go func() {
        // marcador de posición para llamada net/http o de base de datos
        time.Sleep(300 * time.Millisecond)
        done <- nil
    }()
 
    select {
    case err := <-done:
        return err
    case <-ctx.Done():
        return fmt.Errorf("fetch %s: %w", url, ctx.Err())
    }
}
 
func nextBusinessOpen(now time.Time, loc *time.Location) time.Time {
    local := now.In(loc)
    // ejemplo ingenuo: próximo 09:00 local en un día laborable
    open := time.Date(local.Year(), local.Month(), local.Day(), 9, 0, 0, 0, loc)
    if !local.Before(open) {
        open = open.Add(24 * time.Hour)
    }
    return open.UTC()
}
 
func main() {
    loc, err := time.LoadLocation("America/New_York")
    if err != nil {
        panic(err)
    }
 
    if err := fetchWithDeadline(context.Background(), "https://example.com"); err != nil {
        panic(err)
    }
 
    utcNow := time.Now().UTC()
    fmt.Println("próxima apertura UTC:", nextBusinessOpen(utcNow, loc))
}

Lo que esto demuestra:

• Plazo anidado en un context entrante.
• Goroutine más select uniendo trabajo bloqueante y cancelación.
• LoadLocation para nombres de zona IANA y conversión de instantes de visualización a UTC.

Análisis Profundo

Cómo funciona

• time.Now captura lecturas del reloj y del tiempo transcurrido en un solo valor time.Time.
• La resta (t2.Sub(t1)) utiliza lecturas del tiempo transcurrido cuando ambos tiempos comparten la misma base monotónica.
• time.Timer se dispara una vez; time.Ticker se repite hasta Stop.
• context.WithDeadline y WithTimeout programan la cancelación automática en un instante derivado de time.Time.

Conceptos de tiempo

Notas de Go

// Analiza y formatea con diseños explícitos (tiempo de referencia Lun 2 Ene 15:04:05 MST 2006):
t, _ := time.Parse(time.RFC3339, "2026-07-15T12:00:00Z")
 
// Sleep no es cancelable - prefiere select:
select {
case <-time.After(delay):
case <-ctx.Done():
    return ctx.Err()
}

Trampas

• Usar time.Sleep sin context - El apagado y la cancelación del cliente no pueden interrumpir el sleep. Solución: select en ctx.Done() y time.After.
• Almacenar tiempos locales en bases de datos - Las transiciones del horario de verano duplican o omiten horas. Solución: persistir UTC; convertir en el límite de la interfaz de usuario con Location.
• Olvidar timer.Stop() o ticker.Stop() - Fuga goroutines hasta la hora de disparo. Solución: diferir Stop() inmediatamente después de la creación.
• Comparar time.Time con == entre zonas - El mismo instante puede diferir en los campos de visualización. Solución: comparar t1.Equal(t2) o convertir ambos a UTC.
• Usar time.After en bucles ajustados - Crea un nuevo temporizador por iteración. Solución: reutilizar time.NewTimer y restablecer cuidadosamente.
• Pasar context.Background() en servidores - Ignora la cancelación de la solicitud entrante. Solución: aceptar ctx de r.Context() o del ámbito padre.

Alternativas

Preguntas frecuentes

Relacionado

• Conceptos básicos de la biblioteca estándar - Ejemplos de tiempo de espera de context y time.Since
• Paquetes runtime, debug y pprof - Perfiles del planificador y de bloqueo
• Descripción general de la familia de paquetes database/sql y net - E/S consciente de context
• Conceptos básicos de concurrencia - Patrones de goroutines y select
• Buenas prácticas de net/http - Configuración del tiempo de espera del servidor

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