Go Academy · Aula

Tempo e duração

Represente momentos e intervalos

Tempo e duração é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O pacote time

O pacote time do Go representa instantes no tempo e intervalos entre eles.

time.Time é um instante específico.
time.Duration é uma duração.

package main

import (
    "fmt"
    "time"
)

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

Obtendo a hora atual

time.Now() retorna o instante atual como um time.Time. (O valor exato depende de quando o programa é executado.)

package main

import (
    "fmt"
    "time"
)

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

Construindo um instante específico

time.Date constrói um instante exato a partir de suas partes: ano, mês, dia, hora, minuto, segundo, nanossegundo e localização.

package main

import (
    "fmt"
    "time"
)

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

Lendo os componentes do tempo

Um time.Time disponibiliza métodos como Year, Month, Day, Hour e 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 duração

Construa durações multiplicando as constantes de unidade: 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)
}

Convertendo durações

Métodos como Seconds(), Minutes() e Hours() retornam a duração como um float64 nessa unidade.

package main

import (
    "fmt"
    "time"
)

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

Adicionando tempo

t.Add(d) retorna um novo instante deslocado por uma duração. O valor original permanece inalterado porque time.Time é um 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())
}

Adicionando unidades do calendário

t.AddDate(years, months, days) desloca o instante por quantidades de calendário, tratando corretamente a duração dos meses e os anos bissextos.

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())
}

Diferença entre horários

t2.Sub(t1) retorna a Duration entre dois horários. Um resultado negativo significa que t2 é 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))
}

Comparação de horários

Use Before, After e Equal para comparar instantes. Evite ==, pois ele também compara a localização 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 tempo Unix

t.Unix() fornece os segundos desde 1º de janeiro de 1970. time.Unix(sec, 0) converte novamente para um 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())
}

Verificação rápida

O que t2.Sub(t1) retorna?

Recapitulação: horário e duração

Você aprendeu o modelo fundamental de tempo:

time.Time é um instante; time.Duration é um intervalo.
Crie com Now e Date; desloque com Add e AddDate.
Meça com Sub e compare com 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")
}

Perguntas Frequentes

A aula “Tempo e duração” é grátis?

Sim — o texto completo de “Tempo e duração” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Tempo e duração”?

Represente momentos e intervalos Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Tempo e duração”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy