Trabajar con fecha y hora en Rust

El manejo de la fecha y la hora es un aspecto crucial de muchas aplicaciones, desde la programación de tareas y el análisis de datos hasta la realización de cálculos y la garantía de la representación de los datos.

Rust tiene muchas bibliotecas y módulos para trabajar con fechas y horas. Rust proporciona un integrado tiempo crate para operaciones relacionadas con el tiempo, y la biblioteca Chrono interactúa con muchas otras bibliotecas de Rust para operaciones de fecha y hora.

Comenzando a trabajar con fecha y hora en Rust

Chrono es una biblioteca de fecha y hora para manejar fechas, horas, zonas horarias y duraciones en Rust. Chrono proporciona múltiples funciones y una API intuitiva para tipos de fecha y hora, zonas horarias y fecha y hora compensadas, duración e intervalo, análisis y formateo, y trabajo con calendarios.

Chrono juega bien con otras bibliotecas en el ecosistema de Rust y se integra a la perfección con el estándar características de E/S de la biblioteca que le permiten leer y escribir valores de fecha y hora de Chrono desde y hacia varios arroyos

Además, Chrono tiene soporte para serialización y deserialización a través del Serde crate, lo que facilita el trabajo con tipos Chrono en JSON, YAML y otros formatos. La integración de Chrono con Serde lo hace adecuado para operaciones de fecha y hora mientras construyendo aplicaciones web en Rust.

Puede usar Chrono para recuperar su ubicación UTC (Tiempo Universal Coordinado) para numerosas operaciones como conversiones.

Agregue esta directiva a la dependencias sección de su Cargo.toml archivo para instalar y usar el crono caja:

[dependencias]
crono = "0.4.24"

Después de instalar el crono caja, puedes usar crono en su proyecto Rust importando la caja de la siguiente manera:

usar crono:: preludio::*;

Chrono es una de las cajas de Rust que necesitará en su arsenal de desarrollo, ya que proporciona la mayoría de las funciones para las operaciones de fecha y hora.

Zonas horarias y manejo del tiempo en Rust With Chrono

Las zonas horarias garantizan que las marcas de tiempo y la información relacionada con la hora sean precisas y coherentes en varias ubicaciones geográficas. Al trabajar con datos relacionados con el tiempo, es esencial tener en cuenta las zonas horarias para evitar ambigüedades e imprecisiones. Operaciones como la comparación de marcas de tiempo, el cálculo de duraciones o la programación de eventos sin el manejo adecuado de la zona horaria pueden generar resultados inesperados.

Puede convertir entre zonas horarias con Chrono. He aquí un ejemplo de cómo convertir un Fecha y hora de una zona horaria a otra:

usar crono::{DateTime, Utc, Local, TimeZone};
fnconvert_timezone() {
dejar utc_time: fecha y hora = Utc:: ahora();
dejar hora_local: fecha y hora = utc_time.with_timezone(&Local);
imprimir!("Hora UTC: {}", hora_utc);
imprimir!("Hora local: {}", hora local);
}

El convert_timezone función recupera el UTC actual con el Utc:: ahora método, convierte el UTC a la zona horaria local con el con_zonahoraria método que toma en referencia a la Local estructura y devuelve un Fecha y hora objeto que representa el mismo punto en el tiempo pero en la zona horaria local.

Cuando llamas al convert_timezone función, imprimirá el UTC y la hora local en la consola.

Además, Chrono proporciona métodos y funcionalidades convenientes para el horario de verano (DST) y las compensaciones de zona horaria. En su sistema, puede ajustar el reloj para el horario de verano a través de la aplicación Configuración o el Panel de control.

Aquí hay un ejemplo que muestra las capacidades de Chrono con DST y compensaciones de tiempo:

usar crono::{DateTime, Utc, FixedOffset};
fnhandle_dst() {
dejar utc_time: fecha y hora = Utc:: ahora();
dejar ny_timezone = FixedOffset:: east(5 * 3600); 
// Hora de verano del Este (EDT) UTC-4:00 
dejar ny_time: fecha y hora = utc_time.with_timezone(&ny_timezone);
imprimir!("Hora UTC: {}", hora_utc);
imprimir!("Tiempo de Nueva York: {}", Hora de Nueva York);
}

