Go Academy · Lección

Tiempo y duración

Represente momentos e intervalos

Tiempo y duración 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.

El paquete time

El paquete time de Go representa instantes y los intervalos entre ellos.

time.Time representa un instante específico.
time.Duration representa una duración.

package main

import (
    "fmt"
    "time"
)

func main() {
    var d time.Duration = 2 * time.Second
    fmt.Println(d)
}

Obtener la hora actual

time.Now() devuelve el instante actual como un time.Time. (Su valor exacto depende de cuándo se ejecute el programa).

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now.Year())
}

Construir una hora específica

time.Date construye un instante exacto a partir de sus componentes: año, mes, día, hora, minuto, segundo, nanosegundo y ubicación.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
    fmt.Println(t)
}

Leer los componentes de una hora

Un time.Time expone métodos como Year, Month, Day, Hour y Weekday.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.May, 30, 0, 0, 0, 0, time.UTC)
    fmt.Println(t.Month(), t.Day(), t.Weekday())
}

Constantes de duración

Construya duraciones multiplicando las constantes de unidad: time.Hour, time.Minute, time.Second, time.Millisecond.

package main

import (
    "fmt"
    "time"
)

func main() {
    d := 1*time.Hour + 30*time.Minute
    fmt.Println(d)
}

Convertir duraciones

Métodos como Seconds(), Minutes() y Hours() devuelven la duración como un float64 expresado en esa unidad.

package main

import (
    "fmt"
    "time"
)

func main() {
    d := 90 * time.Minute
    fmt.Println(d.Hours())
    fmt.Println(d.Seconds())
}

Añadir tiempo

t.Add(d) devuelve una nueva hora desplazada según una duración. El valor original no cambia porque time.Time es un tipo de valor.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
    later := t.Add(2 * time.Hour)
    fmt.Println(later.Hour())
}

Añadir unidades de calendario

t.AddDate(years, months, days) desplaza la fecha según cantidades de calendario y gestiona correctamente la duración de los meses y los años bisiestos.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.January, 31, 0, 0, 0, 0, time.UTC)
    next := t.AddDate(0, 1, 0)
    fmt.Println(next.Month(), next.Day())
}

Diferencia entre instantes

t2.Sub(t1) devuelve la Duration entre dos instantes. Un resultado negativo significa que t2 es anterior.

package main

import (
    "fmt"
    "time"
)

func main() {
    a := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
    b := time.Date(2026, time.May, 30, 12, 0, 0, 0, time.UTC)
    fmt.Println(b.Sub(a))
}

Comparación de instantes

Use Before, After y Equal para comparar instantes. Evite ==, porque también compara la ubicación interna.

package main

import (
    "fmt"
    "time"
)

func main() {
    a := time.Date(2026, 5, 30, 9, 0, 0, 0, time.UTC)
    b := time.Date(2026, 5, 30, 10, 0, 0, 0, time.UTC)
    fmt.Println(a.Before(b))
}

Marcas de tiempo Unix

t.Unix() devuelve los segundos transcurridos desde el 1 de enero de 1970. time.Unix(sec, 0) convierte ese valor de nuevo en un time.Time.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, 5, 30, 0, 0, 0, 0, time.UTC)
    secs := t.Unix()
    fmt.Println(time.Unix(secs, 0).UTC().Year())
}

Comprobación rápida

¿Qué devuelve t2.Sub(t1)?

Repaso: tiempo y duración

Ha aprendido el modelo básico del tiempo:

time.Time representa un instante; time.Duration, una duración.
Cree valores con Now y Date; desplácelos con Add y AddDate.
Mida con Sub y compare con Before/After.

package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Date(2026, 5, 30, 8, 0, 0, 0, time.UTC)
    end := start.Add(45 * time.Minute)
    fmt.Println(end.Sub(start).Minutes(), "minutes")
}

Preguntas frecuentes

¿La lección «Tiempo y duración» es gratis?

Sí — el texto completo de «Tiempo y duración» 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 «Tiempo y duración»?

Represente momentos e intervalos 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 «Tiempo y duración»?

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