Am nevoie pentru a obține executarea dată în milisecunde.
inițial am pus această întrebare în 2008. La răspunsul acceptat apoi a fost de a utiliza new Date().getTime() cu toate Acestea, suntem cu toții de acord acum că utilizarea standard de performanță.acum() API este mai adecvate. Sunt, prin urmare, schimbarea acceptat să răspundă la asta.
var t0 = performance.now();
doSomething(); // <---- The function you're measuring time for
var t1 = performance.now();
console.log("Call to doSomething took " + (t1 - t0) + " milliseconds.");
NodeJs
: este necesar pentru a import "performanță" clasă
console.time('someFunction');
someFunction(); // Whatever is timed goes between the two "console.time"
console.timeEnd('someFunction');
Notă:
șirul fiind treacă la timp () " și " timeEnd()` metode trebuie să se potrivească
(pentru timer pentru a termina cum era de așteptat).
consola.time()
documentatii:
folosi new Date().getTime()
getTime() metoda returnează numărul de milisecunde de la miezul nopții de 1 ianuarie 1970.
ex.
var start = new Date().getTime();
for (i = 0; i < 50000; ++i) {
// do something
}
var end = new Date().getTime();
var time = end - start;
alert('Execution time: ' + time);
Folosi performanță.acum()
:
<script>
var a = performance.now();
alert('do something...');
var b = performance.now();
alert('It took ' + (b - a) + ' ms.');
</script>
Acesta funcționează pe:
ADICĂ 10 ++
FireFox 15 ++
Chrome 24 ++
Safari 8 ++
Opera 15 ++
Android 4.4 ++
`consola.timpul poate fi viabil pentru tine, dar's non-standard §ă;:
Această caracteristică este non-standard și nu este pe standarde. Nu-l folosi pe site-uri de producție cu care se confruntă Web: acesta nu va funcționa pentru fiecare utilizator. Acolo poate fi, de asemenea, mari incompatibilități între implementări și comportamentul se poate schimba în viitor.
În afară de browser-ul de sprijin, de performanță.acum se pare că au potențial pentru a oferi mai multe timpilor exacte pentru ca pare a fi goale-oase de versiunea de consola.timp`.
<declama> de Asemenea, DON'T folosi VREODATĂ "Data" pentru nimic pentru ca's afectate de schimbări în "sistem de timp". Ceea ce înseamnă că va obține rezultate nevalide —ca "negativ timing"— atunci când utilizatorul nu't au un sistem precis de timp:
Pe Oct 2014, sistemul meu ceas a luat-o razna și că ce.... Am deschis Gmail și am văzut toate de ziua mea's e-mailuri "trimis de 0 de minute**". Și am'd gândit Gmail ar trebui să fie construit de clasă mondială ingineri de la Google.......
(Setați ceasul de sistem la un an în urmă și du-te la Gmail, astfel încât să putem avea un râs bun. Poate într-o zi vom avea o Sala de Rușine pentru JS "Data".)
Google foaie de Calcul's now()
funcție, de asemenea, suferă de această problemă.
Singura dată când te - 'll fi folosind "Data" este atunci când doriți să arate utilizatorului lui sistem de ceas de timp. Nu atunci când doriți să obțineți *la data* sau pentru a măsura ceva.
Dacă aveți nevoie pentru a obține funcția de execuție timp de dezvoltare locală mașină, puteți folosi browser-ul dvs.'s profilare instrumente, sau consola de comenzi, cum ar fi de consola.time()
și consola.timeEnd()
.
Toate browserele moderne au JavaScript profileri built-in. Aceste profileri ar trebui să dea măsurarea mai precisă deoarece nu trebuie să modificați codul existent, care ar putea afecta funcția's timp de executie.
La profil JavaScript:
În mod alternativ, pe dezvoltarea de mașini, puteți adăuga instrumente pentru codul cu consola.time()
și consola.timeEnd()
. Aceste funcții, susținută în Firefox11+, Chrome2+ și IE11+, raport privind cronometre care începe/opri prin consola.time()
. dată()
are o definite de utilizator nume timer ca un argument, și timeEnd()
apoi a rapoartelor privind executarea timp de când cronometrul a început:
function a() {
console.time("mytimer");
... do stuff ...
var dur = console.timeEnd("myTimer"); // NOTE: dur only works in FF
}
Rețineți că numai Firefox returnează intervalul de timp în anii timeEnd()
apel. Alte browsere pur și simplu raportează rezultatul la consola pentru dezvoltatori: valoarea de returnare a timeEnd()
este nedefinit.
Dacă doriți să obțineți funcția de execuție de timp în sălbăticie, va trebui să-instrument de cod. Aveți câteva opțiuni. Puteți salva pur și simplu începutul și sfârșitul ori prin interogarea new Date().getTime()
:
function a() {
var start = new Date().getTime();
... do stuff ...
var end = new Date().getTime();
var dur = end - start;
}
Cu toate acestea, "Data" obiect are doar o milisecundă de rezoluție și vor fi afectate de orice sistem de OPERARE's ceasul de sistem modificări. În browserele moderne, acolo's o opțiune mai bună.
Cea mai bună opțiune este de a utiliza de Înaltă Rezoluție Time, aka fereastră.de performanță.acum()
. now()
este mai bine decât tradiționale de Întâlnire.getTime()` în două moduri importante:
now()
este o dublă cu submillisecond rezoluție care reprezintă numărul de milisecunde de la începutul paginii's de navigare. Returnează numărul de microsecunde în fracționată (de exemplu, o valoare de 1000.123 este de 1 secundă și 123 de microsecunde).
now()
este monoton crescătoare. Acest lucru este important deoarece Data.getTime()
poate eventual salt înainte sau chiar înapoi la apelurile ulterioare. În special, dacă sistemul de OPERARE's timp sistemul este actualizat (de exemplu, sincronizare ceas atomic), Data.getTime()
este, de asemenea, actualizate. now()
este garantat de a fi mereu monoton crescătoare, deci nu este afectat de OS's sistem de timp-aceasta va fi întotdeauna perete-ceas de timp (presupunând că ceas de perete nu este atomic...).
now()
poate fi folosit în aproape fiecare loc pe care new Date().getTime()
, + Data nou
șit Data.acum()
sunt. Excepția este că Data
si now()
ori nu't se amestecă, ca și "Data" se bazează pe unix epoch (numărul de milisecunde din 1970), în timp ce now()
este numărul de milisecunde din pagina dvs. de navigare început (deci, va fi mult mai mică decât "Data").
Aici's un exemplu de cum să folosiți now()
:
function a() {
var start = window.performance.now();
... do stuff ...
var end = window.performance.now();
var dur = end - start;
}
now()
este susținută în Chrome stabil, Firefox 15+, și IE10. Există, de asemenea, mai multe polyfills disponibil.
O altă opțiune pentru măsurarea timpului de execuție în sălbăticie este UserTiming. UserTiming se comportă în mod similar la consola.time () " și " consola.timeEnd()
, dar se utilizeaza la fel de Înaltă Rezoluție Timestamp că now()
foloseste (astfel încât să obțineți un sub-milisecundă monoton crescătoare ceas), și salvează timp și durate de la PerformanceTimeline.
UserTiming a conceptelor de mărci (timestamp) și măsuri (durate). Puteți defini cât mai multe de ori, după cum doriți, și-au're expuse pe PerformanceTimeline.
Pentru a salva un marcaj de timp, ai spune mark(startMarkName). Pentru a obține durata de la primul semn, pur și simplu suna măsură(measurename, startMarkname)
. Durata este apoi salvat în PerformanceTimeline alături de mărci.
function a() {
window.performance.mark("start");
... do stuff ...
window.performance.measure("myfunctionduration", "start");
}
// duration is window.performance.getEntriesByName("myfunctionduration", "measure")[0];
UserTiming este disponibil în IE10+ și Chrome25+. Există, de asemenea, un polyfill disponibil (pe care l-am scris).
Pentru a obține valori exacte, ar trebui să utilizați interfață de Performanță. L's susținută în versiunile moderne ale Firefox, Chrome, Opera și IE. Aici's un exemplu de cum poate fi folosit:
var performance = window.performance;
var t0 = performance.now();
doWork();
var t1 = performance.now();
console.log("Call to doWork took " + (t1 - t0) + " milliseconds.")
Data.getTime () " sau " consola.time()
nu sunt bune pentru măsurarea precisă a timpului de executie. Le puteți folosi dacă rapid estimare este OK pentru tine. De estimare adică puteți obține 15-60 ms trecerea de la timp real.
Verificați acest genial post pe măsurarea timpului de execuție în JavaScript. Autorul oferă, de asemenea, o serie de link-uri despre precizie de JavaScript timp, în valoare de lectură.
var StopWatch = function (performance) {
this.startTime = 0;
this.stopTime = 0;
this.running = false;
this.performance = performance === false ? false : !!window.performance;
};
StopWatch.prototype.currentTime = function () {
return this.performance ? window.performance.now() : new Date().getTime();
};
StopWatch.prototype.start = function () {
this.startTime = this.currentTime();
this.running = true;
};
StopWatch.prototype.stop = function () {
this.stopTime = this.currentTime();
this.running = false;
};
StopWatch.prototype.getElapsedMilliseconds = function () {
if (this.running) {
this.stopTime = this.currentTime();
}
return this.stopTime - this.startTime;
};
StopWatch.prototype.getElapsedSeconds = function () {
return this.getElapsedMilliseconds() / 1000;
};
StopWatch.prototype.printElapsed = function (name) {
var currentName = name || 'Elapsed:';
console.log(currentName, '[' + this.getElapsedMilliseconds() + 'ms]', '[' + this.getElapsedSeconds() + 's]');
};
Referință
var stopwatch = new StopWatch();
stopwatch.start();
for (var index = 0; index < 100; index++) {
stopwatch.printElapsed('Instance[' + index + ']');
}
stopwatch.stop();
stopwatch.printElapsed();
Ieșire
Instance[0] [0ms] [0s]
Instance[1] [2.999999967869371ms] [0.002999999967869371s]
Instance[2] [2.999999967869371ms] [0.002999999967869371s]
/* ... */
Instance[99] [10.999999998603016ms] [0.010999999998603016s]
Elapsed: [10.999999998603016ms] [0.010999999998603016s]
de performanță.acum() este opțional - doar trece false în Cronometru funcție constructor.
puteți folosi add operator, de asemenea, aici
var start = +new Date();
callYourFunctionHere();
var end = +new Date();
var time = end - start;
console.log('total execution time = '+ time + 'ms');
Pentru a extinde vsync's cod continuare să aibă capacitatea de a reveni timeEnd ca o valoare în NodeJS utilizați această mică bucată de cod.
console.timeEndValue = function(label) { // Add console.timeEndValue, to add a return value
var time = this._times[label];
if (!time) {
throw new Error('No such label: ' + label);
}
var duration = Date.now() - time;
return duration;
};
Acum folositi codul astfel:
console.time('someFunction timer');
someFunction();
var executionTime = console.timeEndValue('someFunction timer');
console.log("The execution time is " + executionTime);
Acest lucru vă oferă mai multe posibilități. Puteți stoca timp de executie pentru a fi utilizate pentru mai multe scopuri, cum ar fi folosind-o în ecuații, sau stocate într-o bază de date, trimise la un client la distanță prin websockets, servit pe o pagină web, etc.
Este posibil să se utilizeze o singură variabilă:
var timer = -performance.now();
// Do something
timer += performance.now();
console.log("Time: " + (timer/1000).toFixed(5) + " sec.")
timer/1000
- pentru a converti milisecunde la câteva secunde
.toFixed(5)
- să tăiați cifre suplimentare
Din consola.timp " și " performanță.acum sunt't sprijinit în unele browsere majore (de exemplu, IE10), am creat un slim de utilitate, care utilizeaza cele mai bune metode disponibile. Cu toate acestea, ea nu are eroare de manipulare pentru fals utilizări (de asteptare End()
pe o inițializat timer).
Folositi-l și-l îmbunătățească, după cum doriți.
Performance: {
Timer: {},
Start: function (name) {
if (console && console.time) {
console.time(name);
} else if (window.performance.now) {
this.Timer[name] = window.performance.now();
} else {
this.Timer[name] = new Date().getTime();
}
},
End: function (name) {
if (console && console.time) {
console.timeEnd(name);
} else {
var result;
if (window.performance.now) {
result = window.performance.now() - this.Timer[name];
} else {
result = new Date().getTime() - this.Timer[name];
}
console.log(name + ": " + result);
}
}
}
Aici's un decorator pentru funcțiile de temporizare
let timed = (f) => (...args)=>{
let start = performance.now();
let ret = f(...args);
console.log(`function ${f.name} took ${(performance.now()-start).toFixed(3)}ms`)
return ret;
}
Utilizare:
let test = ()=>{/*does something*/}
test = timed(test) // turns the function into a timed function in one line
test() // run your code as normal, logs 'function test took 1001.900ms'
Daca're folosind asincron funcții puteți face "cronometrat" asincron și se adaugă o așteaptă
înainte de a f(...args), și că ar trebui să lucreze pentru ele. Devine mai complicat daca vrei un decorator să se ocupe atât de sincronizare și asincron funcții.
Multumesc, Achim Koellner, se va extinde raspunsul tau un pic:
var t0 = process.hrtime();
//Start of code to measure
//End of code
var timeInMilliseconds = process.hrtime(t0)[1]/1000000; // dividing by 1000000 gives milliseconds from nanoseconds
Vă rugăm să rețineți, că nu ar trebui't face nimic în afară de ceea ce doriți să măsurați (de exemplu, consolă.log
va, de asemenea, să ia timp pentru a executa și va afecta testele de performanță).
Rețineți că, în scopul de a măsura asincron funcții de execuție de timp, ar trebui să introduceți var timeInMilliseconds = proces.hrtime(t0)[1]/1000000;
în interiorul apel invers. De exemplu,
var t0 = process.hrtime();
someAsyncFunction(function(err, results) {
var timeInMilliseconds = process.hrtime(t0)[1]/1000000;
});
Acum câteva luni mi-am pus împreună mea de rutină, care ori o funcție de utilizarea Dată.now () - chiar dacă în momentul în care a acceptat metodă părea să fie performanta.acum() -- pentru că performanța obiect nu este încă disponibil (built-in) în grajd Node.js de presă.
Azi am făcut niște cercetări și am găsit o altă metodă de sincronizare. De când am găsit, de asemenea, cum să folosească acest lucru în Node.js codul, am crezut că am să-l împărtășească aici.
Următoarele este combinat din exemplele date de w3c și Node.js:
function functionTimer() {
performance.mark('start')
functionToBeTimed()
performance.mark('end')
performance.measure('Start to End', 'start', 'end')
const measure = performance.getEntriesByName('Start to End')[0]
console.log(measure.duration)
}
NOTĂ:
Dacă intenționați să utilizați "performanță" obiect într-un Node.js app, trebuie să includă următoarele nevoie de:
const { performanță } = necesită('perf_hooks')
Dacă doriți pentru a măsura timpul între mai multe lucruri care nu sunt't imbricate ai putea folosi asta:
function timer(lap){
if(lap) console.log(`${lap} in: ${(performance.now()-timer.prev).toFixed(3)}ms`);
timer.prev = performance.now();
}
Similar cu consola.time(), dar mai ușor de utilizare, dacă nu't nevoie pentru a ține evidența anterior cronometre.
Dacă vă place culoarea albastră din consola.time(), puteți utiliza această linie, în loc
console.log(`${lap} in: %c${(performance.now()-timer.prev).toFixed(3)}ms`, 'color:blue');
// Usage:
timer() // set the start
// do something
timer('built') // logs 'built in: 591.815ms'
// do something
timer('copied') // logs 'copied in: 0.065ms'
// do something
timer('compared') // logs 'compared in: 36.41ms'
export default class Singleton {
static myInstance: Singleton = null;
_timers: any = {};
/**
* @returns {Singleton}
*/
static getInstance() {
if (Singleton.myInstance == null) {
Singleton.myInstance = new Singleton();
}
return this.myInstance;
}
initTime(label: string) {
this._timers[label] = Date.now();
return this._timers[label];
}
endTime(label: string) {
const endTime = Date.now();
if (this._timers[label]) {
const delta = endTime - this._timers[label];
const finalTime = `${label}: ${delta}ms`;
delete this._timers[label];
return finalTime;
} else {
return null;
}
}
}
InitTime legate de "string".
revenirea lui Singleton.getInstance().initTime(eticheta); // Returnează data init`
revenirea lui Singleton.getInstance().endTime(eticheta); // Întoarce timpul total între init și sfârșitul`
În cazul meu, am perfer să folosească @ gramatica suger și compila cu babel. Problema acestei metode este faptul că funcția trebuie să fie în interiorul obiectului.
Mostră de Cod JS
function timer() {
return (target, propertyKey, descriptor) => {
const start = Date.now();
let oldFunc = descriptor.value;
descriptor.value = async function (){
var result = await oldFunc.apply(this, arguments);
console.log(Date.now() - start);
return result;
}
}
}
// Util function
function delay(timeout) {
return new Promise((resolve) => setTimeout(() => {
resolve();
}, timeout));
}
class Test {
@timer()
async test(timout) {
await delay(timout)
console.log("delay 1");
await delay(timout)
console.log("delay 2");
}
}
const t = new Test();
t.test(1000)
t.test(100)
.babelrc (pentru babel 6)
{
"plugins": [
"transform-decorators-legacy"
]
}
Funcționează cu server și client (Nod sau DOM), folosește "Performanță" API. Bun atunci când aveți mai multe cicluri mici de exemplu, într-o funcție numită de 1000 de ori că procesele de 1000 de obiecte de date, dar vrei să vezi cum fiecare operațiune în această funcție adaugă la total.
Deci, acest lucru se folosește un modul global (singleton) timer. Fel ca o clasa singleton model, doar un pic mai simplu de utilizat, dar ai nevoie pentru a pune acest lucru într-o separat, de exemplu, `stopwatch.js dosarul lui.
`javascript const perf = typeof performanta !== "nedefinit" ? performanță : necesită('perf_hooks').de performanță; const CIFRE = 2;
să _timers = {};
const _log = (eticheta, delta?) => {
dacă (_timers[etichetă]) {
console.log(${eticheta}:
+ (delta ? ${delta.toFixed(CIFRE)} ultima ms,
: '') +
${_timers[etichetă].total.toFixed(CIFRE)} ms total, ${_timers[etichetă].cicluri} cicluri
);
}
};
export const Cronometru = { începe(eticheta) { const acum = perf.acum(); dacă (_timers[etichetă]) { dacă (!_timers[etichetă].început) { _timers[etichetă].a început = acum; } } else { _timers[etichetă] = { început: acum, total: 0, cicluri: 0 }; } }, /* Se întoarce total scurs de milisecunde, sau null în cazul în care cronometrul nu't există. / stop(eticheta, log = false) { const acum = perf.acum(); dacă (_timers[etichetă]) { să delta; dacă(_timers[etichetă].început) { delta = acum - _timers[etichetă].a început; _timers[etichetă].inceput = null; _timers[etichetă].total += delta; _timers[etichetă].cicluri++; } jurnal && _log(eticheta, delta); reveni _timers[etichetă].total; } else { return null; } }, /* Busteni timp total / jurnal: _log, delete(eticheta) { șterge _timers[etichetă]; } }; ``