Console

Console

Con console podemos imprimir todo tipo de valores por
nuestra terminal.

• console.log: recibe cualquier tipo y lo muestra en el consola.
• console.info: es equivalente a log pero es usado para informar.
• console.error: es equivalente a log pero es usado para errores.
• console.warn: es equivalente a log pero es usado para warning.
• console.table: muestra una tabla a partir de un objeto.
• console.count: inicia un contador autoincremental.
• console.countReset: reinicia el contador a 0.
• console.time: inicia un cronometro en ms.
• console.timeEnd: Finaliza el cronometro.
• console.group: permite agrupar errores mediante identación.
• console.groupEnd: finaliza la agrupación.
• console.clear: Limpia la consola.

<code>
// console.log()
    //imprime algo en consola
        console.log("Hola!");

// console.info()
    // es un alias de console.log
    console.log("Hola! (pero con .info)...");

// console.warn()
    // imprime una advertencia en consola;
        console.warn("Este sitio utiliza cookies" + " Este es un console.warn");

// console.error()
    //imprime un error en consola
        const code = 5;
        console.error("Hubo otro error", code);
        console.error(new Error ("Así también se declara un error"));

// console.table()
    // Tabula un grupo de datos 
        const usuario = [
            {
                nombre: "Luis",
                apellido: "Lora",
                edad: 22
            },
            {
                nombre: "Agustín",
                apellido: "Morán",
                edad: 19
            }
        ]
        console.table(usuario);

// console.group() & console.groupEnd()
    // Agrupa una cantidad de datos en consola
        const dias = ["Lunes", "Martes", "Miércoles", "Jueves",
            "Viernes", "Sábado", "Domingo"];
            
        console.group("diasSemana")
        for (let i = 0; i < dias.length; i++) {
        console.log(dias[i]);
        };
        console.groupEnd("diasSemana")

// console.clear()
    // Límpia la consola
        function limpiarConsola () {
            setTimeout(() => {
                console.clear("Limpiando cada 5 segs");
            }, 10000)
        }
        limpiarConsola();

// console.count() & console.countReset()
    // Cuenta la cantidad de veces que se ejecuta algo
        console.count("Veces");
        console.count("Veces");
        console.countReset("Veces");
        console.count("Veces");
        console.count("Veces");

// console.time() & console.timeEnd()
    // determina el tiempo que demora un proceso en ocurrir
        console.time("100-elementos")
        for (let i = 0; i < 100; i++){
        };
        console.timeEnd("100-elementos")

Yo en lo personal uso un console.clear() al inicio de todos mis archivos mientras uso el nodemon, ya que de esta forma cada que guardo un cambio solo me muestra la información sobre ese ultimo cambio

Nice el console.table es súper útil para quienes trabajan con JSON’s (osea casi todos)

Console

Node.js v14.9.0 Documentation

• Mensaje

  console.log('Mensaje')
  console.info('Simplemente Mensaje')
  

• Error

  console.error('Error!!')
  

• Alerta

  console.warn('Alerta!')
  

• Tabla

  let Tabla = [{a: 1, b: 'A'},{a: 2,b: 'B'}]
  console.table(Tabla)
  

• Grupo de logs

  console.group('Conversación')
      console.log('Hola');
      console.log('bla bla bla');
      console.log('Ok Adios');
  console.groupEnd('Fin de la Conversación')
  

• Contador

  console.count('Veces') // Veces: 1
  console.count('Veces') // Veces: 2
  console.count('Veces') // Veces: 3
  console.count('Veces') // Veces: 4
  console.count('Veces') // Veces: 5
  

• Temporizador

  console.time('**Inicio**')
  for(let i = 0; i < 50; i++){
  		// Contador
      console.count('Ronda: ')
  }
  console.timeEnd('**Inicio**') // Inicio: 2.381ms
  

console.table()

Esta bueno para revisar el retorno de un API.

Todas estas funcione son de js , no de node propiamente, asi que tambien lo podemos utilizar en nuestro froint

