¿Cómo puedo obtener la hora actual en milisegundos?

84

¿Cómo puedo obtener la hora actual en milisegundos como puedo en Java?

System.currentTimeMillis()

rust

— アレックス
fuente

114

Desde Rust 1.8, no es necesario utilizar una caja. En su lugar, puede usar SystemTimey UNIX_EPOCH:

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

fn main() {
    let start = SystemTime::now();
    let since_the_epoch = start
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards");
    println!("{:?}", since_the_epoch);
}

Si necesita exactamente milisegundos, puede convertir el Duration .

Óxido 1.33

let in_ms = since_the_epoch.as_millis();

Óxido 1,27

let in_ms = since_the_epoch.as_secs() as u128 * 1000 + 
            since_the_epoch.subsec_millis() as u128;

Óxido 1.8

let in_ms = since_the_epoch.as_secs() * 1000 +
            since_the_epoch.subsec_nanos() as u64 / 1_000_000;

— Pastor
fuente

¿Por qué systemtime en lugar de instantáneo?

— Andy Hayden

2

@AndyHayden es posible que desee volver a leer la documentación paraInstant : No hay ningún método para obtener "la cantidad de segundos" de un instante. En cambio, solo permite medir la duración entre dos instantes (o comparar dos instantes).

— Shepmaster

36

Si solo desea hacer tiempos simples con milisegundos, puede usar std::time::Instantasí:

use std::time::Instant;

fn main() {
    let start = Instant::now();

    // do stuff

    let elapsed = start.elapsed();

    // Debug format
    println!("Debug: {:?}", elapsed); 

    // Format as milliseconds rounded down
    // Since Rust 1.33:
    println!("Millis: {} ms", elapsed.as_millis());

    // Before Rust 1.33:
    println!("Millis: {} ms",
             (elapsed.as_secs() * 1_000) + (elapsed.subsec_nanos() / 1_000_000) as u64);
}

Salida:

Debug: 10.93993ms
Millis: 10 ms
Millis: 10 ms

— Robinst
fuente

Véase también el tema RFC 1545 para añadir as_millisa Duration.

— robinst

Es posible que desee consultar doc.rust-lang.org/1.8.0/std/time/… si desea duración.

— vinyll

Causado u128 is not supported.

— Pedro Paulo Amorim

16

Puedes usar la caja de tiempo :

extern crate time;

fn main() {
    println!("{}", time::now());
}

Devuelve un valor Tmque puede obtener la precisión que desee.

— Steve Klabnik
fuente

2

Las precise_time_...funciones de esa caja también son relevantes, si solo se desea medir tiempos relativos.

— huon

¿Cómo obtengo milisegundos?

— アレックス

1

Tienes que usar time::now_utc()o time::get_time()ya que System.currentTimeMillis () de Java devuelve la hora UTC. Escribiríalet timespec = time::get_time(); let mills = timespec.sec + timespec.nsec as i64 / 1000 / 1000;

— Nándor Krácser

1

hora :: precisa_hora_ns () y hora :: precisa_hora_s ()

— tyoc213

5

Esta caja ahora está en desuso. En su lugar, use una chronocaja.

— Ondrej Slinták

13

Encontré una solución clara con chrono en coinnect :

use chrono::prelude::*;

pub fn get_unix_timestamp_ms() -> i64 {
    let now = Utc::now();
    now.timestamp_millis()
}

pub fn get_unix_timestamp_us() -> i64 {
    let now = Utc::now();
    now.timestamp_nanos()
}

— DenisKolodin
fuente

6

extern crate time;

fn timestamp() -> f64 {
    let timespec = time::get_time();
    // 1459440009.113178
    let mills: f64 = timespec.sec as f64 + (timespec.nsec as f64 / 1000.0 / 1000.0 / 1000.0);
    mills
}

fn main() {
    let ts = timestamp();
    println!("Time Stamp: {:?}", ts);
}

Patio de recreo de óxido

— Zijun Luo
fuente

Esto no devuelve el mismo valor que System.currentTimeMillis ()

— josehzz

Es cierto que devuelve el tiempo en segundos. Para obtener los milis, debe multiplicar sec por 1000 y dividir nsec por 1000 menos (como lo hacen otras respuestas correctamente).

— contradecida el

@contradictioned play.rust-lang.org/…

— Zijun Luo

4

System.currentTimeMillis() en Java devuelve la diferencia en milisegundos entre la hora actual y la medianoche del 1 de enero de 1970.

En Rust tenemos time::get_time()que devuelve un Timespeccon la hora actual en segundos y el desplazamiento en nanosegundos desde la medianoche del 1 de enero de 1970.

Ejemplo (usando Rust 1.13):

extern crate time; //Time library

fn main() {
    //Get current time
    let current_time = time::get_time();

    //Print results
    println!("Time in seconds {}\nOffset in nanoseconds {}",
             current_time.sec, 
             current_time.nsec);

    //Calculate milliseconds
    let milliseconds = (current_time.sec as i64 * 1000) + 
                       (current_time.nsec as i64 / 1000 / 1000);

    println!("System.currentTimeMillis(): {}", milliseconds);
}

Referencia: caja de tiempo , System.currentTimeMillis ()

— josehzz
fuente

El enlace a la caja no es válido.

— Ixx