Tu primera experiencia con Node.js

1

¿Dónde aprender backend con Node.js actualizado?

2

Todo lo que aprenderás sobre backend con Node.js

3

¿Qué es Node.js?

4

¿Qué es Node.js y para qué sirve?

5

Diferencias entre Node.js y JavaScript

6

Resumen: Diferencias Nodejs y Javascript

7

Instalación de Node.js

8

Arquitectura orientada a eventos

9

Node.js para la web

Manejo y uso de Streams con Node.js

10

Introducción a streams

11

Readable y Writable streams

12

Duplex y Transforms streams

Uso de utilidades de Node.js

13

Sistema operativo y sistema de archivos

14

Administrar directorios y archivos

15

Consola, utilidades y debugging

16

Clusters y procesos hijos

Crea tu primer proyecto en Express.js

17

¿Qué es Express.js y para qué sirve?

18

Creando tu primer servidor con Express.js

19

Request y Response Objects

Aprende a crear un API con REST

20

Anatomía de una API Restful

21

Estructura de una película con Moockaru

22

Implementando un CRUD en Express.js

23

Métodos idempotentes del CRUD

24

Implementando una capa de servicios

Cómo conectarse con librerías externas en Express.js

25

Creación de una BD en MongoAtlas

26

Conexión a MongoAtlas una instancia de MongoDB

27

Conexión con Robot3T y MongoDB Compass a una BD

28

Implementación de las acciones de MongoDB

29

Conexión de nuestros servicios con MongoDB

Conoce como funcionan los Middleware en Express.js

30

¿Qué es un middleware? Capa de manejo de errores usando un middleware

31

Manejo de errores asíncronos y síncronos en Express

32

Capa de validación de datos usando un middleware

33

¿Qué es Joi y Boom?

34

Implementando Boom

35

Implementando Joi

36

Probar la validación de nuestros endpoints

37

Middlewares populares en Express.js

Implementa tests en Node.js

38

Creación de tests para nuestros endpoints

39

Creación de tests para nuestros servicios

40

Creación de tests para nuestras utilidades

41

Agregando un comando para coverage

42

Debugging e inspect

Despliega tu primera aplicación en Express.js

43

Considerando las mejores prácticas para el despliegue

44

Variables de entorno, CORS y HTTPS

45

¿Cómo implementar una capa de manejo de caché?

46

¿Cómo contener tu aplicación en Docker?

47

Despliegue en Now

Conclusiones

48

¿Qué aprendiste en este curso?

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Consola, utilidades y debugging

15/48
Recursos

Aportes 56

Preguntas 5

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

El módulo útil esta diseñado para resolver las necesidades internas de las API de Node, sin embargo muchas de estas utilidades también son útiles para los módulos de las aplicaciones en desarrollo. Se puede acceder a estas utilidades usando:
const util = require('util');

util.format()
El método util.format () devuelve una cadena formateada utilizando el primer argumento como una cadena de formato tipo printf que puede contener cero o más especificadores de formato. Cada especificador se reemplaza con el valor convertido del argumento correspondiente. Los especificadores compatibles son:

  • %s - String
  • %d - Number
  • %i - parseInt(value, 10)
  • %f - parseFloat(value)
  • %j - JSON
  • %o - Object
  • %c - Css
  • %% - signo de '%'
    Inspector
    cuando se inicia la inspección --inspect, Node escucha a un cliente de depuración , Por defecto escuchara el host y el puerto 127.0.0.1:9229 y a cada proceso se le asigna un id único.
    Opciones de la línea de comandos
    --inspect: Habilita el agente de inspección y escucha el puerto por defecto 127.0.0.1:9229
    --inspect=[host:port]: Habilita el agente de inspección, vincula la dirección y el puerto a la dirección de inspección.

Reto (estuvo super interesante me costo mucho trabajo)

const log = new console.Console({
  stdout: process.stdout,
  strerr: process.strerr
});

const emojis = {
  log: "  \u001b[37m ☺",
  danger: "  \u001b[31m ☠",
  info: "  \u001b[34m ℹ",
  warning: "  \u001b[33m ⚠",
  love: "  \u001b[35m ❤"
};

console.Console.prototype.logger = function(text) {
  this.log(`${emojis.log} ${text}`);
};

console.Console.prototype.warning = function(text) {
  this.warn(`${emojis.warning} ${text}`);
};

console.Console.prototype.information = function(text) {
  this.info(`${emojis.info} ${text}`);
};

console.Console.prototype.danger = function(text) {
  this.error(`${emojis.danger} ${text}`);
};

console.Console.prototype.love = function() {
  this.error(`${emojis.love} This was made with love for you`);
};

log.logger("this is a normal log");
log.information("this is a info log");
log.warning("this is a warning log you should read it");
log.danger("this is a error log, You are in fire");
log.love();

