No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Benchmarking (console time y timeEnd)

26/31
Recursos

Aportes 49

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Benchmark = prueba de rendimiento o comparativa en ingl茅s

La funci贸n console.time(鈥榥ombre鈥) inicia un temporizador que se puede usar para rastrear cu谩nto tiempo dura una operaci贸n. El temporizador sera identificado por el nombre dado a la consola. Ese mismo nombre se utilizara cuando se llame a console.timeEnd(鈥榥ombre鈥) para detener el temporizador y obtener el tiempo demorado durante el proceso.

console.time("Temporizador");
for (var i = 0; i < 10000; i++) {
  // Nuestro codigo entre los temporizadores puede ser cualquier cosa.
}
console.timeEnd("Temporizador");
<h1>驴Qu茅 es m谩s r谩pido?</h1>
  • Suma++

  • Suma = Suma + i

let suma = 0;
let suma2 = 0;

console.time('Tiempo bucle');
for (let i = 0; i < 1000; i++) {
    suma++;
}
console.timeEnd('Tiempo bucle')

console.time('Tiempo bucle 2');
for (let j = 0; j < 1000; j++) {
    suma2 = suma2 + j;
}
console.timeEnd('Tiempo bucle 2')```

Respuesta:

Tiempo bucle: 0.268ms
Tiempo bucle 2: 0.055ms

Benchmarking (console time y timeEnd)


Aqu铆 vamos a ver c贸mo hacer para descubrir de todas tus funciones cuando tienes un proceso largo, cu谩nto esta tardando en ejecutarse y poder detectar procesos que est谩n tard谩ndose m谩s de lo que deber铆an.

let suma = 0

console.time('bucle')

for (let i = 0; i < 1000000000; i++) {
    suma += 1
    
}
console.timeEnd('bucle')
  • console.time(*nombre*) 鈫 Nos encerrar un bloque de c贸digo y despu茅s evaluar cu谩nto tarda en ejecutarse.

Y tambi茅n puedes trabajar esto con procesos as铆ncronos.

console.time('bucle async')
console.log('Empieza el proceso asincrono')
asincrona()
    .then(() => console.timeEnd('bucle async'))

function asincrona() {
    return new Promise( resolve => {
        setTimeout( () => {
            console.log('Terimina el proceso as铆ncrono')
            resolve()
        }, 0)
    })
}

隆Que buen truco!

Bastante aplicable para revisar el tiempo que tarda en peticiones http

Trucos que no quieren que sepamos de Node.js sacados de trucoteca

Mi forma de hacerlo : P

es genial, aunque hay que tener en cuenta que va depender de la maquina donde corras el codigo

console.time('todo');
let suma = 0;

console.time('bucle1');
for (let i = 0; i < 1000000000; i++) {
    suma++;
}
console.timeEnd('bucle1');

let suma2 = 0;
console.time('bucle2');
for (let i = 0; i < 10000000000; i++) {
    suma2++;
}
console.timeEnd('bucle2');

console.time('asincrona');
console.log('inicia asincrono');
asincrona()
    .then ( () => {
        console.timeEnd('asincrona');
    })


console.timeEnd('todo');


//-------------------

function asincrona() {
    return new Promise ( (resolve) => {
        setTimeout(() => {
            console.log('Termina el proceso asincrono');
            resolve();
        }, 1000);
    })
}

Console.time es una buena herramienta para medir el tiempo de ejecuci贸n de nuestro c贸digo, pero cabe resaltar que este tiempo es relativo, la velocidad de la cpu, los procesos que pueda estar corriendo entre otros, en el Curso B谩sico de Algoritmos, m谩s especifico a la clase de C贸mo comparar algoritmos y ritmo de crecimiento
se puede adentran mas en el rendimiento de nuestro c贸digo.

/* Se puede ejecutar un proceso que pronostique cuanto debe tardarce en ejecutar algo y asi identificar donde hay fallas para corregir y hacer que todo ejecute mas rapido */


/* console.time('todo');
let suma = 0;
console.time('bucle');

for (let i = 0; i < 100000000; i++) {
    suma +=1;
}

console.log(suma);
console.timeEnd('bucle');

let suma2 = 0;
console.time('bucle2');

for (let j = 0; j < 1000000000; j++) {
    suma2 +=1;
}

console.log(suma2);
console.timeEnd('bucle2');
console.timeEnd('todo'); */

/* con las funciones asincronas funciona asi */


console.time('todo');
let suma = 0;
console.time('bucle');

for (let i = 0; i < 100000000; i++) {
    suma +=1;
}

console.log(suma);
console.timeEnd('bucle');

let suma2 = 0;
console.time('bucle2');

for (let j = 0; j < 1000000000; j++) {
    suma2 +=1;
}

console.log(suma2);

console.timeEnd('bucle2');

console.time('asincrono');
asincrona()
    .then(() => {
        console.timeEnd('asincrono');
    });

console.timeEnd('todo');



function asincrona() {
    return new Promise((resolve) => {
        setTimeout(function () {
            console.log('Termina el proceso asincrono')
            resolve();
        },5000)
    })
}

/* As铆 podemos entender cuando tarda un codigo en ejecutarce esto se conoce como benchmarking */

This is my c贸de!!

console.time('all');
let suma = 600000;

console.time('bucle');
for (let i = 0; i < suma; i++) {
   // console.log(i)
}
console.log(suma)
console.timeEnd('bucle');

console.time('bucle2');
let suma2 =suma*2;
console.log(suma2)
for (let x = 0; x < suma2; x++) {
   // console.log(x)
}
console.timeEnd('bucle2');
console.log('async');
asincrona()
    .then( () => {
        console.timeEnd('async');

    })
console.timeEnd('all');

function asincrona(){
    return new Promise( (resolve, reject) =>{
        setTimeout(() => {
            console.log('Termina el proceso asincrono');
            resolve();
        })
    })
}```

