Paquetes de nodes útiles que quizás no conozca

P

Introducción

Algunos de ustedes, veteranos de Node, probablemente hayan oído hablar de algunos de estos paquetes antes, pero espero que en este artículo encuentren algunos realmente útiles de los que nunca habían oído hablar, como lo hice yo. Tiendo a olvidar que hay tantos paquetes por ahí, así que exploré un poco y jugué con algunos. Estos son algunos de mis favoritos.

yargs

los yargs El paquete es simple y directo, y le evitará tener que escribir código de caldera en todos sus proyectos. Maneja los argumentos de la línea de comandos por usted, por lo que el usuario puede establecer indicadores e ingresar cualquier tipo de datos, incluidos booleanos, números de punto flotante y cadenas.

yargs incluso manejará su salida de ‘uso’, por lo que puede decirle fácilmente al usuario qué opciones toma su programa, incluidas cuáles son necesarias.

var argv = require('yargs')
    .usage('Usage: $0 -x [num] -y [num]')
    .demand(['x','y'])
    .argv;
 
console.log('Pow(x, y):', Math.pow(argv.x, argv.y));

Entonces, usando el código anterior, si intentamos ejecutar el script con solo node index.js -x 3, entonces obtendríamos este mensaje:

Usage: index.js -x [num] -y [num]

Options:
  -x                                                                  [required]
  -y                                                                  [required]

Missing required argument: y

yargs es lo suficientemente bueno como para decirnos qué es exactamente lo que nos falta en un mensaje con un formato agradable, y todo lo que tuvimos que hacer fue usar el simple .usage() y .demand() métodos. Casi todos los paquetes podrían usar esto.

demasiado ocupado

Este fue uno de esos paquetes con los que, ciertamente, no me impresionó demasiado al principio, pero rápidamente me di cuenta de lo útil que podía ser.

Funciona sondeando el bucle de eventos del node y rastrea el ‘retraso’, que es el tiempo que tardan en cumplirse las solicitudes. Si el retraso se vuelve demasiado largo, entonces toobusy le informará, lo que le permitirá devolver un código HTTP 503 “Servicio no disponible” al cliente.

Esto es importante porque cuanto más ocupado se vuelve su servidor, más largos se vuelven los tiempos de espera. Esto se convierte rápidamente en un problema agravado que solo empeorará con el paso del tiempo. Si no hace nada, el servicio se cerrará (también conocido como bloqueo) para todos. Pero si detiene el procesamiento antes de tiempo para devolver HTTP 503, se atenderán al menos algunas solicitudes. Mejor algunos que ninguno, ¿verdad?

Puedes usar toobusy instalándolo:

npm install toobusy

Y luego integrándolo con algo como Express como esto:

var toobusy = require('toobusy'),
    express = require('express');
    
var app = express();
    
// Block requests if we get too busy 
app.use(function(req, res, next) {
	if (toobusy()) {
		res.send(503, "Too many users!");
	} else {
		next();
	} 
});
  
var server = app.listen(3000);
  
process.on('SIGINT', function() {
	server.close();

	toobusy.shutdown();	// Allow us to exit normally

	process.exit();
});

Realmente no se necesita tanto código, e incluso menos configuración, por lo que podría empaquetarlo fácilmente en un buen middleware e incluirlo en todos sus proyectos Express. Solo asegúrese de no cortar ninguna solicitud crítica que tenga alta prioridad o solicitudes que contengan datos críticos.

tiza

Me gusta toobusy, Realmente no me di cuenta de la utilidad de chalk hasta que realmente me tomé un tiempo para pensar en ello y en dónde lo he visto usar. Las interfaces de usuario en la línea de comandos son muy difíciles de crear, ya que todo lo que tiene para interactuar con el usuario es una ventana para mostrar texto y una sola entrada de texto. Entonces, ¿cómo consigues que la información importante se destaque? Una de las mejores formas es agregar formato a su texto. Express es un buen ejemplo de esto. A partir de su salida, puede encontrar fácilmente la información más importante de inmediato, para que nunca se pierda algo importante.

Aquí está la lista completa de todos los diferentes tipos de estilos que chalk apoya:

Modificadores
  • bold
  • underline
  • dim
  • reset
  • hidden
  • inverse
  • italic (no admitido en todas partes)
  • strikethrough (no admitido en todas partes)
Colores
  • red
  • black
  • green
  • white
  • yellow
  • blue (en Windows se usa una versión más brillante ya que el azul normal es ilegible)
  • cyan
  • gray
  • magenta