output

Para poder poner color a la consola les recomiendo este artículo: Make Color console.log

Mientras, les muestro mi solución del challenge:

En la salida se ve muy bien esto:

Mi solución:

Mi consola 😉:

const consoleFile = new console.Console(out, err);

consoleFile.meliodas = (msg = '') => {
    console.log('\x1b[31m', `🐉 Full Counter! ${msg}`)
};

consoleFile.escanor = (msg = '') => {
    console.log('\x1b[33m', `🦁 Sunshine! ${msg}`)
};

consoleFile.ban = (msg = '') => {
    console.log('\x1b[37m', `🦊 Physical Hunt! ${msg}`)
};

consoleFile.king = (msg = '') => {
    console.log('\x1b[34m', `🐻 Status Promotion! ${msg}`)
};

consoleFile.diane = (msg = '') => {
    console.log('\x1b[33m', `🐍 Mother Catastrophe! ${msg}`)
};

consoleFile.gowther = (msg = '') => {
    console.log('\x1b[35m', `🐏 Lost World! ${msg}`)
};

consoleFile.merlin = (msg = '') => {
    console.log('\x1b[35m', `🐗 Enchant Infinity! ${msg}`)
};

consoleFile.meliodas();
consoleFile.escanor();
consoleFile.ban();
consoleFile.king();
consoleFile.diane();
consoleFile.gowther();
consoleFile.merlin();

El código es una mezcla de varios challenges que vimos:

//Declaration
const fs = require(`fs`);
const server = require(`http`).createServer();
const { Transform } = require('stream');

const err = fs.createWriteStream(`./ErrorInfo`);
const data = fs.createWriteStream(`./DataInfo`);

const consolePersonalizate = new console.Console(data, err);

//modifications:
consolePersonalizate.yourAgeDaySERVER = (method, port) => {
    server.on(`request`, (req, res) => {
        let body = [];
            if(req.method ===  method && req.url === `/echo`) {
                req
                .on('data', (data) => {
                    body.push(data)
                })
                .on('end', () => {
                    res.writeHead(200, { 'Connection' : 'OK' });
                    body = Buffer.concat(body).toString();
                    let resmeta = `Naciste un: ${new Date(body)}`;
                    console.group('res');
                        console.log(resmeta);
                    console.groupEnd('res');
                    res.end(resmeta);
                })
            } else {
                let errorPath = 'error path no specified or this is´nt correct';
                res.statusCode = 404;
                console.log(errorPath);
                res.end(errorPath);
            }
    });
    server.listen(port);
    port ? console.log(`Listening in port: ${port}`) : console.error(`Error: port no specified`);
}

consolePersonalizate.CamelCase = (chunk) => {
    return chunk.charAt(0).toUpperCase() + chunk.slice(1).replace(/ +/g, "");
}

const Transforms = new Transform({
    transform(chunk, encoding, cb) {
        this.push(consolePersonalizate.CamelCase(chunk.toString()));
        cb();
    }
});

//Print
consolePersonalizate.yourAgeDaySERVER('POST', 8000);
process.stdin.pipe(Transforms).pipe(process.stdout);
consolePersonalizate.log('Hello Log');

Reto

const fs = require('fs')
const output = fs.createWriteStream('./stdout.log')
const error = fs.createWriteStream('./stderr.log')

const date = new Date()
const customConsole = new console.Console(output,error)

customConsole.logger = (element) => {
    customConsole.log(`Logger created on ${date} : ${element}`)
    console.log("\x1b[34m%s\x1b[0m",`💬  This part is log : ${element}`)
}
customConsole.warning = (element='')=>{
    customConsole.log(`Warning created on ${date} : ${element}`)
    console.log("\x1b[33m%s\x1b[0m",`❕  This part is warning : ${element}`)
}
customConsole.danger = (element='')=>{
    customConsole.log(`Danger created on ${date} : ${element}`)
    console.log("\x1b[31m%s\x1b[0m",`❗  This part is danger : ${element}`)
}
customConsole.err = (error='')=>{
    customConsole.error('An error occurred')
    console.log("\x1b[32m%s\x1b[0m",`❌  An error occurred : ${error}`)
}

customConsole.logger('Hello')
customConsole.warning()
customConsole.danger()
customConsole.err()

Consola:

Reto:

const miConsola = new console.Console(process.stdout, process.stderr);

miConsola.imprimirInfo = (msg = '') => {
    console.log('-> [Information]: %s', msg)
};

miConsola.imprimirWarning = (msg = '') => {
    console.log('-> [Warning]: %s', msg)
};

miConsola.imprimirError = (msg = '') => {
    console.log('-> [Error]: %s', msg)
};