Console.time es una buena herramienta para medir el tiempo de ejecuci贸n de nuestro c贸digo, pero cabe resaltar que este tiempo es relativo

El mejor profesor de Node del mundo.

Que bueno poder saber cu谩nto le est谩s exigiendo a tu m谩quina a la hora de ejecutar un proceso. Estos datos siempre me dan ganas de saber en qu茅 parte o c贸mo puedo mejorar el c贸digo para hacerlo m谩s r谩pido.

console.time(鈥榥ombre_proceso鈥)
//tu codigo鈥

console.timeEnd(鈥榥ombre_proceso鈥)
Sirve para obtener el tiempo que tarda que en ejecutarse el codigo que esta entre las consolas time

Tambien tenemos disponible console.timeLog, para poder observar el cambio de una variable鈥 https://developer.mozilla.org/en-US/docs/Web/API/Console/timeLog

Estos peque帽os trucos hacen la diferencia a la hora de debuggear

Lo he hecho con console.time & console.timeLog

console.time(`All code`);

console.time(`process`)
let sum = 0;
for(i = 0; i < 10; i++ ){
    sum += 1;
}
console.timeLog(`process`, sum);

/* Asincrono */
console.log("Aqu铆 comienza as铆ncrono");

function startup() {
    return new Promise(
        (resolve, reject)=>{
            setTimeout(() => {
                console.log("Petici贸n 1")
                resolve();
            }, 4000);
        }
    );
}
console.time(`startup`);
startup()
    .then(res => console.timeLog(`startup`))
    .catch(err => console.timeLog(`startup`))

console.timeEnd(`All code`) 

Otro ejemplo con funciones asincronas:

function asynchronous() {
    setTimeout(() => {
        console.log('hey');
        console.timeEnd('async');
    }, 3000);
}

console.time('async');
asynchronous()
console.time('todo');
let suma = 0;

console.time('bucle')

for (let i = 0; i < 1000000000; i++) {
    suma += i;
}

console.log('Listo: ', suma);
console.timeEnd('bucle');

let suma2 = 0;


console.time('bucle2')

for (let j = 0; j < 10000000; j++) {
    suma2 += 1;
}

console.log('Listo: ', suma2);
console.timeEnd('bucle2');

console.time('asincrono')
console.log('Empieza el proceso asincrono');
asincrona()
    .then(() => {
        console.timeEnd('asincrono');
    });



console.timeEnd('todo');


function asincrona() {
    return new Promise((resolve) => {
        setTimeout(function () {
            console.log('Termina el proceso asincrono');
            resolve();
        })
    })
}

Funci贸n muy 煤til a la hora de comprar algoritmos que resuelven alg煤n problema, as铆 podemos saber cual es mejor.

Yo me casaba con python, pero Node y JS me estan convenciendo

Excelente no conocia esta funcion

Benchmarking

Uno de los trucos que nos puede servir es para saber cuanto tiempo tarda la ejecuci贸n de alguna funci贸n o proceso que se ejecuta, es un m茅todo de console y se llama time y timeEnd.

let sum = 0
console.time('cicle')
for (let i = 0; i < 1000000000; i++) {
  sum += 1
}
console.timeEnd('cicle')
/*
Output:
	cicle: 1.608s
*/

