Benchmarking (console time y timeEnd)

Benchmark = prueba de rendimiento o comparativa en inglés

La función console.time(‘nombre’) 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(‘nombre’) 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");

• 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(‘nombre_proceso’)
//tu codigo…

console.timeEnd(‘nombre_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 “i” a “j”, 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(“nombre del bloque”)
console.timeEnd(“nombre 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 😉