Console

Nos permite ver algo, o sea, lo que sea que pongamos ahí.

console.log('info')

Es parecido a log, pero solo se usa para informa de alfo.

console.info('algo info')

Es parecido algo log normal, solo que algunas consolas lo pintan de rojo para indicar que un error paso

console.error('algo error')

Es parecido algo log normal, solo que algunas consolas lo pintan de rojo para indicar que un warning paso

console.warn('algo warn')

Nos muestra nuestra información en forma de tabla a partir de algún objeto que le mandemos.

let elTable = [
    {
        a: 1,
        b: 'Z'
    },
    {
        a: 3,
        b: 'Otra'
    },
    {
        a: 5,
        b: 'Otra más'
    },
    {
        a: 1,
        b: 'A'
    },
]

console.table(elTable)

Nos permite hacer grupo de consoles pero dándole una indentación en la terminal.

console.group('grupo')
console.log('algo log')

console.info('algo info')

console.error('algo error')

console.warn('algo warn')
console.groupEnd('grupo')

Nos permite hacer conteos con los console,

console.count('veces')
console.count('veces')
console.count('veces')
console.count('veces')
// Con este reinicias el conteo
console.countReset('veces')
console.count('veces')

Nadie:
Absolutamente nadie:
Carlos conversando: blablablablablaxd 6:30

Me encantó console.table

Cosas que no tenía ni idea:
console.count(‘valor’);
console.table(array);

Si activan el modo de escritura de node en la consola con: node le dan enter y escriben console les aparecera un objeto con todos los metodos disponibles. Console es bastante poderoso la verdad.

creo que falto console.time me parece que tambien es muy util

console.clear();

Limpia la consola cada vez que lo ejecutas

//funciones
function funcion1() {
console.group('Funcion 1');
console.log('esto es de funcion 1');
console.log('esto es de funcion 1');
funcion2();
console.groupEnd('Funcion 1')
}


function funcion2() {
    console.group('funcion 2');
    console.log('esto es de funcion 2');
    console.groupEnd('funcion 2');

}

/////




//AGRUPAR CON GROUP Y COMO FUNCIONA
console.log('Ver algo');
console.error('inscribe el error');
console.warn('Puede ser un warning');

console.group('-> EJEMPLO DE TABLA EN CONSOLA :')
var tabla = [
    { a: 1, b: 2 },
    { a: 5, b: 6 }]

console.table(tabla);//sirve con arrays muy largos con muchas columnas.
console.groupEnd('-> EJEMPLO DE TABLA EN CONSOLA :');


//group permite dar identacion a lso consolog siguieenes hasta
//group end
console.group('conversacion:')
    console.log('Hola');
    console.log('Blabla');
    console.log('Adios');
console.groupEnd('conversacion:');

funcion1();


//contdor de veces que se ejecuta el log
console.count('veces');
console.count('veces');
console.count('veces');
console.count('veces');
console.countReset('veces');
console.count('veces');
//```

Con esto se puede medir el tiempo de ejecución. ⏱

console.time('100-elements');
for (let i = 0; i < 100; i++) {}
console.timeEnd('100-elements');
// prints 100-elements: 225.438ms

Me gusta mucho el console.table(), creo que es útil para ver datos de objetos.

yo para todo hacia console.log, para todo, y todas esa funciones que hay, OMG, Esta muuy completo platzi muyyyy completo

Tipo de console:
Console.log()

console.infoo()

Console.error()
Console.table() : Muestra datos en forma de módulo (tablas)
Console.warn()
console.group(): sirve para agrupar (indentar textos)
console.groupEnd() : finaliza la indentacion abierta
console.count(): contador
console.count(): reinicia contador

console.clear();
// Clear the console.

console.log('hello world');
// Writes 'hello world' to the console.
// Imprime así --> hello world

console.group('conversacion:');
	console.log('hola Andres, como estas?')
	console.log('bien Pedro y tu?')
	console.log('bien.')