Permite saber el tiempo que tarda el ciclo en ejecutarse.

Para utilizarlo con funciones as铆ncronas, se pueden usar las Promises .

function asyncFunction() {
  return new Promise((resolve) => {
    setTimeout(function () {
      console.log('Termina el proceso asincrono')
      resolve()
    })
  })
}

console.time('asincrono')
asyncFunction().then(() => {
  console.timeEnd('asincrono')
})

/*
Output:
	Termina el proceso asincrono
	asincrono: 2.039ms
*/

Creo que con esto deber铆an explicar la asincronia de javascript, porque si le pones un setTimeout de 2 segundos al principio, va a tardar realativamente lo mismo a que si lo pones al final, solo que el tiempo final va a ser menor

Muy 煤til el console.time hace que rastrear peticiones HTTP y en general todo tipo de proceso sea mucho m谩s f谩cil. 隆Genial!

console.clear();

let suma = 0;
let suma2 = 0;

console.time('suma');
for (let index = 0; index < 10000000; index++) {
    suma += 1;
}
console.timeEnd('suma');


console.time('suma2');
for (let index = 0; index < 10000000; index++) {
    suma2 ++;
}
console.timeEnd('suma2');

A la hora de crear el otro ciclo for, no era necesario cambiar la variable 鈥渋鈥 a 鈥渏鈥, porque us贸 let para declarar la variable, es decir, la variable est谩 en un scope local. Seguro que la mayor铆a es consciente de esto, pero lo menciono por si alguien no lo hab铆a comprendido completamente.

Otro truco, usar exponente a los para los n霉meros:

1.000鈥000.000 === 1e9

let suma = 0;
console.time("bucle");
for (let i = 0; i < 1e9; i++) {
  suma += 1;
}
console.timeEnd("bucle");

Hola a todos, los invito a leer del BigO notation, creo que si enlazamos esta lecci贸n y los conceptos del bigO notation, cumpliremos lo que nos dice el profe Le贸nidas xD el saber un gran truco y aplicarlo en nuestro c贸digo.
https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/big-o-notation aqu铆 les dejo este peque帽o articulo, obviamente luego de leerlo a realizar ejercicios amigos, con eso comprendemos a fondo la complejidad de nuestro c贸digo y adem谩s el uso eficiente de recursos, Salu2! 馃槂

馃く

Entonces los console time y timeEnd nos sirven para saber o medir el rendimiento y la velocidad de ejecuci贸n de nuestro c贸digo.

no es necesario cambiar el nombre de esa variable que usa para iterar en ciclo for.

De lujo Homero

Bart Simpson

隆Hola t煤! Si quieres a帽adirle un poco m谩s de personalizaci贸n para realizar Benckmarking con node.js, te invito a echarle un vistazo al siguiente tutorial:
Usando colores en nuestras aplicaciones de NodeJS


// Benchmarking Console 

// Es importante gestionar el tiempo que utiliza cada funcion, Para mejorar el performance y los tiempos de carga.
// Console.time, inicia un tiempo x
// console.timeEnd termina el tiempo y lo muestra.
let suma = 0;

console.log('the asynco starts')
console.time('bucle');
console.time('bucle2');
console.time('Asynco');
for(let i = 0; i < 1000000; i++){
    suma += 1;
}
console.timeEnd('bucle');

let suma2 = 0;
for(let i = 0; i < 1000000; i++){
    suma2 += 1;
}
console.timeEnd('bucle2');

function asynco() {
    return new Promise( (resolve) => {
        setTimeout((function () {
            console.log('the process was finished')
            return resolve();
        }))
    })
}

asynco()
    .then(() => {
        console.timeEnd('Asynco')
    })

console.time('cualquierNombre') crea un temporizador que puede ser utilizado para calcular cu谩nto puede estar demorando un proceso. Este temporizador ser谩 identificado por 'cualquierNombre' ingresado inicialmente. Este mismo nombre ser谩 utilizado para llamar a console.timeEnd('cualquierNombre') para obtener el tiempo total.

console.time(鈥渘ombre del bloque鈥)
console.timeEnd(鈥渘ombre del bloque鈥)

Una de las preguntas que me hacia!! wow y con el console.log!!!

Buena clase!

metricas importantes para validar el rendimiento de los procesos!

Esto tiene que ver con m茅tricas?

Genial

Esto es s煤per 煤til

console.time

This is my code!

Excelente!

Genial.
Que trucaso 馃槈