Bagaimana cara mendapatkan microtime di Node.js?

Bagaimana saya bisa mendapatkan cap waktu paling akurat di Node.js?

ps Versi Node.js saya adalah 0.8.X dan ekstensi node-microtime tidak berfungsi untuk saya (macet saat menginstal)

new Date().getTime()? Ini memberi Anda stempel waktu dalam milidetik, yang paling akurat yang akan diberikan JS kepada Anda.

Pembaruan: Seperti yang dinyatakan oleh vaughan, process.hrtime()tersedia dalam Node.js - resolusinya nanodetik dan karena itu jauh lebih tinggi, juga ini tidak berarti itu harus lebih tepat.

PS .: Agar lebih jelas, process.hrtime()mengembalikan Anda tupel yang Arrayberisi waktu nyata resolusi tinggi saat ini dalam [detik, nanodetik]

Di Node.js, "waktu resolusi tinggi" tersedia melalui process.hrtime. Ia mengembalikan array dengan elemen pertama waktu dalam detik, dan elemen kedua nanodetik tersisa.

Untuk mendapatkan waktu saat ini dalam mikrodetik, lakukan hal berikut:

var hrTime = process.hrtime()
console.log(hrTime[0] * 1000000 + hrTime[1] / 1000)

(Terima kasih kepada itaifrenkel untuk menunjukkan kesalahan dalam konversi di atas.)

Di browser modern, waktu dengan presisi mikrodetik tersedia sebagai performance.now. Lihat https://developer.mozilla.org/en-US/docs/Web/API/Performance/now untuk dokumentasi.

Saya telah membuat implementasi fungsi ini untuk Node.js, berdasarkan process.hrtime, yang relatif sulit digunakan jika Anda hanya ingin menghitung perbedaan waktu antara dua titik dalam sebuah program. Lihat http://npmjs.org/package/performance-now . Sesuai spesifikasi, fungsi ini melaporkan waktu dalam milidetik, tetapi ini mengambang dengan presisi sub-milidetik.

Dalam Versi 2.0 modul ini, milidetik yang dilaporkan relatif terhadap saat proses node dimulai ( Date.now() - (process.uptime() * 1000)). Anda perlu menambahkannya ke hasil jika Anda menginginkan stempel waktu yang mirip dengan Date.now(). Perhatikan juga bahwa Anda harus menghitung ulang Date.now() - (process.uptime() * 1000). Kedua Date.nowdan process.uptimesangat tidak bisa diandalkan untuk pengukuran yang tepat.

Untuk mengetahui waktu saat ini dalam mikrodetik, Anda dapat menggunakan sesuatu seperti ini.

var loadTimeInMS = Date.now()
var performanceNow = require("performance-now")
console.log((loadTimeInMS + performanceNow()) * 1000)

Lihat juga: Apakah JavaScript menyediakan pengatur waktu resolusi tinggi?

now('milli'); //  120335360.999686
now('micro') ; // 120335360966.583
now('nano') ; //  120335360904333

Diketahui bahwa now:

const now = (unit) => {

  const hrTime = process.hrtime();

  switch (unit) {

    case 'milli':
      return hrTime[0] * 1000 + hrTime[1] / 1000000;

    case 'micro':
      return hrTime[0] * 1000000 + hrTime[1] / 1000;

    case 'nano':
      return hrTime[0] * 1000000000 + hrTime[1];

    default:
      return now('nano');
  }

};

The BigInttipe data didukung sejak Node.js 10.7.0. ( lihat juga pengumuman posting blog ). Untuk versi Node.js yang didukung ini, process.hrtime([time])metode tersebut sekarang dianggap sebagai 'warisan', diganti dengan process.hrtime.bigint()metode tersebut.

The bigintversi process.hrtime()metode mengembalikan resolusi tinggi real time saat ini dalam bigint.

const start = process.hrtime.bigint();
// 191051479007711n

setTimeout(() => {
  const end = process.hrtime.bigint();
  // 191052633396993n

  console.log(`Benchmark took ${end - start} nanoseconds`);
  // Benchmark took 1154389282 nanoseconds
}, 1000);

tl; dr

• Node.js 10.7.0+ - Gunakan process.hrtime.bigint()
• Jika tidak - Gunakan process.hrtime()

Ada juga https://github.com/wadey/node-microtime :

> var microtime = require('microtime')
> microtime.now()
1297448895297028

Node.js nanotimer

