【跟小嘉学 Rust 编程】二十八、Rust中的日期与时间(DateTime)

系列文章目录

【跟小嘉学 Rust 编程】一、Rust 编程基础
【跟小嘉学 Rust 编程】二、Rust 包管理工具使用
【跟小嘉学 Rust 编程】三、Rust 的基本程序概念
【跟小嘉学 Rust 编程】四、理解 Rust 的所有权概念
【跟小嘉学 Rust 编程】五、使用结构体关联结构化数据
【跟小嘉学 Rust 编程】六、枚举和模式匹配
【跟小嘉学 Rust 编程】七、使用包(Packages)、单元包(Crates)和模块(Module)来管理项目
【跟小嘉学 Rust 编程】八、常见的集合
【跟小嘉学 Rust 编程】九、错误处理(Error Handling)
【跟小嘉学 Rust 编程】十一、编写自动化测试
【跟小嘉学 Rust 编程】十二、构建一个命令行程序
【跟小嘉学 Rust 编程】十三、函数式语言特性：迭代器和闭包
【跟小嘉学 Rust 编程】十四、关于 Cargo 和 Crates.io
【跟小嘉学 Rust 编程】十五、智能指针(Smart Point)
【跟小嘉学 Rust 编程】十六、无畏并发(Fearless Concurrency)
【跟小嘉学 Rust 编程】十七、面向对象语言特性
【跟小嘉学 Rust 编程】十八、模式匹配(Patterns and Matching)
【跟小嘉学 Rust 编程】十九、高级特性
【跟小嘉学 Rust 编程】二十、进阶扩展
【跟小嘉学 Rust 编程】二十一、网络编程
【跟小嘉学 Rust 编程】二十三、Cargo 使用指南
【跟小嘉学 Rust 编程】二十四、内联汇编(inline assembly)
【跟小嘉学 Rust 编程】二十五、Rust命令行参数解析库(clap)
【跟小嘉学 Rust 编程】二十六、Rust的序列化解决方案(Serde)
【跟小嘉学 Rust 编程】二十七、Rust 异步编程(Asynchronous Programming)
【跟小嘉学 Rust 编程】二十八、Rust中的日期与时间

前言

本章节讲解 Rust 的异步编程方案，我们将讲解 Future、Waker、Executor、Pin、async 和 await、Stream等

主要教材参考 《The Rust Programming Language》
主要教材参考 《Rust For Rustaceans》
主要教材参考 《The Rustonomicon》
主要教材参考 《Rust 高级编程》
主要教材参考 《Cargo 指南》
主要教材参考 《Rust 异步编程》

---

一、Rust 标准库中的日期与时间

Rust 标准库中提供了默认的时间类型：std:time:SystemTime 和 std:time:Duration

1.1、时间类型（std:time:SystemTime）

1.1.1、创建 std:time:SystemTime

在 Rust 中 std:time:SystemTime 是默认的时间类型，它表示从 Unix 纪元（1970年1月1日）起的时间点。std:time:SystemTime 可以用来表示过去或者未来的时间，以及时间间隔。

use std::time::SystemTime;

fn main(){
    let now = SystemTime::now();
    println!("当前时间：{:?}", now);
}

输出结果

当前时间：SystemTime { tv_sec: 1694959432, tv_nsec: 564005000 }

1.1.2、比较 SystemTime 实例

可以使用比较运算符(例如：<、>、<=、>=) 来比较 SystemTime 的大小。

use std::time::{SystemTime, Duration};

fn main(){
    let now = SystemTime::now();
    let future = now + Duration::from_secs(60);
    println!("当前时间：{:?}", now> future);
}

1.1.3、elapsed 方法

返回系统时间与当前时间的差值。这个函数如果返回OK，那么就是返回从此时间到当前时间所经过的时间量。如果要可靠测量经过的时间，使用 Instant 代替。

use std::time::SystemTime;
use std::time::Duration;
use std::thread;

fn main(){
    let now = SystemTime::now();
    thread::sleep(Duration::from_secs(1));

    match now.elapsed() {
        Ok(elapsed) =>{
            println!("{}",elapsed.as_secs());
        }
        Err(e) => {
            println!("Error: {e:?}");
        }
    }
}