console.groupEnd('conversacion:')
// Creates a new inline group, indenting all following output by another level. 
// To move back out a level, call groupEnd().
/*
Imprime así --> 
conversacion:
	hola Andres, como estas?
	bien Pedro y tu?
	bien
*/

console.count('contador')
console.count('contador')
console.countReset('contador')
console.count('contador')
// Log the number of times this line has been called with the given label.
// countReset resets the value of the counter with the given label.
/*
Imprime así -->
contador: 1
contador: 2
contador: 1
*/

console.table([{'a': 'b'}, {'c': 'd'}])
// Displays tabular data as a table.
/*
Imprime así -->
┌─────────┬─────┬─────┐
│ (index) │  a  │  c  │
├─────────┼─────┼─────┤
│    0    │ 'b' │     │
│    1    │     │ 'd' │
└─────────┴─────┴─────┘
*/

console.log("'console.log' Muestra un mensaje en la consola/terminal en la que se ejecuta el código")
console.info("'console.info' Muestra un mensaje informativo en la consola. Algunos navegadores identifican con un ícono 'i' estos mensajes en la consola web")
console.error("'console.error' muestra un mensaje de error. Algunas terminales, como Linux, lo  identifican con otro color")
console.warn("'console.warn' muestra un mensaje de advertencia(warning) en la consola. Errores o riesgos potenciales.")
console.table("'console.table' imprime una tabla a partir de un objeto pasado como parámetro. Visualización más legible")
console.table([{a:1, b:7}, {a:5, b:8}])
console.group("group")
console.log("'console.group(<nombreGrupo>)' sirve para agrupar varios logs como parte de un mismo conjunto de elementos")
console.log("Esto permite diferenciarlos de otros logs impresos en consola")
console.log("Para dejar de agrupar logs, usamos el comando 'console.group(<nombreGrupo>)'")
console.groupEnd("conversacion")
console.log("'console.count(<parametro>)' crea un contador autoincremntal que se incrementa cada vez que ejecutamos la función con el mismo el mismo valor como parámetro")
console.count("Ejemplo 1")
console.count("Ejemplo 2")
console.count("Ejemplo 1")
console.count("Ejemplo 2")
console.count("Ejemplo 1")
console.count("Ejemplo 2")
console.log("'console.countReset(<nombreGrupo>)' permite reiniciar el contador del valor recibido como parámetro")
console.log("Se ejecuta console.count('contador')")
console.count('contador')
console.count('contador')
console.count('contador')
console.log("Se reinicia el contador con console.countReset('contador')")
console.countReset('contador')
console.count('contador')
console.time('cronometro')
console.log("'console.time(<temporizador>)' inicializa un contador con asignado al valor pasado como parámetro")
console.log("Para concluirlo, debemos invocar la función 'console.timeEnd(<temporizador>)'")
console.timeEnd('cronometro')
console.log("'clear' limpia la consola")
//console.clear()```

• console.log(), console.info(), console.warm(), console.error(). Para mensajes que muestra un log, información, advertencia o error en pantalla.
• console.table(), Muestra una tabla, se puede usar con datos como matrices o diccionarios.
• console.group('group'), console.groupend('group'), Agrupa un grupo de mensajes creando una indetación.
• console.count(), cuenta un numero de mensajes.
• console.reset(), reinicia la cuenta de mensajes.

Interesante, no conocia toda la funcionalidad de console.

😃

var tabla = [
    {
        a: 1,
        b: 'Fran'
    },
    {
        a: 2,
        b: 'Juanda'
    }
]

console.table(tabla);

console.group('conversacion');
console.log('hola');
console.group('bla');
console.log('bla bla bla');
console.log('bla bla bla');
console.log('bla bla bla');
console.groupEnd('bla');
console.log('adios');
console.groupEnd('conversacion');

console.log('otra cosa');

//interesante par ver y contar las veces quie pasamos por un loop etc.
console.count('veces');
console.count('veces');
console.count('veces');
console.count('veces');
console.countReset('veces');
console.count('veces');
console.count('veces');