miConsola.imprimirInfo('Hola mundo');
miConsola.imprimirWarning('Hola mundo');
miConsola.imprimirError('Hola mundo');

Para los que quieran la referencia de los colores, los pueden traer desde aquí:
stackoverflow.com/questions/9781218/how-to-change-node-jss-console-font-color

Tomé como ejemplo a los compañeros Marco Antonio y Derek Samuel para hacer mi desafío y con cambios leves entre este y los desafíos anteriores, el código pide tu fecha de nacimiento y devuelve el día de la semana en la que naciste, enviando log, error e info. También anda suelto un warn que no usé…

const { Transform } = require('stream')
const myConsole = new console.Console(process.stdout, process.stderr)

color = {
  "red": { "bold": "\x1b[1;31m", "normal": "\x1b[0;31m" },
  "green": { "bold": "\x1b[1;32m", "normal": "\x1b[0;32m" },
  "white": { "bold": "\x1b[1;37m", "normal": "\x1b[0;37m" },
  "violet": { "bold": "\x1b[1;35m", "normal": "\x1b[0;35m" },
} //clicolors ascii

myConsole.log = (msg) => {
  console.log(`${color.violet.bold}[MESSAGE] => ${color.violet.normal}${msg} ${color.white.normal}`)
}

myConsole.error = (err) => {
  console.error(`${color.red.bold}[ERROR] => ${color.red.normal}${new Error(err)} ${color.white.normal}`)
}

myConsole.info = (info) => {
  console.info(`${color.green.bold}[INFO] => ${color.green.normal}${info} ${color.white.normal}`)
}

myConsole.warn = (warn) => {
  console.warn(`${color.red.bold}[WARNING] => ${color.white.bold}${warn} ${color.white.normal}`)
}

const days = ['Domingo', 'Lunes', 'Martes',
  'Miercoles', 'Jueves', 'Viernes', 'Sábado'] // domingo es el primer día según MDN

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    chunk = chunk.toString()
    chunk = chunk.split("/")
    let [day, month, year] = chunk
    date = new Date(`${month}/${day}/${year}`)
    if (date == 'Invalid Date') { // si la fecha está mal escrita
      myConsole.error('la fecha que ingresaste no es válida. Formato: DD/MM/YYYY')
    } else {
      formatDate = `${day}/${month}/${year}`
      myConsole.info(`Resultado: `)
      this.push(`Naciste el ${formatDate} un día ${days[date.getDay()]}\n`)
    }
    callback()
  }
})

myConsole.log('Hola, ingresa tu fecha de nacimiento en el siguiente formato: DD/MM/YYYY')
process.stdin.pipe(transformStream).pipe(process.stdout)

Al inicio:
[MESSAGE] => Hola, ingresa tu fecha de nacimiento en el siguiente formato: DD/MM/YYYY
Posibles respuestas:

[ERROR] => Error: la fecha que ingresaste no es válida. Formato: DD/MM/YYYY

[INFO] => Resultado: Naciste el [FECHA] un día [DIA]

Reto:

const consoleAux = new console.Console(process.stdout, process.stderr);
let fecha = new Date();
consoleAux.printInfo = (msg = "") => {
  console.info(
    "\x1b[36m%s\x1b[0m",
    "[Information] - " + fecha + ":: ",
    "\x1b[0m",
    "\n\t >> " + msg
  );
};

consoleAux.printWarn = (msg = "") => {
  console.warn(
    "\x1b[33m%s\x1b[0m",
    "[Warning] - " + fecha + ":: ",
    "\x1b[0m",
    "\n\t >> " + msg
  );
};

consoleAux.printErr = (msg = "") => {
  console.error(
    "\x1b[31m%s\x1b[0m",
    "[Error] - " + fecha + ":: ",
    "\x1b[0m",
    "\n\t >> " + msg
  );
};

consoleAux.printSuc = (msg = "") => {
  console.log(
    "\x1b[32m%s\x1b[0m",
    "[Success]  - " + fecha + ":: ",
    "\x1b[0m",
    "\n\t >> " + msg
  );
};

consoleAux.printInfo("Mensaje de información.");
consoleAux.printWarn("Mensaje de advertencia.");
consoleAux.printErr("Mensaje de error.");
consoleAux.printSuc("Mensaje de éxito.");

Resultado en consola:

Un poco largo, pero ahi esta!

const _console = new console.Console(process.stdout, process.stderr);