Colores de fondo
  • bgBlue
  • bgBlack
  • bgRed
  • bgGreen
  • bgCyan
  • bgYellow
  • bgWhite
  • bgMagenta

Si bien estos son los únicos colores admitidos oficialmente, cualquier terminal compatible con xterm puede utilizar los códigos de color completos de 8 bits.

Para formatear algún texto, solo tiene que pasar la cadena a través de una función para colorear o formatear. Entonces, si desea que el usuario vea un error crítico, es posible que desee agregar algún formato como este:

var chalk = require('chalk');

var str = chalk.red.bold('ERROR: ') + chalk.bold('Everything just blew up...');
console.log(str);

inspector de nodes

Los buenos depuradores pueden ser difíciles de encontrar, especialmente aquellos con GUI fáciles de usar, por eso soy un gran admirador de inspector de nodes. Este depurador funciona mostrándole una GUI de página web para depurar su código. Tiene todas las características de un depurador estándar, como puntos de interrupción, entrada y salida del código e inspección de variables. También tiene algunas características no tan comunes que son realmente útiles, como la creación de perfiles de CPU y montón, inspección de solicitudes de clientes de red y la capacidad de editar en vivo el código en ejecución. Esta última característica es una de mis favoritas, ya que le permitirá ahorrar mucho tiempo.

Tenga en cuenta que Node Inspector solo es compatible con Chrome y Opera, ya que utiliza Blink Developer Tools, que es la interfaz del depurador de JavaScript que ve y compatible con Node.

Durante mucho tiempo confié bastante en el uso de la consola para generar mi información de depuración, lo que terminó tomando mucho tiempo para agregar, editar y eliminar mis declaraciones de depuración. El uso de la GUI me ha ahorrado literalmente horas de depuración. Ahora, los depuradores no son nada nuevo, pero algunos son mucho más difíciles de usar que otros, y este es un buen método.

terminal-kit

Si su aplicación Node usa la línea de comando para algo más que una simple entrada / salida de texto, entonces probablemente debería usar terminal-kit. terminal-kit simplifica muchos de los aspectos de la interacción con los usuarios para que pueda concentrarse en desarrollar las cosas importantes dentro de su aplicación. Algunas cosas que hace el terminal-kit son:

  • estilo de texto (muy parecido a chalk)
  • editar la pantalla
  • barras de progreso
  • entrada del usuario

Hay bastantes casos de uso que se aplican al kit de terminal. Como, por ejemplo, si descarga algo de Internet, sería útil mostrar una barra de progreso al usuario para que sepa que la aplicación no se ha estancado. Para mostrar una barra de progreso ficticia, solo tiene que hacer algo como esto:

var terminal = require( 'terminal-kit' ).terminal;

var progressBar;
var progress = 0;

function updateProgress() {
    // Add random progress
    progress += Math.random() / 10;
    progressBar.update(progress);
    
    // Check if we're done
    if (progress >= 1) {
        setTimeout(function() {
        	terminal('n');
        	process.exit();
        }, 250);
    }
    else {
        setTimeout(updateProgress, 100 + Math.random() * 500);
    }
}

progressBar = terminal.progressBar({
    width: 80,
    title: 'Downloading file:',
    eta: true,
    percent: true
});

updateProgress();

El código anterior producirá algo como esto, que se tomó del README del kit de terminal:

validador

los validator El paquete ayuda con un montón de validaciones de cadenas comunes (como direcciones de correo electrónico, tarjetas de crédito, direcciones IP, etc.). Un paquete como este es esencial para cada vez que reciba información de un usuario. Casi puede pensar en su usuario como la mayor amenaza para su producto. Cometerán errores e ingresarán algunas cosas realmente extrañas en los cuadros de texto, por lo que necesita un paquete probado para validar la entrada y evitar la corrupción de datos o fallas del servidor.

Algunos de los validadores más útiles son:

  • isEmail(str [, options])
  • isIP(str [, version])
  • isMobilePhone(str, locale)
  • isURL(str [, options])

validator también tiene desinfectantes, que pueden normalizar, eliminar o escapar de sus cadenas de entrada. Por ejemplo, es posible que desee desinfectar el comentario de un usuario para evitar que ingrese HTML / JavaScript malicioso. Este es uno de los casos de uso más comunes, ya que es muy fácil para un atacante crear un bot para probar este ataque en miles de sitios.

Algunos desinfectantes útiles proporcionados por validator son:

  • blacklist(input, chars)
  • escape(input)
  • normalizeEmail(email [, options])
  • whitelist(input, chars)

