rust中获取时间精确到毫秒

首先再Cargo.toml导入时间库包
1.

[dependencies]
time = "0.1.41"
date_time = "2.1.1"
regex = "0.1"
chrono = { version = "0.4", features = ["serde", "rustc-serialize"] }

2.
lib.rs导入exampletime下的time文件

3.导入chrono时间库和代码进行测试

use chrono::prelude::*;

 pub fn time_x(){
//获取当前毫秒值
   let now: DateTime<Local> = Local::now();
   let mills: i64 = now.timestamp_millis(); 
  println!("获取毫秒的值: {}", mills);
 
   let dt: DateTime<Local> = Local.timestamp_millis(mills);
    // date time parsed millis: 2021-01-04 20:01:36.945 +08:00
   println!("获取精确到毫秒时间: {}", dt); 
 }

#[test]
fn main (){
    time();
}

获取时间的所有方法

// use std::fs::File;

// fn main() {
//     let arr = [1, 3, 5, 7, 9];
//     let part = &arr[0..2];
//     for i in part.iter() {
//         println!("{}", i);
//     }


//     let f= File::open("hello.txt");
//     match f {
//         Ok(file) =>{
//             print!("success");
//         },
//         Err(err) =>{
//             println!("erro");
//         }
//     }

//     //切片例子
//     let  s = String::from("Hello world");
//     let hello = &s[0..5];
//     let world = &s[6..11];
//     println!("{}",hello);

//     let a = [1, 2, 3, 4, 5];
//     let slica = &a[1..3];

// }


//监听连接内容  TcpStream流接收的内容
// use std::net::{TcpListener, TcpStream};
// use std::io::Read;//

// fn main() -> std::io::Result<()> {
    
//      let  listener = TcpListener::bind("127.0.0.1:8080")?;//绑定
//      //let mut stream = TcpListener::connect("127.0.0.1:8080").unwrap();

//      for stream in listener.incoming(){//incoming返回 迭代器  
//          handle_client(stream?);//接收的内容
//      }
     

//     Ok(())//结构体
// } // the stream is closed here
 
//     //stream对收到的内容做一下处理   _就是stream忽视提示
// fn handle_client(mut stream: TcpStream){
//        // println!("rust连接监听成功")

//         let get = b"Get /HTTP/1.1\r\n";
       

//        //读取请求的内容
//         let mut buffer =[0;512];
//         stream.read(&mut buffer).unwrap();//可变引用 
//         println!("Request: {}",String::from_utf8_lossy(&buffer[..]));//转换成字符串类型
// }




//HashMap   没有内置的宏来创建 HashMap
// use std::collections::HashMap;
// fn main(){
//     //
//     let field_name = String::from("Favorite color");
//     let field_value =String::from("Blue");
//     let mut map =HashMap::new();
//     //map.insert(field_name,field_value);//这个是错误的，不可以直接传入值进行输出
//     map.insert(&field_name,&field_value);//传入自己的引用。进行输出
//     println!("{}:{}",field_name,field_value);

//     //HashMap 获取值
//     //let mut scores: HashMap<String,i32> = HashMap::new();//可以这个弄，还可以想下面这样new()
//     let mut scores = HashMap::new();
//     scores.insert(String::from("Blue"), 10);
//     scores.insert(String::from("Yellow"), 20);
    
//     let team_name = String::from("Blue");
//     let score = scores.get(&team_name);//返回的是score这个枚举需要处理下，如下：

//     //如果返回的是Some 那么取出值并打印。None不存在
//     match score {
//         Some(s) => println!("{}",s),
//         None => println!("team not exist"),
//     };

//     //HashMap更新,

//     //1.替换
    // let mut map =HashMap::new();
    // map.insert(String::from("Blue"),10);
    // map.insert(String::from("Blue"),25);
    // println!("{:?}",map);

//     //2.插入新值
    // let mut map =HashMap::new();
    // map.insert(String::from("Blue"),10);
    // let e =map.entry(String::from("Yellow"));
    // println!("{:?}",e);
    // e.or_insert(50);
    // map.entry(String::from("Blue")).or_insert(50);//查看Blue这个值是存在的，如果不存在就不会添加Yellow
    // println!("{:?}",map);

    //3.判断字符出现的次数
 //   let text = "hello world wonderful world";

//     let mut map =HashMap::new();

//     for word in text.split_whitespace(){
//         let count = map.entry(word).or_insert(0);
//         *count +=1;
//     }
//     println!("{:#?}",map);
// }



//创建文件
// use std::fs::File;
// use std::io::ErrorKind;

// fn main(){
//     //测试文件是否存在，如果不存在返回一个宏unwrap 错误。
//     //let f =File::open("hello.txt").unwrap();
//     //expect指定错误信息
//     //let f =File::open("hello.txt").expect("无法打开文件，文件找不到");