_console.xinfo = (msg = '') => {
    const type = typeof msg;
    if(type === 'number')
        console.info('[info number] => %d', msg);
    else if(type === 'object')
        console.info('[info json] => %j', msg);
    else
        console.info('[info string] => %s', msg);
    
}
_console.xwarn = (msg = '') => {
    const type = typeof msg;
    if(type === 'number')
        console.warn('[warn number] => %d', msg);
    else if(type === 'object')
        console.warn('[warn json] => %j', msg);
    else
        console.warn('[warn string] => %s', msg);
    
}
_console.xerror = (msg = '') => {
    const type = typeof msg;
    if(type === 'number')
        console.error("[error number] => %d", msg);
    else if(type === 'object')
        console.error("[error json] => %j", msg);
    else
        console.error("[error string] => %s", msg);
}

_console.xinfo('Esto es un info')
_console.xinfo(30)
_console.xinfo({"Nombre":"Carlos Ramírez"})

_console.xwarn('Esto es un warn')
_console.xwarn(20)
_console.xwarn({"warning":"Validar funcion"})

_console.xerror('Esto es un error')
_console.xerror(10)
_console.xerror({"error":"error 404", "line":50})

![](

Ahora si que me pasó algo bien curioso pero me ayudó a entender más lo que hemos venido viendo.

Al momento de querer hacer el new console.Console me tira el error de que espera un writable stream, por lo que decidí a probar con ello.
En la clase de Readable y Writeable streams menciona que el process.stdout lo llama console.log por debajo, esto me ha parecido muy interesante entonces decidí a probar a hacer mi propio console.log.

El resultado es el siguiente:

const { Writable } = require("stream");

const writableStreamLog = new Writable({
  write(chunk, encoding, callback) {
      const now = new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '');
      process.stdout.write('----------------------------------------\n');
      process.stdout.write('------- Escuela de Javascript ----------\n');
      process.stdout.write(`------- LOG ${now} --------\n`);
      process.stdout.write(`\x1b[32m${chunk.toString()}\x1b[0m`);
      process.stdout.write('----------------------------------------\n\n');
      callback();
  }
});

const writableStreamError = new Writable({
    write(chunk, encoding, callback) {
        const now = new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '');
        process.stdout.write('----------------------------------------\n');
        process.stdout.write('------- Escuela de Javascript ----------\n');
        process.stdout.write(`------ ERROR ${now} -------\n`);
        process.stdout.write(`\x1b[31m${chunk.toString()}\x1b[0m`);
        process.stdout.write('----------------------------------------\n\n');
        callback();
    }
});

const ej_console = new console.Console(writableStreamLog, writableStreamError);
ej_console.log('esto es un log');
ej_console.error('esto es un error');

El resultado en la consola.

Aquí está mi consola:

Mi consola creada (guarda los logs):

const fs = require("fs");

// const out = fs.createWriteStream("./out.log");
// const err = fs.createWriteStream("./err.log");

const personalConsole = new console.Console(process.stdout, process.stderr);

personalConsole.succes = (str) => {
  console.log(`✅`, `${str}`);
};

personalConsole.log = (str) => {
  console.log(`📃`, `${str}`);
};

personalConsole.error = (str) => {
  console.log(`❌`, `${str}`);
};

personalConsole.warn = (str) => {
  console.log(`👮`, `${str}`);
};

personalConsole.succes("El proceso se completo con exito");
personalConsole.log("un log comun y corriente");
personalConsole.error("Ocurrio un error");
personalConsole.warn("Cuidado, accion peligrosa");

Utils

  • Consola personalizada

Gracias a fs podemos crear nuestra propia consola personalizada, esta nos permitirá manipular los datos como deseemos y almacenar los datos en los archivos que queramos.
Se realizan de la siguiente manera:

const fs = require('fs');

const out = fs.createWriteStream('./out.log');
const err = fs.createWriteStream('./err.log');

const consoleFile = new console.Console(out, err);

setInterval(() => {
    consoleFile.log(new Date());
    consoleFile.error(new Error('errorrrreeesss de la vida'));
}, 2000);
  • console.log

Una funcionalidad en console.log, es que le podemos pasar parametros donde

  • %s = string
  • %d = number
  • %j = json
function consoleString (data1, data2){
    //recibe parámetros
    console.log("Un %s y un %s", data1, data2);
}

consoleString('gatoooo soooy', 'Guau guau tambien');
  • console.info

Es igual que console.log

console.info("hellow world");
  • console.assert

Devuelve una respuesta en booleano

console.assert(42 === '42'); //false
  • console.trance

Es especifico, nos indica exactamente la linea de código donde ocurrio el error

console.trace("hello");
  • debuglog

Es una funcionalidad de util, se ejecuta únicamente si pasamos la variable entorno con namespace

const util = require("util");
const debuglog = util.debuglog("foo");
debuglog("hello from foo")

para que se ejecute en este ejemplo ejecutaremos en consola:

NODE_DEBUG=foo node console.utils.js

respuesta:

FOO 665: hello from foo
  • deprecate

Es una funcionalidad de util, la cual nos permite advertir al usuario que esta utilidad quedara en desuso, para luego desaparecer en un futuro.

const util = require('util');

const helloPluto = util.deprecate(()=>{
    console.log('Hello pluto');
}, 'pluto is deprecated, Its not a planet anymore');

helloPluto();
  • **debugging con --inspect

Podemos hacerle debugging desde el navegador con las herramientas que otorga NodeJs, esto lo hacemos ejecutando lo siguiente en consola:

node --inspect archivo.js

Luego ingresamos al localhost:9229, vamos a inspeccionar elementos, luego de ello debemos darle click al icono de node, y podremos ver el código y operar con las herramientas de debugging.

Mi version usando la clase “console”:

const fs = require('fs')
const { Console } = require('console')

const out = fs.createWriteStream("./reto-out.log")
const err = fs.createWriteStream("./reto-err.log")

const MyCoLogs = new Console({ stdout: out, stderr: err })

setInterval(() => {
  MyCoLogs.log(new Date())
  MyCoLogs.error(new Error('Ooops'))
}, 500)

Yo hice un tipo libreria de consola en donde el primer parametro pones el color que gustes y en el segundo el mensaje

const fs = require("fs");
const colors = require("./consoleColor.json");

const out = fs.createWriteStream("./utils-debuggin/out.log");
const err = fs.createWriteStream("./utils-debuggin/err.log");

const print = new console.Console(out, err);

const verifyColor = (color) => {
  const isColor = Object.keys(colors).filter((co) => co === color);
  if (isColor.length > 0) {
    return true;
  }
  return false;
};

print.color = (color, msg = "") => {
  if (!color) {
    return console.log("Ingresa un color");
  }
  if (!verifyColor(color)) {
    return console.log("El color que ingresaste no es valido");
  }
  console.log(`\x1b${colors[color]}`, msg);
};

print.color("green", "Hola a todos");

Les comparto mis apuntes en el código

// al usar la consola hay algunos parametros sustituibles, que tambien funciona en la consola de node
// %s para strings
// %d para numbers
// %j para JSON
console.log('Un %s y un %s', 'perritu', 'gatitoo');
//podemos ir a la consola  escribir "node", luego hacer uso de un "console.log()"

//funcionan de manera similar al console.log()
console.info('hellow mundo');
console.warn('hellow error');

//enviara un mensaje en consola si el argumento es false
console.assert(true);           //no envia nada
console.assert(false);          //enviara algo
console.assert(42 == '42');     //true
console.assert(42 === '42');    //false

//nos indica exactamente la linea del error
console.trace('La linea exacta es:')   

//util para hacer debug en el proceso de desarrollo
const util = require("util");
const debuglog = util.debuglog('foo');
//en consola: NODE DEBUG=foo node console-utils.js

This is my code of the class!


Buenas, les comparto mi codigo

const logger = new console.Console(process.stdout,process.stderr);

logger.warning = function (str) {
   this.log('\x1b[33;101m', `⚠  ${str} ⚠ `, '\x1b[0m');
}

logger.confirmed = function (str) {
   this.log('\x1b[92m', `✔  ${str} ✔ `,'\x1b[0m');
}

logger.caution = function (str) {
   this.log('\x1b[91m', `‼  ${str} ‼ `,'\x1b[0m');
}


logger.warning('warning test');
logger.caution('caution test');
logger.confirmed('confirmed test');

Y asi es como se ve en la consola

Estuvo bien interesante hacer este reto 😄, aquí les dejo mi solución.

const colors = require("colors");
const moment = require("moment");

const date = moment().format("L");
const myConsole = new console.Console(process.stdout, process.stderr);

myConsole.log = (message) => {
  console.log(`[☺ ${date}] ${message}`.grey);
};

myConsole.info = (message) => {
  console.info(`[ℹ ${date}] ${message}`.cyan);
};

myConsole.warn = (message) => {
  console.warn(`[⚠ ${date}] ${message}`.yellow);
};

myConsole.error = (message) => {
  console.error(`[☠ ${date}] ${message}`.red);
};

myConsole.log("Este es un mensaje de log");
myConsole.info("Este es un mensaje de info");
myConsole.warn("Este es un mensaje de warn");
myConsole.error("Este es un mensaje de error");

Amé el --inspect

Muy buena clase!

Explica como utilizar el debugging con > node --inspect file.js

Acá un ejemplo con el api randomuser

const fs = require('fs');
// const fetch = require('fetch');
const fetch = require('node-fetch');

const out = fs.createWriteStream('./out.log');
const err = fs.createWriteStream('./error.log');

const consoleFile = new console.Console(out, err);

