A hora e a data são componentes cruciais de muitos softwares, desde utilitários de gerenciamento de tempo até aplicativos da web. Como programador, você precisa saber como manipular hora e data em qualquer idioma que você use.
Em Go, o Tempo pacote agrupa as funções para manipulação de data e hora. Você pode acessar essas funções em qualquer arquivo de origem importando esse pacote.
Então, o que significa manipular hora e data, e como você pode manipular hora e data em Go?
O que é manipulação de data e hora?
De acordo com os requisitos do seu programa, pode ser necessário controlar, gerenciar ou ajustar o comportamento ou a representação de horários e datas.
Diferentes linguagens de programação têm suas próprias funções para manipulação de data e hora. A linguagem Go possui amplos recursos, úteis para essa finalidade.
A manipulação de hora e data pode incluir:
- Obtenção da hora atual de um local ou fuso horário.
- Realização de operações aritméticas em horas e datas.
- Alterando o formato de entrada/saída de horas e datas.
Para começar a manipular a hora e a data em seus aplicativos Go, importe o Tempo pacote junto com os outros pacotes que você está usando.
importar (
"fmt"
"Tempo"
)Como obter a hora e a data atuais em Go
Um caso de uso comum para manipulação de tempo é obter a hora local atual ou a hora atual de um fuso horário ou local específico.
Para obter a hora e a data em seu horário local ou em um fuso horário ou local específico, você pode usar o Tempo. Agora() e Tempo. LoadLocation() funções:
função a Principal(){
// Obtém a hora e a data atuais na hora local
meuHora := ime. Agora()
fmt. Imprimirln("Hora atual em ", meu tempo. Localização(), " é: ", meu tempo)// Outra maneira de obter a hora local
localização, _ := hora. LoadLocation("Local") // ou hora. LoadLocation("")
fmt. Imprimirln("Hora atual em ", localização, " é: ", Tempo. Agora().Em (local))// outro local
localização, _ = tempo. LoadLocation("América/Nova_York")
fmt. Imprimirln("Hora atual em ", localização, " é: ", meu tempo. Em (local))
// obtém a hora atual no fuso horário da montanha (MST)
localização, _ = tempo. LoadLocation("MST")
fmt. Imprimirln("Hora atual em ", localização, " é: ", meu tempo. Em (local))
}
Executando o programa acima com vá executar nomedoarquivo.go produz a seguinte saída no terminal:
O método LoadLocation não oferece suporte a todas as abreviações de local e fuso horário. De acordo com Documentação do Go, ele suporta apenas locais no Banco de dados IANA.org.
Como obter componentes separados de uma determinada data
Você pode obter cada componente do carimbo de data e hora separadamente, o que é semelhante a quando trabalhando com hora e datas em JavaScript.
Existem várias maneiras de fazer isso usando o Go's Tempo funções. Esta seção ilustra cada método.
Você pode usar o Encontro() função para obter o dia, mês e ano, e o Relógio() função para obter a hora, minuto e segundos. Por exemplo:
funçãoa Principal() {
minhahora := hora. Agora();
ano, mês, dia := myTime. Encontro()
fmt. Println("Ano:", ano)
fmt. Println("Mês:", mês)
fmt. Println("Dia:", dia)
hora, min, seg := myTime. Relógio()
fmt. Println("Hora:", hora)
fmt. Println("Minuto:", min)
fmt. Println("Segundos:", seg)
}
A saída ilustra as diferentes partes do carimbo de data/hora:
Você também pode obter unidades do timestamp individualmente com o Tempo funções para cada um deles:
funçãoa Principal() {
minhahora := hora. Agora()
// obtém cada unidade de Ano para Nanossegundo
fmt. Println("Ano:", myTime. Ano())
fmt. Println("Mês:", myTime. Mês())
fmt. Println("Dia:", myTime. Dia())
fmt. Println("Hora:", myTime. Hora())
fmt. Println("Minuto:", myTime. Minuto())
fmt. Println("Segundos:", myTime. Segundo())
fmt. Println("Nanosegundo :", myTime. Nanossegundo())
}
Como a saída ilustra, isso também dá acesso a nanossegundos:
Os exemplos até este ponto se concentraram na obtenção de unidades de carimbo de data/hora da hora atual. Você pode realizar os mesmos tipos de ação em um carimbo de data/hora que não seja Tempo. Agora().
Você pode extrair o ano, mês, dia, hora, minuto e segundo de uma determinada data. Para fazer isso, você deve inicializar um novo objeto de data ou analisar a data de uma string:
funçãoa Principal() {
// obtém componentes individuais do tempo de Ano para Nanossegundos
// a partir de uma data específica
seuTempo := tempo. Encontro(2020, 07, 1, 06, 32, 10, 0, Tempo. UTC)
fmt. Println("Ano:", seuTempo. Ano())
fmt. Println("Mês:", seuHora. Mês())
fmt. Println("Dia:", seuHora. Dia())
fmt. Println("Hora:", seuHora. Hora())
fmt. Println("Minuto:", seuTempo. Minuto())
fmt. Println("Segundos:", seuTempo. Segundo())
fmt. Println("Nanosegundo :", yourTime. Nanossegundo())
// usando a função Clock() para obter hora, minuto e segundo
yourHour, yourMin, yourSec := yourTime. Relógio()
fmt. Println("Hora:", suaHora)
fmt. Println("Minuto:", seuMin)
fmt. Println("Segundos:", seuSec)
// obtém hora e data da string
dateString := "2020-07-0106:32:10"
esquema := "2006-01-0215:04:05" // seu formato de saída desejado
seuTempo, _ = tempo. Analisar (layout, dateString)
fmt. Println("Sua hora é: ", suahora)
fmt. Println("Ano:", seuTempo. Ano())
fmt. Println("Mês:", seuHora. Mês())
fmt. Println("Dia:", seuHora. Dia())
fmt. Println("Hora:", seuHora. Hora())
fmt. Println("Minuto:", seuTempo. Minuto())
fmt. Println("Segundos:", seuTempo. Segundo())
}
Este código produz a seguinte saída:
Observe que Parse() usa UTC por padrão, se você não especificar um fuso horário na string de data.
Como realizar operações aritméticas com data e hora
As operações aritméticas são outro tipo de manipulação que você pode realizar na hora e na data em Go. Operações simples como adição, subtração e diferença de tempo são todas possíveis.
Go permite que você defina Tempo. Duração valores com todas as unidades de tempo de Tempo. Hora para Tempo. Nanossegundo. Você pode usar esses valores para adicionar ou subtrair o tempo usando Adicionar(). Há também um AdicionarData() função que recebe 3 parâmetros: anos, meses e dias para realizar adição ou subtração.
O código a seguir demonstra o uso dessas funções:
funçãoa Principal() {
curTime := tempo. Agora()
curTime = curTime. Tempo extra. Hora) // adiciona uma hora
fmt. Println("Hora atual é: ", curTime)
amanhã := curTime. Tempo extra. Hora * 24)
fmt. Println("Esta hora amanhã é: ", amanhã)
nextWeek := curTime. Tempo extra. Hora * 24 * 7)
fmt. Println("Desta vez na próxima semana é: ", nextWeek)
// usando AddDate (y, m, d)
nextTomorrow := curTime. AdicionarData(0, 0, 2)
fmt. Println("Desta vez, o próximo amanhã é: ", nextTomorrow)
nextMonth := curTime. AdicionarData(0, 1, 0)
fmt. Println("Desta vez no próximo mês é: ", nextMonth)
fiveYearsAndOneMonthAfter := curTime. AdicionarData(5, 1, 0)
fmt. Println("Desta vez, cinco anos e um mês depois é: ", fiveYearsAndOneMonthAfter)
}
Que produz a seguinte saída:
Você também pode subtrair o tempo com Adicionar() e AdicionarData() passando parâmetros negativos. Por exemplo:
funçãoa Principal() {
curTime := tempo. Agora()// subtrai um dia usando AddDate()
ontem := curTime. AdicionarData(0, 0, -1)
fmt. Println("Hora ontem foi: ", ontem)
// subtrai um mês usando Add()
lastMonth := curTime. Tempo extra. Hora * -24 * 30)
fmt. Println("Desta vez no mês passado foi: ", lastMonth)
}
Produz esta saída:
Embora você possa usar Adicionar() e AdicionarData() para encontrar a distinção entre datas, Go tem um Sub() função que funciona um pouco diferente:
funçãoa Principal() {
curTime = tempo. Agora()
passado := tempo. Encontro(2022, Tempo. Dezembro, 25, 12, 0, 0, 0, Tempo. UTC)
diff := passado. Sub (curTime)
fmt. Println("A diferença entre agora e o passado é: ", diff)
// obtém a diferença em várias unidades
anos := int(dif. Horas() / 24 / 365)
fmt. Println("Anos: ", anos)
meses := int(dif. Horas() / 24 / 30)
fmt. Println("Meses: ", meses)
dias := int(dif. Horas() / 24)
fmt. Println("Dias: ", dias)
horas := int(dif. Horas())
fmt. Println("Horas: ", horas)
// diferença. Minutos(), diferença. Segundos(), diferença. Milissegundos(), diferença. Nanossegundos() também retornam suas unidades
}
Este código produz a seguinte saída:
Como obter hora e data em vários formatos
Você também pode obter saídas de data e hora em vários formatos usando o Formato() função. Aqui estão alguns estilos de formatação comuns:
funçãoa Principal() {
curTime = tempo. Agora()
// estilos de formatação padrão embutidos
fmt. Println("Hora atual é: ", curTime)
fmt. Println("A hora atual no formato RFC3339 é: ", curTime. Formato (hora. RFC3339))
fmt. Println("Hora atual no formato RFC3339Nano é: ", curTime. Formato (hora. RFC3339Nano))
fmt. Println("A hora atual no formato RFC1123 é: ", curTime. Formato (hora. RFC1123))
fmt. Println("A hora atual no formato RFC1123Z é: ", curTime. Formato (hora. RFC1123Z))
fmt. Println("A hora atual no formato RFC822 é: ", curTime. Formato (hora. RFC822))
fmt. Println("A hora atual no formato RFC822Z é: ", curTime. Formato (hora. RFC822Z))
fmt. Println("Hora atual no formato RFC850 é: ", curTime. Formato (hora. RFC850))
fmt. Println("Hora atual no formato ANSIC é: ", curTime. Formato (hora. ANSIC))
fmt. Println("A hora atual no formato Unix é: ", curTime. Formato (hora. Data Unix))
// estilos de formatação personalizados
// DD-MM-AAAA HH: MM: SS
fmt. Println("A hora atual no formato personalizado é: ", curTime. Formato("02-01-200615:04:05"))
// MM-DD-AAAA HH: MM: SS
fmt. Println("A hora atual no formato personalizado é: ", curTime. Formato("01-02-200615:04:05"))
// AAAA-MM-DD HH: MM: SS
fmt. Println("A hora atual no formato personalizado é: ", curTime. Formato("2006-01-0215:04:05"))
// DD.MM.AAAA
fmt. Println("A hora atual no formato personalizado é: ", curTime. Formato("02.01.2006"))
// DD/MM/AAAA
fmt. Println("A hora atual no formato personalizado é: ", curTime. Formato("02/01/2006"))
// 01 de fevereiro de 2006
fmt. Println("A hora atual no formato personalizado é: ", curTime. Formato("02 janeiro 2006"))
// 01 de fevereiro de 2006 segunda-feira
fmt. Println("A hora atual no formato personalizado é: ", curTime. Formato("02 Fevereiro 2006 Segunda-feira"))
// 01 de fevereiro de 2006 Seg 15:04:05
fmt. Println("A hora atual no formato personalizado é: ", curTime. Formato("02 Fevereiro 2006 seg 15:04:05"))
}
Esses diferentes tipos de formatação produzem a seguinte saída:
Manipulando a hora e a data em Go
A lista de manipulações que você pode realizar em horários e datas é quase interminável. Dependendo do escopo do seu aplicativo, pode ser necessário realizar diversas operações de data/hora.
Para qualquer caso de uso que você possa ter, o Tempo pacote é muito funcional e tem muitos métodos embutidos.
Você pode usar a manipulação de data e hora para criar um planejador diário simples ou um aplicativo de agendador de tarefas.