//     let f = File::open("hello.txt");
//     let f = match f{
//         Ok(file) => file,//创建一个 文件
//         Err(error) =>match error.kind(){
//             ErrorKind::NotFound => match File::create("hello.txt"){
//                 Ok(fc) => fc,
//                 Err(e) => panic!("Error creating file: {:?}",e),
//             },
//                 oe => panic!("Error opening the file:{:?}",oe),  
//             //other_error => panic!("Error opening the file:{:?}",other_error),  
//         },
//     };
// }



//寻找集合中的最大值
// fn largest(list: &[i32] -> i32){
//     let mut largest =list[0];
//     for &item in list{
//         if item >largest {
//             largest = item;
//         }
//     }
//     largest;
// }


// fn main(){
//     let number_list =vec![1,2,3,90];
//     let mut largest =number_list[0];
//     for number in number_list {
//         if number >largest{
//             largest = number;
//         }
//     }
//     println!("The largest number is {}",largest);
// }




//找出最大值
// fn main(){
//     let number_list =vec![34,50,25,110,65];
//     let mut largest =number_list[0];
//     for number in number_list {
//         if number >largest {
//             largest = number;
//         }
//     }
//     println!("largest输出:{}",largest);
// }


//类型转换
// fn main() {
//     let tup = (1, 2);

//     let mut fun  = add1 as fn((i32, i32))->i32;  
//     println!("x = {}", fun(tup));

//     fun = add3;
//     println!("x = {}", fun(tup));

//     fun = add2;
//     println!("x = {}", fun(tup));
// }

// fn add1(t:(i32, i32))->i32{
//     return t.0 + t.1;
// }

// fn add3(t:(i32, i32))->i32{
//     return t.0 + t.1;
// }

// fn add2((x, y):(i32, i32))->i32{
//     x + y
// }



// use time;
// fn main(){
//     //rust 获取10位时间戳
//     let time = time::get_time();
//     println!("{}",format!("{:#?}",time.sec));
    
// }



// use std::time::Instant; // timer

// fn main() {
//     let start = Instant::now();
 	
//  	//even number range in[0, 4000001)
//     let iter = (0..400_0001).filter(|x| x % 2 == 0);
//     let res:i64 = iter.sum();
//     println!("iter.sum is: {:?}", res);
    
//     println!("time cost: {:?} ms", start.elapsed().as_millis());// ms(毫秒)
//     println!("time cost: {:?} us", start.elapsed().as_micros());// us（微妙）
//     println!("time cost: {:?} ns", start.elapsed().as_nanos());// us
// }

/*
iter.sum is: 4000002000000
time cost: 299 ms
time cost: 302236 us
time cost: 302829500 ns
*/


// extern crate time;
// use std::thread;
// use time::*;
// use std::time::Instant; // timer 时间戳
 
// fn main(){
 
//     let now = time::now();
//     let f_now = time::strftime("%Y-%m-%d --- %H:%M:%S%.3f", &now).unwrap();
//     println!("now: {:?}", f_now);



    
   
//     let start = Instant::now();
 	
//   //even number range in[0, 4000001)
//    let iter = (0..400_0001).filter(|x| x % 2 == 0);
//    let res:i64 = iter.sum();
//    println!("iter.sum is: {:?}", res);
   
//    println!("time cost: {:?} ms", start.elapsed().as_millis());// ms 毫秒
//    println!("time cost: {:?} us", start.elapsed().as_micros());// us微妙
//    println!("time cost: {:?} ns", start.elapsed().as_nanos());// us
    
// }

//rust 获取10位时间戳
// use std::time::Instant; // timer
// use std::time::{Duration, SystemTime};
// fn main() {
//     use time;
//     let time = time::get_time();
//     println!("{}",format!("{:#?}",time.sec));
// }

//当前毫秒数和当前毫秒的整数
// use chrono::prelude::*;

// fn main(){
//     let now: DateTime<Local> = Local::now();
//     let mills: i64 = now.timestamp_millis(); 
//     println!("current time millis: {}", mills);
 
//     let dt: DateTime<Local> = Local.timestamp_millis(mills);
//     // date time parsed millis: 2021-01-04 20:01:36.945 +08:00
//     println!("date time parsed millis: {}", dt); 

// }