fetch('https://randomuser.me/api/?results=5000')
  .then((response) => {
    return response.json();
  })
  .then((myJson) => {
    consoleFile.log('Bienvenido a la oficina del trabajo, le podemos buscar un empleo, si es que no está juvilado');
    myJson.results.map((user) => {
      const { age } = user.dob;
      const name = user.name.first;
      const { last } = user.name;
      const fullName = `${name} ${last}`;
      if (age <= 60) {
        const message = `${fullName}, tienes la edad requerida (${age}) te encontramos un trabajo`;
        consoleFile.log(message);
      } else {
        const message = `${fullName}, usted tiene ${age} años, ya recibe una pensión, diviértase, ¡no todo en la vida es trabajar!`;
        console.log(new Error(message));
        consoleFile.error(new Error(message));
      }
    });
  });

Esta parte del curso me ha gustado mucho, me agrada mucho node, y la parte de os, en python hay utilidades muy similares, y es sencillo hacer transferencia de conocimiento entre ambos lenguajes

Reto:

`const fs = require(‘fs’);

const COLORS = {
cyan: ‘\x1b[36m%s\x1b[0m’,
yellow: ‘\x1b[33m%s\x1b[0m’,
red: “\x1b[31m”,
white: “\x1b[37m”
}

const ICONS = {
err: ‘💥’,
log: ‘✨’,
info: ‘🗣’,
warn: ‘👀’
}

const LOGDIR = ${__dirname}/log;

const selectType = (type) => {
let color, icon;
switch (type) {
case ‘info’:
color = COLORS.cyan;
icon = ICONS.info;
break;
case ‘warn’:
color = COLORS.yellow;
icon = ICONS.warn;
break;
case ‘err’:
color = COLORS.red;
icon = ICONS.err;
break;
default:
color = COLORS.white;
icon = ICONS.log;
}

return { color, icon };

}

class CustomConsole {
constructor() {
fs.mkdir(LOGDIR, (err) => {
if (err.code !== ‘EEXIST’) console.log(err);
});
const out = fs.createWriteStream(${LOGDIR}/out.log, {flags:‘a’});
const err = fs.createWriteStream(${LOGDIR}/err.log, {flags:‘a’});
this.consoleSave = new console.Console(out, err);
}

__log(message, options) {
    const { save, type } = options;
    const { color, icon } = selectType(type);
    console.log(color, `${icon}  ${message}`);
    if (!save) return;
    const header = `${type.toUpperCase()} - ${new Date()}`
    if (type == 'err') {
        this.consoleSave.error(header);
        this.consoleSave.error(message)
    } else {
        this.consoleSave.log(header);
        this.consoleSave.log(message)
    }
}

log(message, options = {}) {
    options.type = 'log';
    this.__log(message, options);
}

info(message, options = {}) {
    options.type = 'info';
    this.__log(message, options);
}

warn(message, options = {}) {
    options.type = 'warn';
    this.__log(message, options);
}

error(message, options = {}) {
    options.type = 'err';
    this.__log(message, options);
}

};

const customConsole = new CustomConsole();
customConsole.log(‘Este es un mensaje de Log’);
customConsole.error(‘Este es un mensaje de Error’);
customConsole.warn(‘Este es un mensaje de Advertencia’);
customConsole.info(‘Este es un mensaje de Informacion’);

customConsole.log(‘Este es un mensaje de Log’, { save: true });
customConsole.error(‘Este es un mensaje de Error’, { save: true });
customConsole.warn(‘Este es un mensaje de Advertencia’, { save: true });
customConsole.info(‘Este es un mensaje de Informacion’, { save: true });`

console-utils.js

placeholders para formatear nuestros datos

%s = string
%d = número
%j = json

Usar node -- inspect scritp.js

Node como modulo nativo nos ofrece el modulo de console, que suele ser muy útil para hacer un debugging básico de nuestro código y conocer funcionalidades de nuestro codigo.
Para realizar un buen debugging de nuestro código, podemos utilizar el comando node --inspect. El cual nos abrirá un navegador con la consola para debuggear de una manera mas avanzada y practica para nosotros.

Reto:

const { Writable } = require('stream');

const stdout = new Writable({
    write(chunk) {
        process.stdout.write(chunk.toString());
    }
});

const customConsole = new console.Console(stdout);

customConsole.log('Hello world');
const consolaPerso = new console.Console(process.stdout, process.stderr);

let fecha = new Date();

consolaPerso.infoP = (msg = '') => {
    console.info('|INFO| - ', msg, ' ', fecha);
}

consolaPerso.doneP = (msg = '') => {
    console.info('|SUCESS| - ', msg, ' ', fecha);
}

consolaPerso.errorP = (msg = '') => {
    console.info('|ERROR| - ', msg, ' ', fecha);
}

consolaPerso.infor('Hola mundo');```
const fs = require('fs');
const moment = require('moment'); // libreria para manejar dates
const colors = require('colors/safe'); // libreria para agregar color a los mensajes en la terminal

const logger = new console.Console({stdout: process.stdout, stderr: process.stderr, colorMode: true});

logger.log = (msg = '\n') => {
    console.log(colors.bgCyan.black('[%s -- INFO] ---> %s'), moment().format('YYYY-MM-DD HH:mm:ss'), msg);
}

logger.warn = (msg = '\n') => {
    console.log(colors.bgYellow.black('[%s -- WARNING] ---> %s'), moment().format('YYYY-MM-DD HH:mm:ss'), msg);
}

logger.error = (msg = '\n') => {
    console.log(colors.bgRed.black('[%s -- ERROR] ---> %s'), moment().format('YYYY-MM-DD HH:mm:ss'), msg);
}

logger.log('Hello world, its only info');
logger.warn('Hello world, caution, there is a warning...');
logger.error('Hello world, Houston, there is a problem!');

%s como c++.

const os = require('os');

let colorBlue = "\x1b[34m"
let colorYellow = "\x1b[33m"
let colorGreen = "\x1b[32m"
let colorRed = '\x1b[31m';

const consoleFile = new console.Console(process.stdout, process.stderr);

consoleFile.info = (nombre, apellido, edad) => {
    console.info(`${colorBlue} Hola: ${nombre} ${apellido}, tienes ${edad}`)
}

consoleFile.log = (plat) => {
    console.info(`${colorGreen} Bienvenido a ${plat}`)
}

consoleFile.error = (dato) => {
    if(dato !== 42){
        console.error(`${colorRed} ${dato} no es igual a 42`)
    }
}

consoleFile.warn = () => {
    console.warn(`${colorYellow} El sistema operativo que esta utilizando es: ${os.type()}`)
}

consoleFile.info('Diego','Reyes',21)
consoleFile.log('Platzi')
consoleFile.error(3)
consoleFile.warn();

Bueno hice algo básico pero funcional, gracias a @Juan Diego Reyes Zepeta aprendí los Colores ANSI:

const { Console } = require('console');

const colorBlue = "\x1b[34m";
const colorRed = "\x1b[31m";
const colorYellow = "\x1b[33m";

const NEW_CONSOLE = new Console(process.stdout, process.stderr);

NEW_CONSOLE.log = (message) => {
  console.log(`%s: %s`, Date().toString(), message);
}

NEW_CONSOLE.info = (message => {
  console.info('%s%s: %s', colorBlue, Date().toString(), message)
});

NEW_CONSOLE.error = (message => {
  console.error('%s%s: %s', colorRed, Date().toString(), message);
});

NEW_CONSOLE.warn = (message => {
  console.warn('%s%s: %s', colorYellow, Date().toString(), message);
});

module.exports = NEW_CONSOLE;

Challenge:

const { Console } = require('console');

const myConsole = new console.Console( {
  stdout: process.stdout,
  stderr: process.stderr,
} );

const colors = {
  log: '\x1b[37m ✅',
  info: '\x1b[34m',
  error: '\x1b[31m ❌',
  warn: '\x1b[33m ⚠️',
}

Console.prototype.lo = function (text) {
  this.log(`${colors.log} ${text}`);
};

Console.prototype.in = function (text) {
  this.log(`${colors.info}ℹ️ ${text}`);
};

Console.prototype.wa = function (text) {
  this.log(`${colors.warn} ${text}`);
};

Console.prototype.err = function (text) {
  this.log(`${colors.error} ${text}`);
};

myConsole.lo('This is ');
myConsole.in('This is ');
myConsole.wa('This is ');
myConsole.err('This is ');```
// console.log works with a util-format that means:
// %s -> String
// %d -> Number
// %j -> JSON
// Small placeholders to format our data
console.log("Mi %s tiene %d años", "perro", 5)

// Alias del "console.log"
console.info("Hello World")

// Alias del "console.error"
console.warn("Hello error")

// if there´s an error, it shows us that there´s
// an error in a boolean or in a verification
// console.assert()

// Examples
console.assert(42 == "42") // it shows nothing
console.assert(42 === "42") // it shows a failure

// it indicates the lines where the error is located
console.trace("Hello error line")


// A DEBUG_LOG "CALL":

// Requiring the utility
const util = require('util')

// Invoking the "debugLog" calling:
const debugLog = util.debuglog("foo") // This is very similar to how it works the Express package
// New debugging with a namespace of "foo" (It´s the parameter)

debugLog("Hello from foo")
// To print the previous line, we need to pass our ENV variable
// in the terminal as:
// $ NODE_DEBUG=foo node YOUR_FILE.js