1.2、时间间隔类型（std:time:Duration）

在 Rust 中 Duration 表示时间间隔。

use std::time::Duration;
let five_seconds = Duration::new(5, 0);

new 方法的参数，第一个参数是秒数，第二个参数是纳秒数。

1.3、即时类型(std::time::Instant)

use std::time::Instant;

fn main(){
    let now = Instant::now();
    println!("Instant: {:?}", now);
}

返回查看函数运行时间

use std::time::Instant;

fn run_time() {
    let now = Instant::now();
    // 执行函数
    run();
    println!("执行时间: {}", now.elapsed().as_millis());
}

fn run() {} 

二、time 库

2.1、time 库介绍

time 是一个 Rust的日期时间库，他有如下的特点

• 方便且安全，time 有一个简单的API；
• 空间优化效率高，支持 ±999,999 年的范围内的日期，精度为纳秒；
• 序列化准备，支持ISO8601, RFC2822 and RFC3339 特性
• const 准备的 API
• 支持 no-std 属性

2.2、添加依赖

cargo add time

2.3、使用方法

2.3.1、获取当前时间的UTC偏移量

获取当前时间的UTC偏移量；

use time::OffsetDateTime;

fn main(){
    let now = OffsetDateTime::now_utc();
    print!("{now}");
}

输出结果

2023-09-17 15:10:26.798899 +00:00:00%

2.3.2、创建日期和时间

2.3.2.1、使用方法来创建日期和时间对象

use time::{Date, UtcOffset};

fn main(){
    let date = Date::from_iso_week_date(2023, 1, time::Weekday::Friday).unwrap();
    let datetime = date.with_hms(5, 20, 0).unwrap();
    let datetime_off = datetime.assume_offset(UtcOffset::from_hms(1, 2, 3).unwrap());

    println!("{date}, {datetime}, {datetime_off}");
}

输出结果

2023-01-06, 2023-01-06 5:20:00.0, 2023-01-06 5:20:00.0 +01:02:03

2.3.2.2、使用宏来创建

use time::macros::{date,datetime};

fn main(){
    let date = date!(2023-05-20);
    let datetime = datetime!(2023-05-20 13:14:52);
    let datetime_off =  datetime!(2023-05-20 13:14:52 +1:02:03);
    println!("{date}, {datetime}, {datetime_off}");
    // 2023-05-20, 2023-05-20 13:14:52.0, 2023-05-20 13:14:52.0 +01:02:03
}

2.3.3、计算时间间隔

use time::Duration;
use time::macros::datetime;

fn main(){
    let a = datetime!(2022-01-01 10:00:55);
    let b = datetime!(2022-01-01 13:00:00);
    
    let duration: Duration = b - a;
    
    println!("{}", duration);     // 2h59m5s
}

2.3.4、字符串与日期时间转换

要使用该功能需要开启 parsing 特征

time = { version = "0.3.28", features = ["macros","parsing"] }

2.3.4.1、字符串转换为日期时间对象

use time::format_description::well_known::Iso8601;
use time::PrimitiveDateTime;

fn main(){
    let date = PrimitiveDateTime::parse("2022-01-02T11:12:13", &Iso8601::DEFAULT).unwrap();
    
    println!("{}", date);     // 2022-01-02 11:12:13.0
}

2.3.4.2、自定义格式字符串转换为时间对象

use time::macros::format_description;
use time::Time;


fn main(){
    let my_format = format_description!("h=[hour],m=[minute],s=[second]");
    let time = Time::parse("h=11,m=12,s=13", &my_format).unwrap();
    println!("{}", time);     // 11:12:13.0
}

2.3.2、支持序列化

需要开启 serde-well-known 特性。

use time::macros::format_description;
use time::{OffsetDateTime, Time};
use serde::{Deserialize};

#[derive(Deserialize)]
struct Notification {
    message: String,
    #[serde(with = "time::serde::iso8601")]
    timestamp: OffsetDateTime,
}