Saya menulis pustaka / objek pembungkus untuk node.js di atas process.hrtimepemanggilan fungsi. Ini memiliki fungsi yang berguna, seperti tugas sinkronisasi waktu dan asinkron, ditentukan dalam hitungan detik, milidetik, mikro, atau bahkan nano, dan mengikuti sintaksis timer javascript bawaan agar lebih familiar.

Objek pengatur waktu juga terpisah, sehingga Anda dapat memiliki sebanyak yang Anda inginkan, masing-masing dengan proses setTimeoutatau setIntervalprosesnya sendiri .

Ini disebut nanotimer . Saksikan berikut ini!

Untuk bekerja dengan lebih presisi dari Date.now(), tetapi dengan milidetik dalam presisi float:

function getTimeMSFloat() {
    var hrtime = process.hrtime();
    return ( hrtime[0] * 1000000 + hrtime[1] / 1000 ) / 1000;
}

Dapatkan hrtimesebagai nomor tunggal dalam satu baris:

const begin = process.hrtime();
// ... Do the thing you want to measure
const nanoSeconds = process.hrtime(begin).reduce((sec, nano) => sec * 1e9 + nano)

Array.reduce, jika diberi satu argumen, akan menggunakan elemen pertama larik sebagai nilai awal accumulator. Seseorang dapat menggunakan 0sebagai nilai awal dan ini akan berhasil juga, tetapi mengapa melakukan ekstra * 0.

ada paket npm yang terikat ke fungsi gettimeofday () sistem, yang mengembalikan stempel waktu presisi mikrodetik di Linux. Telusuri npm gettimeofday. Menelepon C lebih cepat dariprocess.hrtime()

Tulis ulang untuk membantu pemahaman cepat:

const hrtime = process.hrtime();     // [0] is seconds, [1] is nanoseconds

let nanoSeconds = (hrtime[0] * 1e9) + hrtime[1];    // 1 second is 1e9 nano seconds
console.log('nanoSeconds:  ' + nanoSeconds);
//nanoSeconds:  97760957504895

let microSeconds = parseInt(((hrtime[0] * 1e6) + (hrtime[1]) * 1e-3));
console.log('microSeconds: ' + microSeconds);
//microSeconds: 97760957504

let milliSeconds = parseInt(((hrtime[0] * 1e3) + (hrtime[1]) * 1e-6));
console.log('milliSeconds: ' + milliSeconds);
//milliSeconds: 97760957

Sumber: https://nodejs.org/api/process.html#process_process_hrtime_time

Saya tidak begitu bangga dengan solusi ini tetapi Anda dapat memiliki stempel waktu dalam mikrodetik atau nanodetik dengan cara ini:

const microsecond = () => Number(Date.now() + String(process.hrtime()[1]).slice(3,6))
const nanosecond = () => Number(Date.now() + String(process.hrtime()[1]).slice(3))

// usage
microsecond() // return 1586878008997591
nanosecond()  // return 1586878009000645600

// Benchmark with 100 000 iterations
// Date.now: 7.758ms
// microsecond: 33.382ms
// nanosecond: 31.252ms

Tahu bahwa:

• Solusi ini bekerja secara eksklusif dengan node.js ,
• Ini sekitar 3 hingga 10 kali lebih lambat dariDate.now()
• Anehnya, tampaknya sangat akurat, hrTime tampaknya mengikuti persis cap waktu js.
• Anda dapat mengganti Date.now()dengan Number(new Date())untuk mendapatkan stempel waktu dalam milidetik

Edit:

Di sini solusi untuk memiliki mikrodetik dengan koma, namun, versi angka akan dibulatkan secara native oleh javascript. Jadi jika Anda menginginkan format yang sama setiap saat, Anda harus menggunakan versi String-nya.

const microsecondWithCommaString = () => (Date.now() + '.' + String(process.hrtime()[1]).slice(3,7))
const microsecondWithComma = () => Number(Date.now() + '.' + String(process.hrtime()[1]).slice(3,7))

microsecondWithCommaString() // return "1586883629984.8997"
microsecondWithComma() // return 1586883629985.966

process.hrtime () tidak memberikan ts saat ini.

Ini seharusnya berhasil.

 const loadNs       = process.hrtime(),
        loadMs       = new Date().getTime(),
        diffNs       = process.hrtime(loadNs),
        microSeconds = (loadMs * 1e6) + (diffNs[0] * 1e9) + diffNs[1]

  console.log(microSeconds / 1e3)

lebih baik?

Number(process.hrtime().join(''))