Pongo como se utilizaría la clase console.Console como base para crear un nuevo comando con log. Debemos extender la clase y luego modificar los métodos que deseemos. Podemos ayudarnos de las funciones de la clase padre con “super”. Podríamos también cambiar el stream de escritura por uno propio.


class Logger extends console.Console {
    constructor() {
        super(process.stdout)
    }
    log(msg) {
        msg = `L -> ${msg}`
        super.log(msg)
    }
    error(msg) {
        msg = `E -> ${msg}`
        super.log(msg)
    }
}

let logger = new Logger();

logger.log("Un log normal")
logger.error("Un error")

Mi reto inspirado en los compañeros…

const consoleIcons = new console.Console({
    stdout: process.stdout,
    stderr: process.stderr
});

const icons = {
    nerd: '\x1b[34m\n ----------Nerd Log----------\n🤓',
    monocle: '\x1b[31m\n ----------Nerd Error----------\n🧐'
}

console.Console.prototype.nerd = function(text){
    this.log(`${icons.nerd} ${text}\n ----------------------------`)
}

console.Console.prototype.monocle = function(text){
    this.error(`${icons.monocle} ${text}\n ----------------------------`);
}

consoleIcons.nerd('Veamos que hace esto!');
consoleIcons.monocle('Nos equivocamos!');```

Custom console

const fs = require("fs");

const out = fs.createWriteStream("./out.log");
const error = fs.createWriteStream("./error.log");

const consoleFile = new console.Console(out, error);

const customConsole = new console.Console(out, error);

customConsole.log = (message) => {
  consoleFile.log(`%c 📄 Logger: ${message}`, "color: #00ff00;");
};

customConsole.error = (message) => {
  consoleFile.error(`Error: ${message}`);
};

customConsole.info = (message) => {
  consoleFile.info(` 🗨 Info: ${message}`);
};

customConsole.warn = (message) => {
  consoleFile.warn(` ⚠ Warning: ${message}`);
};

setInterval(() => {
  customConsole.log("Test Message");

  customConsole.error("Test error");

  customConsole.info("Test info");

  customConsole.warn("Test warning");
}, 2000);

Si tienen problemas para hacer el debug en chrome, intenten aumentando el setTimeout.

![](

const miConsole = new console.Console(process.stdout, process.stderr);

miConsole.info = (msg = "") => {
    console.info( "\x1b[34m", "[Information]:", msg)
};

miConsole.warning = (msg = "") => {
    console.warn( "\x1b[33m", "[Warning]:", msg)
};

miConsole.error = (msg = "") => {
    console.error("\x1b[31m", "[Error]:", msg)
};




miConsole.info("Hello");
miConsole.warning("Hello");
miConsole.error("Hello");
➜  utilidades_debugging node mi-console.js
 [Information]: Hello
 [Warning]: Hello
 [Error]: Hello
➜  utilidades_debugging

Reto

const fs = require('fs')
const output = fs.createWriteStream('./chOut.log')
const error = fs.createWriteStream('./chErr.log')

const date = new Date()
const challengeConsole = new console.Console(output, error)

challengeConsole.sucess = (element) => {
    challengeConsole.log(`Logger created on ${date} : ${element}`)
    console.log("\x1b[36m%s\x1b[0m", `☑️  Esta parte  se completado success: ${element}`)
}
challengeConsole.warning = (element = '!!!') => {
    challengeConsole.log(`Warning created on ${date} : ${element}`)
    console.log("\x1b[33m%s\x1b[0m", `⚠️  Esta parte ha generado alert warning : ${element}`)
}

challengeConsole.err = (error = '...') => {
    challengeConsole.error('Ha ocurrido un error')
    console.log("\x1b[31m%s\x1b[0m", `❌  Ha ocurrido un error : ${error}`)
}

challengeConsole.sucess('Hello Word')
challengeConsole.warning()
challengeConsole.err()

Solucion

Mi reto usando Chalk

const chalk = require("chalk")

const consoleCustom = new console.Console(process.stdout, process.stderr)

let msg= "";
let error= "";
consoleCustom.log = (msg) =>{
    console.log(chalk.blue(`Este es el log custom ${msg}`))
}

consoleCustom.info = (msg) =>{
    console.log(chalk.yellow(`Este es el info custom ${msg}`))
}

consoleCustom.warn= (msg) =>{
    console.log(chalk.red(`Este es el warning custom ${msg}`))
}

consoleCustom.error= (error) =>{
    console.log(chalk.bgRed.white(`Este es el error custom ${chalk.underline.bgWhite.red(error)}`))
}
consoleCustom.log("Hola")
consoleCustom.info("Hola")
consoleCustom.warn("Hola")
consoleCustom.error("Hola")

😃

Practica, mucha practica!

Esta clase esta genial