Resumen de la clase …

// console.log("Algo");

// console.info("Información");

// console.error("Error");

// console.warn("Alerta de posible error");

// let tabla = [
//   {
//     a: 1,
//     b: "Z"
//   },
//   {
//     a: 2,
//     b: "otra"
//   }
// ];

// console.table(tabla);  Muestra una tabla con la inf organizada

// console.group("Conversación");
// console.log("Abuelos");
// console.log("Abuelos");
// console.log("Abuelos");
// console.groupEnd("Aqui acaba el grupo de conversación");
// console.log("Tryna tell ya boys");
//
// const function1 = () => {
//   console.group("Function 1");
//   console.log("Give a t-shir to her, she said throw it on");
//   function2();
//   console.groupEnd("Function 2");
// };

// const function2 = () => {
//   console.group("Function 2");
//   console.log("Ahora modo función dos");
//   console.groupEnd("Function 1");
// };

// console.log("Empezamos");
// function1();

console.count("veces");

/*Este módulo de node es poderosísimo, te da buen control sobre la consola. Aquí les dejo otros dos métodos que no se mencionaron en la
clase y que les puede servir:

console.clear(): limpiará la consola, aunque depende mucho del sistema operativo su comportamiento. Por ejemplo, en linux es equivalente
al comando clear, mientras que en Windows borrará solo la salida en la vista de la terminal actual.
console.timer(‘timer’): comienza un temporizador que puedes usar para calcular la duración de cualquier operación. El mismo parámetros
que le pasamos se pasara a console.timerEnd() para detener al contador. */

// Console

// console.log() recibe cualquier tipo y lo muestra en el consola.
/*
console.log('Algo')
 */
// console.info()  es equivalente a log pero es usado para informar.
/*
console.info('Algo')
 */
// console.warn() es equivalente a log pero es usado para warning.
/*
console.warn('Algo')
 */
// console.error() es equivalente a log pero es usado para errores.
/*
console.error('Algo')
 */
// console.table() muestra una tabla a partir de un objeto.

// console.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }]);
/*
var tabla = [
    {
        a:1,
        b:'z'
    },
    {
        a:2,
        b: 'Otra'
    }
]
console.table(tabla)
*/
// ┌─────────┬─────┬─────┐
// │ (index) │  a  │  b  │
// ├─────────┼─────┼─────┤
// │    0    │  1  │ 'Y' │
// │    1    │ 'Z' │  2  │
// └─────────┴─────┴─────┘

// console.group(); permite agrupar errores mediante identación
// console.groupEnd(); finaliza la agrupación.