fn main() {
    let input = r#"{
      "message": "foo",
      "timestamp": "2022-01-02T11:12:13Z"
    }"#;

    let notification: Notification = serde_json::from_str(input).unwrap();
    println!("{:?}", notification.timestamp);
}

三、chrono 库

3.1、chrono库介绍

chrono 支持各种运行时环境和操作系统，支持的特征如下两大类

• 默认特征：
  • alloc：企业用依赖于分配的特性，主要是字符串格式化
  • std：启用依赖于标准库的功能，这是alloc 的超集，增加了与标准库类型和特征的互操作；
  • clock：启用读取系统时间，此类api取决于 unix 操作系统的标准库 和 Windows API
  • wasmbind： 与 wasm32 目标的JS Date API 接口
• 可选特征
  • serde、rkyv 序列化
  • arbitrary：使用任意 crate 类型构造类型的任意实例
  • unstable-locales：支持本地化，这个将带有_localization 后缀的各种方法，实现和API可能会更改，甚至删除。
  • oldtime：这个特性不再与功能，但是曾经提供了 time 0.1 的兼容性；

添加依赖

cargo add chrono

3.2、chrono 常用操作

3.2.1、DateTime

3.2.1.1、获取当前时间

use chrono::{Local, DateTime};

fn main(){
	// 获取当前时间
    let datetime: DateTime<Local> = Local::now();
    println!("datetime = {:#?}", datetime);
	
	// 获取日期
	println!("datetime.date_naive()= {:#?} ",datetime.date_naive());

	// 获取时间戳
	println!("datetime.timestamp()= {:#?} ",datetime.timestamp());
}

3.2.1.2、i64时间戳转换日期时间

use chrono::{Utc, TimeZone};

fn main(){
	// 时间戳转换
	let timestamp:i64 = 1694966356;
	let new_utc_dt = Utc.timestamp_opt(timestamp + 30, 0).unwrap();
	println!("new_utc_dt = {:#?}", new_utc_dt);
}

3.2.1.3、日期时间格式化

1、时间转换为字符串

use chrono::{Local, DateTime};

fn main(){
	let local:DateTime<Local>  = Local::now();
	let format = local.format("%Y-%m-%d %H:%M:%S");
	println!("{:#?}", format!("{}", format));
}

2、字符串转换为日期时间

use chrono::{DateTime, FixedOffset, ParseResult, NaiveDateTime};

fn main(){
	let t = NaiveDateTime::parse_from_str("2022-02-10 00:00:00", "%Y-%m-%d %H:%M:%S").unwrap();
	println!("{:?}", t);
    println!("{:?}", t.date());
	println!("{:?}",t.to_string());
	
	let t1: ParseResult<DateTime<FixedOffset>> =
	DateTime::parse_from_str("2020-03-28 21:00:09 +09:00", "%Y-%m-%d %H:%M:%S %z");
	println!("{:?}", t1.unwrap().date_naive());
}

3.2.2、时区相关

use chrono::FixedOffset;

fn main(){
	let timezone_offset =FixedOffset::east_opt(8*3600).unwrap();
	println!("timezone_offset = {:#?}", timezone_offset);
}

3.2.3、Duration

Duration代表来一个时间段，例如2分钟，4小时等；

use chrono::Duration;

fn main(){
	let duration = Duration::days(1);
	println!("{:#?}",duration.num_seconds());
}

四、coarsetime库

4.1、coarsetime介绍

提供有高性能的 Duration、Instant 实现

添加依赖

cargo add coarsetime

4.2、Duration

use coarsetime::{Instant, Duration};

fn main(){
	let d = Duration::from_days(1);
	println!("{:#?}", d);
}

4.3、Instant

use coarsetime::Instant;

fn main(){
	let now = Instant::now();
	let ts1 = Instant::recent();

	println!("now :  {:#?}", now);
	println!("ts1 :  {:#?}", ts1);

	Instant::update();
	let ts2= Instant::recent();
	println!("now :  {:#?}", now);
	println!("ts1 :  {:#?}", ts1);
	println!("ts2 :  {:#?}", ts2);
	
}

总结

本章节讲解标准库、time库、chrono库、coarsetime库的介绍。