los normalizeEmail() El método es interesante. Se asegurará de que una dirección de correo electrónico esté en minúsculas e incluso eliminará los caracteres ignorados del nombre de usuario de las direcciones de GMail. Entonces, si tuvieras el correo electrónico [email protected], normalizeEmail() lo normalizará a [email protected] dado que GMail ignora los puntos (.) y etiquetas.

formidable

Una de las tareas más difíciles que he abordado en el pasado fue manejar la carga de archivos, por lo que formidable hizo la lista. formidable maneja cada parte de la carga, incluido el analizador de varias partes, la escritura de archivos en el disco y el manejo de errores. Aunque muchas aplicaciones web no permiten que el usuario cargue imágenes y videos enormes, muchas sí permiten imágenes de perfil, lo que significa que debe manejar la recepción de la imagen, validarla y escribirla en el disco, lo que puede no ser una tarea fácil dependiendo en sus limitaciones.

Este es uno de esos paquetes de los que soy un gran admirador porque realmente no quiero reinventar la rueda. Hace un trabajo y lo hace realmente bien.

Aquí hay un ejemplo usando formidable con solo un servidor HTTP simple, modificado de un ejemplo dado en el paquete mismo:

var http = require('http');
var util = require('util');
var formidable = require('formidable');
var path = require('path');

var PORT = 8080;

var root = path.join(__dirname, '../');
exports.dir = {
	root    : root,
	lib     : root + '/lib',
	fixture : root + '/test/fixture',
	tmp     : root + '/test/tmp',
};

var server = http.createServer(function(req, res) {
  if (req.url == "https://Pharos.sh.com/") {
    res.writeHead(200, {'content-type': 'text/html'});
    res.end(
      '<form action="/post" method="post">' +
      '<input type="text" name="title"><br>' +
      '<input type="text" name="data[foo][]"><br>' +
      '<input type="submit" value="Submit">' +
      '</form>'
    );
  } else if (req.url == '/post') {
    var form = new formidable.IncomingForm(),
        fields = [];

    form
      .on('error', function(err) {
        res.writeHead(200, {'content-type': 'text/plain'});
        res.end('error:nn' + util.inspect(err));
      })
      .on('field', function(field, value) {
        console.log(field, value);
        fields.push([field, value]);
      })
      .on('end', function() {
        console.log('-> post done');
        res.writeHead(200, {'content-type': 'text/plain'});
        res.end('received fields:nn ' + util.inspect(fields));
      });
    form.parse(req);
  } else {
    res.writeHead(404, {'content-type': 'text/plain'});
    res.end('404');
  }
});

server.listen(PORT);

console.log('listening on http://localhost:' + PORT + "https://Pharos.sh.com/");

shelljs

shelljs es un paquete que le permite usar comandos comunes de Unix en cualquier sistema, ya sea Windows, Linux o Mac. De esta manera, no es necesario que escriba scripts bash y batch para sus proyectos. shelljs le ofrece un entorno similar a Unix con el que trabajar, por lo que si escribe scripts para ejecutar pruebas, confirmar cambios o iniciar en un servidor, solo tiene que escribirlo una vez.

Puede hacer cosas como actuar en la salida del comando:

require('shelljs/global');

ls('*.js').forEach(function(file) {
	sed('-i', 'BUILD_VERSION', 'v2.0.3', file);
	sed('-i', /.*REMOVE_THIS_LINE.*n/, '', file);
	sed('-i', /.*REPLACE_THIS_LINE.*n/, cat('macro.js'), file);
});

Ejecute comandos comunes:

require('shelljs/global');

mkdir('-p', 'release/data');
cp('-R', 'data/*', 'release/data');

Compruebe los binarios disponibles:

require('shelljs/global');

if (!which('git')) {
	echo('This script requires git!');
	exit(1);
}

E incluso ejecute comandos nativos como lo haría en un script bash / batch real:

if (exec('git commit -am "Release commit"').code !== 0) {
  echo('Error: Git commit failed!');
  exit(1);
}

Conclusión

Es de esperar que en este artículo haya encontrado algunas herramientas útiles de las que nunca ha oído hablar, o tal vez se haya dado cuenta de lo útiles que pueden ser algunos de estos paquetes. Una búsqueda rápida o simplemente navegar por algunos proyectos de código abierto puede dar como resultado algunos buenos hallazgos, así que mantén los ojos abiertos. Hay más de 190.000 paquetes (a partir del 1/10/15) en npmjs.com, así que lo que esté buscando probablemente esté allí.

¿Cuál es tu paquete “desconocido” favorito? ¡Háznoslo saber en los comentarios!

 

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias para su correcto funcionamiento. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad