Trabalhando com data e hora em Rust

A manipulação de data e hora é um aspecto crucial de muitos aplicativos, desde o agendamento de tarefas e análise de dados até a execução de cálculos e a garantia da representação de dados.

Rust tem muitas bibliotecas e módulos para trabalhar com datas e horas. Rust fornece um built-in tempo crate para operações relacionadas ao tempo, e a biblioteca Chrono interopera com muitas outras bibliotecas Rust para operações de data e hora.

Começando a trabalhar com data e hora em Rust

Chrono é uma biblioteca de data e hora para lidar com datas, horas, fusos horários e durações no Rust. O Chrono fornece vários recursos e uma API intuitiva para tipos de data e hora, fusos horários e compensação de data e hora, duração e intervalo, análise e formatação e trabalho com calendários.

Chrono funciona bem com outras bibliotecas no ecossistema Rust e integra-se perfeitamente com o padrão características de E/S da biblioteca, permitindo que você leia e grave valores de data e hora do Chrono de e para vários fluxos.

Além disso, o Chrono tem suporte para serialização e desserialização por meio do serde crate, facilitando o trabalho com tipos Chrono em JSON, YAML e outros formatos. A integração do Chrono com o Serde o torna adequado para operações de data e hora enquanto Construindo aplicações web em Rust.

Você pode usar o Chrono para recuperar sua localização UTC (Tempo Universal Coordenado) para numerosas operações como conversões.

Adicione esta diretiva ao dependências seção do seu Cargo.toml arquivo para instalar e usar o crono caixote:

[dependências]
crono = "0.4.24"

Depois de instalar o crono caixa, você pode usar crono em seu projeto Rust importando a caixa da seguinte forma:

usar crono:: prelúdio::*;

Chrono é uma das caixas Rust que você precisará em seu arsenal de desenvolvimento, pois fornece a maioria dos recursos para operações de data e hora.

Fusos horários e tratamento de tempo em Rust com Chrono

Os fusos horários garantem que os carimbos de data/hora e as informações relacionadas ao tempo sejam precisos e consistentes em várias localizações geográficas. Ao trabalhar com dados relacionados ao tempo, é essencial considerar os fusos horários para evitar ambigüidades e imprecisões. Operações como comparar carimbos de data/hora, calcular durações ou agendar eventos sem o tratamento adequado do fuso horário podem gerar resultados inesperados.

Você pode converter entre fusos horários com Chrono. Aqui está um exemplo de conversão de um Data hora de um fuso horário para outro:

usar crono::{DataHora, Utc, Local, Fuso Horário};
fnconvert_timezone() {
deixar utc_time: DateTime = Utc:: agora();
deixar local_time: DateTime = utc_time.with_timezone(&Local);
println!("Hora UTC: {}", hora_utc);
println!("Horário local: {}", horário local);
}

O convert_timezone função recupera o UTC atual com o UTC:: agora método, converte o UTC para o fuso horário local com o with_timezone método que leva em consideração o Local estrutura e retorna um Data hora objeto que representa o mesmo ponto no tempo, mas no fuso horário local.

Quando você chama o convert_timezone função, ele imprimirá o UTC e a hora local no console.

Além disso, o Chrono fornece métodos e funcionalidades convenientes para o horário de verão (DST) e deslocamentos de fuso horário. Em seu sistema, você pode ajustar o relógio para o horário de verão através do aplicativo Configurações ou do Painel de Controle.

Aqui está um exemplo mostrando os recursos do Chrono com DST e compensações de tempo:

usar crono::{DateTime, Utc, FixedOffset};
fnhandle_dst() {
deixar utc_time: DateTime = Utc:: agora();
deixar ny_timezone = FixedOffset:: east(5 * 3600); 
// Horário de verão do leste (EDT) UTC-4:00 
deixar ny_time: DateTime = utc_time.with_timezone(&ny_timezone);
println!("Hora UTC: {}", hora_utc);
println!("Horário de Nova York: {}", ny_time);
}

O handle_dst função acessa a hora atual com o agora método e recupera o tempo em Nova York enquanto contabiliza o tempo de deslocamento com o FixedOffset:: leste método.

Ao ligar para o with_timezone função, você está convertendo o UTC para o fuso horário de Nova York. Chrono lida com os ajustes de tempo de acordo com o horário de verão apropriado e retorna um Data hora objeto.

Ao operar com horário de verão, é crucial lembrar que as transições de horário de verão ocorrem em datas e horários específicos. crono Data hora struct está equipado para lidar com essas transições e garantir representações precisas de tempo em diferentes fusos horários.

Cálculos de duração e intervalo

Uma duração é um tempo independente de qualquer ponto específico no tempo. Você pode precisar calcular a duração entre dois eventos, medir o tempo decorrido ou adicionar ou subtrair uma certa quantidade de um tempo especificado.

A biblioteca padrão do Rust tempo A caixa fornece ferramentas abrangentes para lidar com durações com eficiência.

Veja como você pode medir o tempo de execução de uma função com o tempo caixote:

usar crono::{DataHora, Utc};
usar padrão:: tempo:: Instantâneo;
fnprincipal() {
deixar início = Instantâneo:: agora();
// Executa alguma operação
// ...
deixar fim = Instantâneo:: agora();
deixar duração = end.duration_since (início);
println!("Tempo decorrido: {:?}", duração);
}

O principal função recupera a hora atual com o Instante método do embutido tempo engradado. Após a operação, o principal função recupera o tempo naquele instante e avalia a diferença com o duração_desde antes de imprimir a diferença de horário no console.

Serializando e desserializando: convertendo data e hora JSON em estruturas de ferrugem usando Chrono

Serializar e desserializar valores de data e hora do JSON usando Chrono e Serde é um processo direto. Primeiro, adicione o serde e serde_json crates para as dependências do seu projeto.

[dependências]
serde = { versão = "1.0", características = ["derivar"] }
serde_json = "1.0"

Em seguida, você terá que definir o tipo Rust e implementar o #[derivar (serializar, desserializar)] atributos para o tipo onde você especificará o tipo de dados:

usar crono::{DataHora, Utc};
#[derivar (serializar, desserializar)]
estruturaReunião {
 start_time: DateTime,
 end_time: DateTime,
}

Você pode serializar o Reunião struct para JSON com Serde juntamente com os recursos de formatação do Chrono.

Veja como você pode converter uma instância do Reunião digite para JSON:

usar serde_json:: to_string;
fnprincipal() {
deixar reunião = Reunião {
 start_time: Utc:: agora(),
 end_time: Utc:: agora(),
 };
deixar json = to_string(&meeting).unwrap();
println!("{}",json);
}

O principal função cria um Reunião instância com o UTC atual para os campos antes de usar o para sequenciar função para converter a instância struct em uma string JSON impressa no console.

Você pode facilmente desserializar dados de data e hora JSON em um tipo struct com serde_json's from_str função que recebe uma string JSON e retorna uma instância struct.

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

O principal A função desserializa a string JSON do json variável no reunião instância do Reunião struct antes de imprimir a instância de struct no console.

Você pode construir aplicativos sofisticados com Rust

A robustez, a facilidade de uso e a ampla funcionalidade do Chrono o tornam uma ferramenta indispensável para lidar com datas, horários, duração e intervalos de seus aplicativos. Você pode garantir cálculos de tempo precisos, agendamento eficiente e operações confiáveis ​​relacionadas a datas, aproveitando os recursos do Chrono.

Um caso de uso importante para o Chrono é a criação de aplicativos da web. Você pode usar o Chrono para registros de tempo de atividade, cronometrar a atividade do usuário e outras operações da web.