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:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

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 鈥渃onsole鈥:

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(鈥榝s鈥);

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: 鈥橉煑b,
warn: 鈥橉煈鈥
}

const LOGDIR = ${__dirname}/log;

const selectType = (type) => {
let color, icon;
switch (type) {
case 鈥榠nfo鈥:
color = COLORS.cyan;
icon = ICONS.info;
break;
case 鈥榳arn鈥:
color = COLORS.yellow;
icon = ICONS.warn;
break;
case 鈥榚rr鈥:
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 !== 鈥楨EXIST鈥) console.log(err);
});
const out = fs.createWriteStream(${LOGDIR}/out.log, {flags:鈥榓鈥檥);
const err = fs.createWriteStream(${LOGDIR}/err.log, {flags:鈥榓鈥檥);
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(鈥楨ste es un mensaje de Log鈥);
customConsole.error(鈥楨ste es un mensaje de Error鈥);
customConsole.warn(鈥楨ste es un mensaje de Advertencia鈥);
customConsole.info(鈥楨ste es un mensaje de Informacion鈥);

customConsole.log(鈥楨ste es un mensaje de Log鈥, { save: true });
customConsole.error(鈥楨ste es un mensaje de Error鈥, { save: true });
customConsole.warn(鈥楨ste es un mensaje de Advertencia鈥, { save: true });
customConsole.info(鈥楨ste 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 鈥渟uper鈥. 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