El handle_dst función accede a la hora actual con el ahora método y recupera la hora en Nueva York mientras contabiliza el tiempo de compensación con el Desplazamiento fijo:: este método.

llamando al con_zonahoraria función, está convirtiendo el UTC a la zona horaria de Nueva York. Chrono maneja los ajustes de hora de acuerdo con el DST apropiado y devuelve un Fecha y hora objeto.

Al operar con DST, es crucial recordar que las transiciones de DST ocurren en fechas y horas específicas. de crono Fecha y hora struct está equipado para manejar estas transiciones y garantizar representaciones precisas del tiempo en diferentes zonas horarias.

Cálculos de duración e intervalo

Una duración es un tiempo independiente de cualquier punto específico en el tiempo. Es posible que deba calcular la duración entre dos eventos, medir el tiempo transcurrido o sumar o restar una cierta cantidad de un tiempo específico.

La biblioteca estándar de Rust tiempo crate proporciona herramientas integrales para el manejo eficiente de las duraciones.

Así es como puede medir el tiempo de ejecución de una función con el tiempo caja:

usar crono::{DateTime, Utc};
usar std:: time:: Instant;
fnprincipal() {
dejar inicio = Instantáneo:: ahora();
// Realizar alguna operación
// ...
dejar fin = Instantáneo:: ahora();
dejar duración = final.duración_desde (inicio);
imprimir!("Tiempo transcurrido: {:?}", duración);
}

El principal función recupera la hora actual con el Instante método de la incorporada tiempo caja. Después de la operación, el principal recupera la hora en ese instante y evalúa la diferencia con la duración_desde antes de imprimir la diferencia horaria en la consola.

Serialización y deserialización: conversión de fecha y hora JSON en estructuras Rust con Chrono

Serializar y deserializar valores de fecha y hora de JSON mediante Chrono y Serde es un proceso sencillo. Primero, agregue el serde y serde_json crates a las dependencias de su proyecto.

[dependencias]
serde = { versión = "1.0", caracteristicas = ["derivar"] }
serde_json = "1.0"

A continuación, deberá definir el tipo Rust e implementar el #[derivar (Serializar, Deserializar)] atributos para el tipo donde especificará el tipo de datos:

usar crono::{DateTime, Utc};
#[derivar (Serializar, Deserializar)]
estructuraReunión {
 hora_de_inicio: fecha y hora,
 hora_fin: fecha y hora,
}

Puede serializar el Reunión struct a JSON con Serde junto con las capacidades de formato de Chrono.

Así es como puede convertir una instancia del Reunión escriba a JSON:

usar serde_json:: to_string;
fnprincipal() {
dejar reunión = Reunión {
 hora_inicio: Utc:: ahora(),
 hora_fin: Utc:: ahora(),
 };
dejar json = to_string(&reunión).unwrap();
imprimir!("{}", json);
}

El principal función crea un Reunión instancia con el UTC actual para los campos antes de usar el Encadenar función para convertir la instancia de estructura en una cadena JSON impresa en la consola.

Puede deserializar fácilmente los datos de fecha y hora de JSON en un tipo de estructura con serde_json from_str función que toma una cadena JSON y devuelve una instancia de estructura.

usar serde_json:: from_str;
fnprincipal() {
dejar json = r#"{"start_time": "2023-05-28T12:00:00Z", "end_time": "2023-05-28T14:00:00Z"}"#;
dejar reunión: Reunión = from_str (json).unwrap();
imprimir!("{:#?}", reunión);
}

El principal función deserializa la cadena JSON de la json variable en el reunión instancia de la Reunión struct antes de imprimir la instancia de struct en la consola.

Puede crear aplicaciones sofisticadas con Rust

La robustez, la facilidad de uso y la amplia funcionalidad de Chrono lo convierten en una herramienta indispensable para manejar las fechas, horas, duración e intervalos de sus aplicaciones. Puede garantizar cálculos de tiempo precisos, programación eficiente y operaciones confiables relacionadas con la fecha aprovechando las capacidades de Chrono.

Un caso de uso clave para Chrono es la creación de aplicaciones web. Puede usar Chrono para registros de tiempo de actividad, cronometrar la actividad del usuario y otras operaciones web.