use std::time::{Duration, SystemTime};
extern crate chrono; // 时间库
extern crate time; // 时间戳，差值
use chrono::prelude::*;
// =========== 时间 格式化和计算
// 这个 time::Duration 和 use std::time::Duration; 是不一样的。chrono 是用的这个 time::Duration，这里as了一下是为和 标准库 区分
//use time::Duration as Durationx; 
// time::Duration 已经升级为 chrono::Duration，所以改为
use chrono::Duration as Durationx; //这样就可以编译通过了
// std::time::Duration; 这个是用在线程休眠上 比如 thread::sleep(Duration::from_secs(1));
fn main(){

   
    let time = time::get_time();
    println!("{}",format!("{:#?}",time.sec));

    let now: DateTime<Local> = Local::now();
    let mills: i64 = now.timestamp_millis(); 
    println!("获取毫秒的值: {}", mills);

    let dt: DateTime<Local> = Local.timestamp_millis(mills);
    // date time parsed millis: 2021-01-04 20:01:36.945 +08:00
   println!("获取精确到毫秒时间: {}", dt); 


    let sys_time = SystemTime::now();
    println!("now time 显示的是一个长整数 {:?}", sys_time);
    let local: DateTime<Local> = Local::now(); // 本地时间
    println!(
        " date 精确到秒 ({:?})",
        local.format("%Y-%m-%d %H:%M:%S").to_string()
    );
    println!(
        " date 精确到毫秒 ({:?})",
        local.format("%Y-%m-%d %H:%M:%S%.3f").to_string()
    );
    println!(
        " date 精确到微秒 ({:?})",
        local.format("%Y-%m-%d %H:%M:%S%.6f").to_string()
    );
    println!(
        " date 精确到纳秒 ({:?})",
        local.format("%Y-%m-%d %H:%M:%S%.9f").to_string()
    );
    let _t0u0 = Utc.ymd(2014, 7, 8).and_hms_micro(9, 10, 11, 12_000); // Utc带时区 全球时间
    let _t0u1 = Utc.ymd(2014, 7, 8).and_hms_nano(9, 10, 11, 12_000_000);
    let _t0l0 = Local.ymd(2014, 7, 8).and_hms_micro(9, 10, 11, 12_000); // 本地时间
    let _t0l1 = Local.ymd(2014, 7, 8).and_hms_nano(9, 10, 11, 12_000_000);
    // 时间加减
    let _t0_as_0 = Utc.ymd(1970, 1, 1).and_hms(0, 0, 0) + Durationx::seconds(1_000_000_000);
    let _t0_as_1 = Utc.ymd(2020, 2, 1).and_hms(0, 0, 0)
        - Durationx::from_std(Duration::from_secs(1_000_000_258)).unwrap();
    println!(
        " 本地时间 20200201 + 1_000_000_000 10亿秒 把标准库10亿秒转换成time10亿秒 再加时间计算 {:?}",
        _t0_as_1.format("%y-%m-%d %H:%M:%S.%3f").to_string()
    );

    let _t0_as_2 = Local.ymd(2020, 1, 1).and_hms(0, 0, 0)
        + Durationx::from_std(Duration::from_millis(1_258_101_957)).unwrap(); // Durationx::from_std 方法从标准库的时间戳转换

    println!(
        " 本地时间 20200101 + 2_000_000_000 20亿秒 转换标准库 12亿 毫秒 {:?}",
        _t0_as_2.format("%y-%m-%d %H:%M:%S.%3f").to_string()
    );

    println!(
        " 本地时间 20200101 + 2_000_000_000 20亿秒 {:?}",
        _t0_as_2.format("%Y-%m-%d %H:%M:%S.%6f").to_string()
    );
    println!(
        " 本地时间 20200101 + 2_000_000_000 20亿秒 {:?}",
        _t0_as_2.format("%Y-%m-%d %H:%M:%S.%9f").to_string()
    );
    let t0_fmt_01 =
        DateTime::parse_from_str("1983 Apr 13 12:09:14.274 +0000", "%Y %b %d %H:%M:%S%.3f %z"); // 注意 %.3f 这个写法
    println!(
        r#" 从字符串 "1983 Apr 13 12:09:14.274 +0000", 格式字符： "%Y %b %d %H:%M:%S%.3f %z" 格式化而来的时间 显示 {:?}"#,
        t0_fmt_01.unwrap()
    );
    // 字符串转换时间类型
    // 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: ParseResult<DateTime<FixedOffset>>({:?})", t1);
    // // 常见转换输入 写法 .ok().unwrap() 很重要
    // let t2: ParseResult<DateTime<Utc>> =
    //     Utc.datetime_from_str("2020-03-06 12:00:09", "%Y-%m-%d %H:%M:%S");
    // println!(
    //     "t2: ParseResult<DateTime<Utc>>({:?})",
    //     t2.ok().unwrap().format("%y-%m-%d %H:%M:%S").to_string()
    // );
    //

    //转换成自己定义的时间戳
    let t3: DateTime<Local> = Local
        .datetime_from_str("2020-03-28 12:00:09", "%Y-%m-%d %H:%M:%S")
        .ok()
        .unwrap();
    //println!("t3: DateTime<Local>({:?})", t3.sec);
    println!("{}",format!("{:#?}",t3.timestamp_millis()));
}



//计算器
// use std::time::SystemTime;
// pub struct Stock{
//     pub price:f64,
//     pub volume:i32,
//     pub code:String,
//     pub amount:f64,
// }
// impl Stock{
//     fn default()->Self{
//         let p =10000.0_f64;
//         let v =1_i32;
//         Stock{
//             price:p,
//             volume:v,
//             code:String::from("SH600036"),
//             amount: p*v as f64,
//         }
//     }
// }
// fn main() {
//     let now = SystemTime::now();
//     let stock = Stock::default();
//     let elapsed = now.elapsed().unwrap().as_nanos();
//     println!("cost time :{:?} ",elapsed);

// }

4.通过这个指令进行测试显示数值

cargo test -- --show-output