Go Academy · Lección

Programación basada en el tiempo

Ejecute tareas periódicas

Lección 1 de 413 pasos

Programación basada en el tiempo 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.

Ejecución de tareas programadas

Muchos sistemas necesitan tareas periódicas: limpiar archivos temporales cada noche, enviar un correo electrónico de resumen cada mañana o consultar una API cada minuto. En esta lección se presenta la programación basada en tiempo en Go mediante la biblioteca estándar.

El paquete time

El paquete time de Go es la base. Sus herramientas principales son:

time.Sleep pausa una goroutine
time.After devuelve un canal que se activa una vez
time.Ticker se activa repetidamente
time.Timer se activa una vez después de un retraso

Un bucle ingenuo

El planificador más sencillo: realizar la tarea, esperar y repetir.

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        fmt.Println("tick", i)
        time.Sleep(10 * time.Millisecond)
    }
}

Por qué Sleep se desvía

Un bucle con espera se desvía: si la tarea tarda 200 ms y espera 1 s, el intervalo real es de 1,2 s, y el desfase se acumula. Para obtener intervalos precisos, utilice un Ticker, que veremos en una lección posterior.

time.After para retrasos puntuales

time.After(d) devuelve un canal que recibe un valor una vez transcurrida la duración d. Resulta útil en select para implementar tiempos de espera.

select {
case <-time.After(2 * time.Second):
    fmt.Println("2s elapsed")
}

time.Timer

Un Timer se activa una vez y puede detenerse o reiniciarse, a diferencia de time.After, que no se puede cancelar.

t := time.NewTimer(5 * time.Second)
defer t.Stop()
<-t.C
fmt.Println("fired")

Programación a una hora específica

Para ejecutar una tarea, por ejemplo, a las 3 de la madrugada, calcule cuánto falta hasta ese momento y espere ese tiempo mediante sleep o un timer; después, vuelva a programarla para el día siguiente.

now := time.Now()
next := time.Date(now.Year(), now.Month(), now.Day(), 3, 0, 0, 0, now.Location())
if next.Before(now) {
    next = next.Add(24 * time.Hour)
}
fmt.Println("sleep for", time.Until(next))

Las duraciones tienen tipo

time.Duration es un int64 de nanosegundos con constantes prácticas: time.Second, time.Minute y time.Hour. Multiplíquelas para expresar intervalos legibles.

every := 30 * time.Minute
fmt.Println(every)

Reloj monótono frente a reloj de pared

time.Now de Go incluye una lectura monotónica que se utiliza para medir el tiempo transcurrido y no se ve afectada por los ajustes del reloj. Utilice time.Since para las duraciones, no la resta del reloj de pared.

start := time.Now()
// ... work ...
fmt.Println("took", time.Since(start))

Cuándo recurrir a una biblioteca

Para programaciones complejas ("cada día laborable a las 9:15"), calcular las horas manualmente es propenso a errores. La biblioteca robfig/cron, que veremos a continuación, analiza las expresiones cron por usted.

Ejecutable: cálculo de la próxima ejecución

Este programa autónomo calcula cuánto falta hasta el comienzo del próximo minuto utilizando únicamente el paquete time.

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Date(2026, 1, 1, 10, 30, 45, 0, time.UTC)
    nextMinute := now.Truncate(time.Minute).Add(time.Minute)
    fmt.Println("now:", now.Format("15:04:05"))
    fmt.Println("next run:", nextMinute.Format("15:04:05"))
    fmt.Println("wait:", nextMinute.Sub(now))
}

Comprobación rápida

Compruebe su comprensión de la programación basada en tiempo.

Responde en la lección interactiva

Resumen

Ha aprendido los conceptos básicos de la programación basada en tiempo:

El paquete time proporciona Sleep, After, Timer y Ticker
Los bucles con Sleep se desvían; los tickers mantienen el horario
Calcule las duraciones hasta una hora objetivo con time.Until
Utilice time.Since y el reloj monotónico para medir el tiempo transcurrido

Gratis para empezar

Aprende Go con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 51
Lecciones: 203

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Programación basada en el tiempo» es gratis?

Sí — el texto completo de «Programación basada en el tiempo» 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 «Programación basada en el tiempo»?

Ejecute tareas periódicas 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 «Programación basada en el tiempo»?

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