// EJEMPLO 1
/*
console.group('saludo');
console.log('Hola');
console.log('blablabla');
console.log('blablabla');
console.groupEnd('saludo');
console.group('despedida');
console.log('Se cuida');
console.log('adios');
console.group();
console.log('Carlos');
console.groupEnd();
console.groupEnd();
*/
// EJEMPLO 2
console.count('veces');
console.count('veces');
console.count('veces');
console.countReset('veces');
console.count('veces');```

var tabla = [
    {
        a: 1,
        b: 'Z'
    },
    {
        a: 2,
        b: 'Otra'
    }
]
console.table(tabla);

console.log('');
console.group('Conversacion: ');
console.log('Hola');
console.log('Bla bla bla');
console.log('Adios');
console.groupEnd('Conversacion: ');

console.log('Otra cosa');


function fun1() {
    console.group('Funcion1');
    console.log('Esto es de la funcion 1');
    console.log('Esto tambien');
    
    fun2();
    console.log('He vuelto a la 1')
    console.groupEnd('Funcion1');
}

function fun2() {
    console.group('Funcion2');
    console.log('Ahora estamos en la funcion 2');
    console.log('Bla bla bla');
    console.groupEnd('Funcion2');
}

fun1();

console.count('veces');
console.count('veces');
console.countReset('veces');
console.count('veces');
console.count('veces');

/* Limpiar la consola */
console.clear()
/* Normal */
console.log("Lo que sea");
/* Informando */
console.info("Lo que sea con info");
/* Marcando un error */
console.error("Lo que sea con error");
/* Adviritendo */
console.warn("Lo que sea advirtiendo")
/* Mostrando en forma de tabla */
let tabla = [
    {
        a: 1,
        b: "Z"
    }, {
        a: 2,
        b: "X"
    }
]
console.table(tabla);

/* Agrupar logs */
console.log("Conversacion:");

console.group("Conver")
console.log("Hola");

console.group("Conver");
console.log("Blablabla");
console.groupEnd("Conver")

console.log("Adios");
console.groupEnd("conver")

console.log("Otra cosa");
/* Ejemplo de agrupar logs con funciones */
function function1() {
    console.group("Funcion 1");
    console.log("Soy la funcion 1");
    function2()
    console.log("Sigo siendo la funcion 1");
    console.groupEnd("Funcion 1")
}
function function2() {
    console.group("Funcion 2")
    console.log("Soy la funcion 2");
    console.groupEnd("Funcion 2")

}
console.log("Empezamos");
function1()

/* Contar las veces que hago un log */

console.count("Veces")
console.count("Veces")
console.count("Veces")
console.count("Veces")
console.countReset("Veces");
console.count("Veces")
console.count("Veces")
console.count("Veces")

/* Temporizador */
console.time("Timer")
console.log("--------")
console.timeEnd("Timer");

Aca en la documentación de node hay un montón de opciones más para console: https://nodejs.org/api/console.html 😃

que bonito es lo bonito!

const tabla = [{
    a: 1, b: 'z'
}, { a: 2, b: 'otra' }];
console.table(tabla);

console.table es tan bonito ❤️

consola de node js: es lo que mas se utiliza para cuando se debugueamos, ver valores de variables y entender el funcionamiento del código, esta es otra alternativa a console.log .

Interesante, desconocía el poder del console 😮

Excelente explicación!!!

que calidadd para enseñaar 👏

Hay una dependencia muy divertida para node JS que nos simplifica mucho trabajar con colores y algunos estilos para los textos de la consola, se llama “colors.js”

https://www.npmjs.com/package/colors

npm install colors

console.log('Algo');
console.info('Otro algo');
/* log se usa para cosas que quieras guardar e info se usa solamente para mostrar informacion */

/* Si quieres loguear un error y que este se guarde en un sitio diferente. */
console.error('Error en algo');

/* para indicar que algo es un potencial error */

console.warn('Cuidado con algo');

/* te muestra datos enforma de tabla  funcion muy util para rrayas largos*/
let tabla = [
    {
        a: 1,
        b: 'z'
    },
    {
        a: 2,
        b: 'otra'
    }
];

console.log(tabla);
console.table(tabla);

/* permite agrupar varios logs para indicar que forma parte de una sola cosa */
console.group('conversacion');
console.log('Hola');
console.group('bla');
console.log('Blabla bla bla');
console.log('Blabla bla bla');
console.log('Blabla bla bla');
console.groupEnd('bla');
console.log('Adios');
console.groupEnd('conversacion')
console.log('otra funcion nada que ver con los log anterior');


function function1() {
    console.group('funcion 1')
    console.log('esto es de la funcion 1')
    console.log('esto tambien')
    console.log('esto tambien')
    function2();
    console.log('Eh vuelto a la funcion 1')
    console.groupEnd('funcion 1')
}

function function2() {
    console.group('funcion 2')
    console.log('esto es de la funcion 2')
    console.groupEnd('funcion 2')
}

console.log('Empezamos');
function1();

/* para crear contadores */

console.count('veces');
console.count('veces');
console.count('veces');
console.count('veces');
console.count('veces');

const codeColors = { 
    error: 31,
    info: 34,
    warn: 33
}
console.error(`\x1b[${codeColors['error']}m%s\x1b[0m`, 'error');
console.info(`\x1b[${codeColors['info']}m%s\x1b[0m`, 'info');
console.warn(`\x1b[${codeColors['warn']}m%s\x1b[0m`, 'warn');

🚀more info

Mis aportes

console.log('Algo'); /*Ver algo */
console.info('Informacion'); /*Nos permite ver la información de algo, en cosas mas complejas*/
console.error('Error'); /*Te muestra en error, en navegador se nota en rojo*/
console.warn('Warn!!!'); /*Es equivalente a log pero es usado para warning. */

var tabla = [
    {
        a: 1,
        b: 'Z'
    },
    {
        a: 2,
        b: 'Hola'

    }
]
console.table(tabla); /*Te muestra cosas en forma de tabla: */

/*console.group agrupa los .log*/
console.group('Conversación');
console.log('Hola');
console.log('BLALBABLALBALBLAB');
console.log('glub glub glub');
console.log('adios');
console.groupEnd('Conversación');

console.group('Numeros');
console.log('1');
console.log('2');
console.groupEnd('Conversación');


/*Ejemplo en funciones de console.group */

function function1() {
    console.group('funcion1');
    console.log('Esto es de la funcion 1');
    console.log('Esto también')
    function2();
    console.log('He vuelo a la 1');
    console.groupEnd('funcion1');
}
function function2() {
    console.group('funcion2');
    console.log('ahora estamos en la funcion 2')
    console.groupEnd('funcion2');
}
console.log('Empezamos');
function1();

/*Contador en consola*/
console.count('veces');
console.count('veces');
console.count('veces');
console.countReset('veces'); //Resetea el contador
console.count('veces');
console.count('veces');
''' 

mi
console.table(tabla);
no hace nada.
:[

Documentación de Console en Node:

Wow no tenia ni idea que se podia hacer todo esto con console, buenos conjuros para guardar en el libro de hechizos jajaja

wooo esto es GENIAL !! no sabia que existian todas estas opciones en el console

wow nunca había prestado atención a todo lo que podemos hacer con a consola

Pff… el Console table es una maravilla 😄

Rayos he estado ocupando el console.log de manera erronea todo este tiempo 😢

Aquí todas las opciones del módulo console:
https://nodejs.org/dist/latest-v12.x/docs/api/console.html

Estuvo muy buena esta clase!!! Excelente, vamos por más aprendizaje.

Like si te exploto la cabeza con esta clase!!! XD
😱 Saber esto me hubiera ahorrado muchos dolores de cabeza en el pasado

console.log(console)

console.groupcollapsed

https://www.geeksforgeeks.org/html-dom-console-groupcollapsed-method/

hehehe he aumentado la velocidad para recordar estas clases, usando las funciones asincronas y await + el comando alias + nodemon …
por ejemplo:
si quiero recordar algo visto en esta clase en la consola primero creo el alias:

alias clasenodeconsola=npx nodemon rutaconsolas.js

y dentro del archivo consolas.js he escrito unas funciones que me muestran en la consola el codigo y su output ejemplo:

async function main () {
    let tabla = {
        a1: "valor1",
        b2: "valor2",
        b3: "valor3",
    };
    

    async function banner(nombre,Jarvis,intb) {
        return new Promise(function (resolve, reject) {
            setTimeout(function () {
                let Wellcome = "Wellcome Sir,"
                let Platzi = " Platzi"           console.log("###########======########======##########");
                resolve();
                reject(console.error(Wellcome + Platzi+Jarvis+nombre));
            }, intb);
        });
    }
    async function codigo(nombre, intc) {
        return new Promise(function (resolve, reject) {
            setTimeout(function () {
                console.log(nombre);
                resolve();
            }, intc);
        });
    }
    await banner("",' Estos son los distintos tipos de console.logs que existen: \n');
    
    console.log("console.log() printType:LOG el print de toda la vida");
    console.info("console.info() printType:INFO: Para rastrear el codigo");
    console.error("console.error() printType:ERROR: renderiza distinto");
    console.warn("console.warn() printType:WARN: renderiza distinto");

    await codigo('\n console.table(tabla) renderiza una tabla: \n');
    await codigo('\n se declara la (tabla) \n\t let tabla = { \n\t a1: \"valor1\",\n\t b2: \"valor2\",\n\t b3: \"valor3\",\n\t}; \n');
    await codigo('y asi renderiza la tabla: \n');
    console.table(tabla);

    }
main(); 

Yo no conocia todas las funciones del console.log, muchas gracias

Console

1. log

console.log('Ver algo') 
// --> Ver algo

2. info

console.info('Información sobre algo')
// --> Información sobre algo

3. error

console.error('error personalizado')
//3) --> error personalizado

4. warn

console.warn('Algo')
//--> Algo
// funciona como log, pero en color de alerta

5. table

let table = [
  {
    a: 1,
    b: 'Z',
  },
  {
    a: 2,
    b: 'Y',
  },
]

console.log(table)
// --> [ { a: 1, b: 'Z' }, { a: 2, b: 'Y' } ]

console.table(table) 

/*
  ┌─────────┬───┬─────┐
  │ (index) │ a │  b  │
  ├─────────┼───┼─────┤
  │    0    │ 1 │ 'Z' │
  │    1    │ 2 │ 'Y' │
  └─────────┴───┴─────┘  
*/

console.table permite arrojar información en la consola de forma más organizada cuando proviene de una estructura de datos como un array y un objeto.

6. group

//6) Group
const function1 = () => {
  console.group('Función 1')
  console.log('Esto es de la función 1')
  console.log('Esto también de la 1')
  function2()
  console.groupEnd()
}

const function2 = () => {
  console.group('Función 2')
  console.log('Esto es de la función 2')
  console.log('Esto también es 2')
  console.groupEnd()
}

function1()

/*
	Función 1
		Esto es de la función 1
		Esto también de la 1
			Función 2
				Esto es de la función 2
				Esto también es 2
*/

console.group permite agrupar datos que van a ser mostrados en la consola de forma seccionada o agrupada.

7. count

console.count('veces') // veces: 1
console.count('veces') // veces: 2
console.count('veces') // veces: 3
console.countReset('veces')
console.count('veces') // veces: 1
console.count('veces') // veces: 2

Me parece genial que enseñen estas herramientas muy importantes cuando vamos a debuggear 😄

Comparto un recurso interesante sobre console.

Estás usando mal console.log en javascript

Un saludo y gracias.

// Makes a table into the console. Very useful.
var table = [
  {
    a: 1,
    b: "otra",
  },
];
console.table(table);

// Prints and saves in color the errors.
console.error("something");
// Prints and saves in color a potential error.
console.warn("something");

// How to group functions into the console.
function function2() {
  console.group("Funcion 2");
  console.log("Esto es de la funcion 2");
  console.groupEnd("Function 2");
}
function function1() {
  console.group("Funcion 1");
  console.log("Esto es de la funcion 1");
  console.log("Esto tambien");
  function2();
  console.groupEnd("Funcion 1");
}

console.log("Empezamos");
function1();


// Console count ables to count a number of times.
console.count("veces");
console.count("veces");
console.countReset("veces");
console.count("veces");

Console

La consola contiene diferentes funciones para el despliegue de mensaje en la consola:

console.log('') y console.info(''): Son iguales para node, desplegaran información.

console.log('Uno');
console.info('Dos');

Uno
Dos

console.error(''):En algunas consolas mostrara un mensaje en otro color.

console.error('Error');

Error

console.table(''): Nos mostrara información en estilo tabla.

equiposFutbol = {
  españa: {
    realmadrid: 'RM',
    Barselona: 'BSC',
    atleticoMadrid: 'ATM',
  }
}
console.table(equiposFutbol);

┌─────────┬────────────┬───────────┬────────────────┬──────────────────┬────────┐
│ (index) │ realMadrid │ Barcelona │ atleticoMadrid │ parisSaintGerman │ monaco │
├─────────┼────────────┼───────────┼────────────────┼──────────────────┼────────┤
│ españa  │    'RM'    │   'BSC'   │     'ATM'      │                  │        │
│ francia │            │           │                │      'PSG'       │ 'MON'  │
└─────────┴────────────┴───────────┴────────────────┴──────────────────┴────────┘

console.group(''): y console.groupEnd(): Sirve para agrupar logs de una misma indole.

console.group('Equipos de España');
console.log('Real Madrid');
console.log('Barcelona');
console.log('Atlético de Madrid');
console.group('Equipos de Francia');
console.log('Paris Saint German');
console.log('Mónaco');
console.groupEnd();
console.groupEnd();

Equipos de España
  Real Madrid
  Barcelona
  Atlético de Madrid
  Equipos de Francia
    Paris Saint German
    Mónaco

console.count(''): Es un contador de veces que pasa algo. console.countReset(''):

console.count('Veces');
console.count('Veces');
console.count('Veces');
console.count('Veces');
console.countReset('Veces');
console.count('Veces');

Veces: 1
Veces: 2
Veces: 3
Veces: 4
Veces: 1

¿Soy el único que piensa en todo lo que podría hacer con estas funciones? Mejor aún, ¿imagina que tuvieras estás funciones de console en todos los lenguajes?

El console.table() va a ser una maravilla para mirar json en consola 🤤

Muy interesante.

excelente curso hasta ahora del profe

otro dato es que en los console en el navegador se distingue por colores
.info (gris) , .error(rojo) .warning(naranja) y que tambien se puede manipular el tamaño, color y fuente del log

Excelente clase!

Sin duda empezaré a usar bastante console.count y console.table

este es uno de los puntos en los que opino que JS le gana a python, que tenga toda esta funcionalidad de logs por defecto es brutal (python requiere importar una librería)

Aquí les dejo mi código para el que quiera mirar mas xd
PD: Realizado con Carbono

La consola también tiene funcionalidades para medir el tiempo que se demora una función utilizando console.time y console.timeEnd. Además permite hacer un grupo que se pueda ocultar con console.groupCollapse. Incluso permite obtener el stack de todas las funciones que se llamaron utilizando console.trace.

Aquí les dejo un video que muestra estas funcionalidades: https://www.youtube.com/watch?v=L8CDt1J3DAw

xq nunca supe lo del .table, para ver un array? jajajaja

La vida vuelve a comenzar cuando conoces console.table

Tantas cosas que pudieron haber sido mas facil de conocer el console.table(), aquí se aprende de todo

Esta bien perron el console.table

Console es más poderosa de lo que creía. 💚

Genial

Genial todo lo que se puede hacer por consola 💪

console.clear() me servira mucho.

Esa consola es bien cool, que grato ya saberlo

muy interesante la cantidad de opciones que maneja el console

interesante este dato, solo conocia el console.log().

Muy buenas las funciones. La mayoría no las conocía.

¿Como actúa console.group() en funciones asíncronas?

cool

console .table es lo mejor ❤️

Jajaja que cool table

Este profesor explica muymuymuymuymuy BIEN!

Es la clase de conocimientos que me hace ver que todo este tiempo estuve haciendo las cosas “De la manera difícil”.

Cuando trabajamos con console.group podemos omitir el texto del console.groupEnd dejándolo de la siguiente manera:

console.group("Conversación");
console.log("Conversación");
console.log("Hola");
console.log("Blabla");
console.log("Adios");
console.groupEnd();

El resultado viene a ser el mismo.

🤯🤯🤯 Sencillamente genial, solo sabia de console.log esto abre un mundo realmente increíble, ahora a hacer debugging correctamente

Con console podemos imprimir todo tipo de valores por
nuestra terminal.

Muy buena información, nunca habia interesado por la consola aparte del console.log de haberlo sabido me habria ahorrado mucho trabajo

Bla bla bla bla bla. Me encantan las clases con este profe 😃