La hora y la fecha son componentes cruciales de una gran cantidad de software, desde utilidades de administración de tiempo hasta aplicaciones web. Como programador, necesita saber cómo manipular la hora y la fecha en cualquier idioma que use.
En Go, el tiempo El paquete agrupa las funciones para la manipulación de fecha y hora. Puede acceder a estas funciones en cualquier archivo fuente importando ese paquete.
Entonces, ¿qué significa manipular la hora y la fecha, y cómo puede manipular la hora y la fecha en Go?
¿Qué es la manipulación de fecha y hora?
De acuerdo con los requisitos de su programa, es posible que deba controlar, administrar o ajustar el comportamiento o la representación de horas y fechas.
Diferentes lenguajes de programación tienen sus propias funciones para la manipulación de fecha y hora. El lenguaje Go tiene amplias capacidades, útiles para este propósito.
La manipulación de fecha y hora puede incluir:
- Obtención de la hora actual de una ubicación o zona horaria.
- Realización de operaciones aritméticas sobre horas y fechas.
- Cambiar el formato de entrada/salida de horas y fechas.
Para comenzar a manipular la hora y la fecha en sus aplicaciones Go, importe el tiempo paquete junto con los otros paquetes que está utilizando.
importar (
"fmt"
"tiempo"
)Cómo obtener la hora y la fecha actuales en Go
Un caso de uso común para la manipulación del tiempo es obtener la hora local actual o la hora actual de una zona horaria o ubicación específica.
Para obtener la hora y la fecha en su hora local o en una zona horaria o ubicación específica, puede usar el tiempo. Ahora() y tiempo. CargarUbicación() funciones:
función principal(){
// Obtener la fecha y hora actual en hora local
miHora := hora. Ahora()
fmt. imprimir("Hora actual en ", mi tiempo. Ubicación(), " es: ", mi tiempo)// Otra forma de obtener la hora local
ubicación, _ := tiempo. CargarUbicación("Local") // o tiempo. CargarUbicación("")
fmt. imprimir("Hora actual en ", ubicación, " es: ", tiempo. Ahora().En (ubicación))// otra localización
ubicación, _ = tiempo. CargarUbicación("América/Nueva_York")
fmt. imprimir("Hora actual en ", ubicación, " es: ", mi tiempo. En (ubicación))
// obtener la hora actual en Mountain Time Zone (MST)
ubicación, _ = tiempo. CargarUbicación("MST")
fmt. imprimir("Hora actual en ", ubicación, " es: ", mi tiempo. En (ubicación))
}
Ejecutando el programa anterior con ve a ejecutar filename.go produce la siguiente salida en la terminal:
El método LoadLocation no admite todas las abreviaturas de ubicación y zona horaria. De acuerdo con la Ir documentación, solo admite ubicaciones en el Base de datos IANA.org.
Cómo obtener componentes separados a partir de una fecha determinada
Puede obtener cada componente de la marca de tiempo por separado, lo cual es similar a cuando trabajar con hora y fechas en JavaScript.
Existen numerosas formas de lograr esto usando Go's tiempo funciones Esta sección ilustra cada método.
Puedes usar el Fecha() función para obtener el día, el mes y el año, y el Reloj() para obtener la hora, los minutos y los segundos. Por ejemplo:
funciónprincipal() {
miTiempo := tiempo. Ahora();
año, mes, día := miHora. Fecha()
fmt. println("Año:", año)
fmt. println("Mes:", mes)
fmt. println("Día:", día)
hora, min, seg := myTime. Reloj()
fmt. println("Hora:", hora)
fmt. Println("Minuto:", min)
fmt. Println("Segundos:", seg)
}
El resultado ilustra las diferentes partes de la marca de tiempo:
También puede obtener unidades de la marca de tiempo individualmente con el tiempo funciones para cada uno de ellos:
funciónprincipal() {
miTiempo := tiempo. Ahora()
// obtener cada unidad de Año a Nanosegundo
fmt. Println("Año:", miHora. Año())
fmt. Println("Mes:", miHora. Mes())
fmt. Println("Día:", miHora. Día())
fmt. Println("Hora:", miHora. Hora())
fmt. Println("Minutos:", miHora. Minuto())
fmt. Println("Segundos:", miTiempo. Segundo())
fmt. Println("Nanosegundo:", miTiempo. Nanosegundo())
}
Como ilustra el resultado, esto también le da acceso a nanosegundos:
Los ejemplos hasta este punto se han centrado en obtener unidades de marca de tiempo de la hora actual. Puede realizar los mismos tipos de acción en una marca de tiempo que no es tiempo. Ahora().
Puede extraer el año, mes, día, hora, minuto y segundo de una fecha determinada. Para hacerlo, debe inicializar un nuevo objeto de fecha o analizar la fecha de una cadena:
funciónprincipal() {
// obtener componentes individuales del tiempo de Año a Nanosegundo
// a partir de una fecha especifica
tuTiempo := tiempo. Fecha(2020, 07, 1, 06, 32, 10, 0, tiempo. UTC)
fmt. Println("Año:", suHora. Año())
fmt. Println("Mes:", suHora. Mes())
fmt. Println("Día:", suHora. Día())
fmt. Println("Hora:", tuHora. Hora())
fmt. Println("Minutos:", tuHora. Minuto())
fmt. Println("Segundos:", suTiempo. Segundo())
fmt. Println("Nanosegundo :", tuTiempo. Nanosegundo())
// usando la función Clock() para obtener hora, minuto y segundo
yourHour, yourMin, yourSec := yourTime. Reloj()
fmt. println("Hora:", tuHora)
fmt. println("Minuto:", tuMin)
fmt. Println("Segundos:", suSeg)
// obtener hora y fecha de la cadena
cadena de fecha := "2020-07-0106:32:10"
diseño := "2006-01-0215:04:05" // su formato de salida deseado
tuTiempo, _ = tiempo. Analizar (diseño, cadena de fecha)
fmt. println("Tu hora es: ", tuhora)
fmt. Println("Año:", suHora. Año())
fmt. Println("Mes:", suHora. Mes())
fmt. Println("Día:", suHora. Día())
fmt. Println("Hora:", tuHora. Hora())
fmt. Println("Minutos:", tuHora. Minuto())
fmt. Println("Segundos:", suTiempo. Segundo())
}
Este código produce el siguiente resultado:
Tenga en cuenta que Parse() utiliza UTC de forma predeterminada si no especifica una zona horaria en la cadena de fecha.
Cómo realizar operaciones aritméticas con fecha y hora
Las operaciones aritméticas son otro tipo de manipulación que puede realizar en la hora y la fecha en Go. Las operaciones simples como la suma, la resta y la diferencia de tiempo son todas posibles.
Ir le permite definir tiempo. Duración valores con todas las unidades de tiempo desde tiempo. Hora a tiempo. Nanosegundo. Puede usar estos valores para sumar o restar tiempo usando Agregar(). También hay un AñadirFecha() función que toma en 3 parámetros: años, meses y días para realizar sumas o restas.
El siguiente código demuestra el uso de estas funciones:
funciónprincipal() {
curTime := tiempo. Ahora()
curTime = curTime. Agregar tiempo. Hora) // agrega una hora
fmt. Println("La hora actual es: ", horaActual)
mañana := horaHora. Agregar tiempo. Hora * 24)
fmt. println("Esta hora mañana es: ", mañana)
próxima semana := hora actual. Agregar tiempo. Hora * 24 * 7)
fmt. Println("Esta hora la próxima semana es: ", nextWeek)
// usando AddDate (y, m, d)
próximo mañana: = hora actual. AñadirFecha(0, 0, 2)
fmt. Println("Esta hora Próximo mañana es: ", el próximo mañana)
nextMonth := horaHora. AñadirFecha(0, 1, 0)
fmt. Println("Esta vez el próximo mes es: ", nextMonth)
cincoañosyunmesdespués := horaactual. AñadirFecha(5, 1, 0)
fmt. Println("Esta vez cinco años y un mes después es: ", cinco años y un mes después)
}
Lo que produce la siguiente salida:
También puedes restar tiempo con Agregar() y AñadirFecha() pasando parámetros negativos. Por ejemplo:
funciónprincipal() {
curTime := tiempo. Ahora()// restar un día usando AddDate()
ayer := horaHora. AñadirFecha(0, 0, -1)
fmt. Println("Esta vez ayer fue: ", ayer)
// restar un mes usando Add()
ultimoMes := horaActual. Agregar tiempo. Hora * -24 * 30)
fmt. Println("Esta vez el mes pasado fue: ", ultimoMes)
}
Produce esta salida:
Aunque puedes usar Agregar() y AñadirFecha() para encontrar la distinción entre fechas, Go tiene un Sub() función que funciona un poco diferente:
funciónprincipal() {
curTime = tiempo. Ahora()
pasado := tiempo. Fecha(2022, tiempo. Diciembre, 25, 12, 0, 0, 0, tiempo. UTC)
diferencia := pasado. Sub (hora actual)
fmt. println("La diferencia entre ahora y el pasado es: ", diff)
// obtener la diferencia en varias unidades
años := En t(dif. Horas() / 24 / 365)
fmt. println("Años: ", años)
meses := En t(dif. Horas() / 24 / 30)
fmt. println("Meses: ", meses)
dias := En t(dif. Horas() / 24)
fmt. Println("Días: ", días)
horas := En t(dif. Horas())
fmt. println("Horas: ", horas)
// diferencia Minutos(), diferencia. Segundos(), diferencia. Milisegundos(), diferencia. Los nanosegundos() también devuelven sus unidades
}
Este código produce el siguiente resultado:
Cómo obtener la hora y la fecha en varios formatos
También puede obtener salidas de hora y fecha en múltiples formatos usando el Formato() función. Estos son algunos estilos de formato comunes:
funciónprincipal() {
curTime = tiempo. Ahora()
// estilos de formato estándar integrados
fmt. Println("La hora actual es: ", horaActual)
fmt. Println("La hora actual en formato RFC3339 es: ", curTime. Formato (tiempo. RFC3339))
fmt. Println("La hora actual en formato RFC3339Nano es: ", curTime. Formato (tiempo. RFC3339Nano))
fmt. Println("La hora actual en formato RFC1123 es: ", curTime. Formato (tiempo. RFC1123))
fmt. Println("La hora actual en formato RFC1123Z es: ", curTime. Formato (tiempo. RFC1123Z))
fmt. Println("La hora actual en formato RFC822 es: ", curTime. Formato (tiempo. RFC822))
fmt. Println("La hora actual en formato RFC822Z es: ", curTime. Formato (tiempo. RFC822Z))
fmt. Println("La hora actual en formato RFC850 es: ", curTime. Formato (tiempo. RFC850))
fmt. Println("La hora actual en formato ANSIC es: ", curTime. Formato (tiempo. ANSIC))
fmt. Println("La hora actual en formato Unix es: ", curTime. Formato (tiempo. Fecha Unix))
// estilos de formato personalizados
// DD-MM-AAAA HH: MM: SS
fmt. Println("La hora actual en formato personalizado es: ", curTime. Formato("02-01-200615:04:05"))
// MM-DD-AAAA HH: MM: SS
fmt. Println("La hora actual en formato personalizado es: ", curTime. Formato("01-02-200615:04:05"))
// AAAA-MM-DD HH: MM: SS
fmt. Println("La hora actual en formato personalizado es: ", curTime. Formato("2006-01-0215:04:05"))
// DD.MM.AAAA
fmt. Println("La hora actual en formato personalizado es: ", curTime. Formato("02.01.2006"))
// DD/MM/AAAA
fmt. Println("La hora actual en formato personalizado es: ", curTime. Formato("02/01/2006"))
// 01 de febrero de 2006
fmt. Println("La hora actual en formato personalizado es: ", curTime. Formato("02 Ene 2006"))
// 01 febrero 2006 lunes
fmt. Println("La hora actual en formato personalizado es: ", curTime. Formato("02 Febrero 2006 Lunes"))
// 01 febrero 2006 lun 15:04:05
fmt. Println("La hora actual en formato personalizado es: ", curTime. Formato("02 Febrero 2006 Lun 15:04:05"))
}
Estos diferentes tipos de formato producen el siguiente resultado:
Manipulación de hora y fecha en Go
La lista de manipulaciones que puedes realizar sobre horas y fechas es casi interminable. Según el alcance de su aplicación, es posible que deba realizar muchas operaciones de fecha y hora diversas.
Para cualquier caso de uso que pueda tener, el tiempo El paquete es muy funcional y tiene muchos métodos integrados.
Puede usar la manipulación de la fecha y la hora para crear un planificador diario simple o una aplicación de programación de tareas.