Go Academy · Lección

Temporizadores y tickers

Programe y repita tareas

Temporizadores y tickers es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 3 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.

Pausar con Sleep

La herramienta de planificación más sencilla es time.Sleep(d), que pausa la goroutine actual durante una duración.

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("start")
    time.Sleep(10 * time.Millisecond)
    fmt.Println("done")
}

¿Qué es un temporizador?

Un time.Timer se activa una sola vez después de un retraso. Cuando vence, envía la hora actual por su canal C.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTimer(10 * time.Millisecond)
    <-t.C
    fmt.Println("timer fired")
}

Atajo time.After

time.After(d) devuelve un canal que entrega un valor después del retraso. Es un temporizador de una sola ejecución práctico que no requiere una variable.

package main

import (
    "fmt"
    "time"
)

func main() {
    <-time.After(10 * time.Millisecond)
    fmt.Println("elapsed")
}

Detener un temporizador

timer.Stop() cancela un temporizador antes de que se active. Devuelve true si logró detenerlo a tiempo.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTimer(time.Hour)
    stopped := t.Stop()
    fmt.Println("stopped:", stopped)
}

¿Qué es un ticker?

Un time.Ticker se activa de forma repetida a intervalos fijos y envía un valor por su canal C cada vez.

Úselo para tareas periódicas, como realizar consultas o generar fotogramas de animación.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    <-ticker.C
    fmt.Println("tick")
    ticker.Stop()
}

Contar activaciones

Recorra el canal del ticker para actuar en cada intervalo y deténgalo después de suficientes activaciones.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    for i := 1; i <= 3; i++ {
        <-ticker.C
        fmt.Println("tick", i)
    }
    ticker.Stop()
}

Detenga siempre los tickers

A diferencia de los temporizadores, un ticker sigue ejecutándose hasta que llama a Stop(). Si olvida detenerlo, se producirán fugas de recursos.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    defer ticker.Stop()
    <-ticker.C
    fmt.Println("one tick, will stop on return")
}

La comodidad de time.Tick

time.Tick(d) devuelve directamente un canal de ticker. Es sencillo, pero no se puede detener; úselo únicamente durante toda la vida del programa.

package main

import (
    "fmt"
    "time"
)

func main() {
    c := time.Tick(5 * time.Millisecond)
    <-c
    fmt.Println("ticked")
}

Tiempo de espera con select

Combine un canal de trabajo con time.After en un select para implementar un tiempo de espera.

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan bool)
    go func() { done <- true }()
    select {
    case <-done:
        fmt.Println("work finished")
    case <-time.After(time.Second):
        fmt.Println("timed out")
    }
}

AfterFunc ejecuta una devolución de llamada

time.AfterFunc(d, f) ejecuta la función f en su propia goroutine después del retraso, sin que tenga que leer un canal.

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan bool)
    time.AfterFunc(10*time.Millisecond, func() {
        fmt.Println("callback ran")
        done <- true
    })
    <-done
}

Temporizador frente a ticker

Elija según si necesita repetición:

Temporizador: se activa una vez después de un retraso.
Ticker: se activa repetidamente a intervalos.
Detenga ambos al terminar para liberar recursos.

package main

import (
    "fmt"
    "time"
)

func main() {
    <-time.After(5 * time.Millisecond)
    fmt.Println("one-shot complete")
}

Comprobación rápida

¿Qué tipo se activa repetidamente a intervalos fijos?

Repaso: temporizadores y tickers

Ha aprendido a planificar tareas:

Sleep pausa; Timer y time.After se activan una vez.
Ticker y time.Tick se activan repetidamente.
Use Stop() para limpiar recursos y combínelo con select para controlar tiempos de espera.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    defer ticker.Stop()
    for i := 0; i < 2; i++ {
        <-ticker.C
        fmt.Println("beat")
    }
}

Preguntas frecuentes

¿La lección «Temporizadores y tickers» es gratis?

Sí — el texto completo de «Temporizadores y tickers» 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 «Temporizadores y tickers»?

Programe y repita tareas 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 3 de 4.

¿Cuánto tiempo toma la lección «Temporizadores y tickers»?

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