Paquetes de nodos útiles que quizás no conozca

Algunos de ustedes, los 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 que...

Introducción

Algunos de ustedes, los 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 yo. Tiendo a olvidar que hay tantos paquetes disponibles, así que exploré un poco y jugué con algunos. Estos son algunos de mis favoritos.

yargos

El paquete yargos es simple y directo, y le evitará tener que escribir código repetitivo 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 valores booleanos, números de coma 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.

1
2
3
4
5
6
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 intentáramos ejecutar el script con solo node index.js -x 3, recibiríamos este mensaje:

1
2
3
4
5
6
7
Usage: index.js -x [num] -y [num]

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

Missing required argument: y

yargs es lo suficientemente amable como para decirnos qué es exactamente lo que nos falta en un mensaje bien formateado, y todo lo que tuvimos que hacer fue usar los métodos simples .usage() y .demand(). Casi todos los paquetes podrían usar esto.

demasiado ocupado

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

Funciona sondeando el bucle de eventos del nodo y rastrea el 'retraso', que es el tiempo que tardan en cumplirse las solicitudes. Si el retraso es demasiado largo, entonces demasiado ocupado se lo hará saber, lo que le permitirá devolver un código HTTP 503 "Servicio no disponible" al cliente.

Esto es importante porque cuanto más ocupado esté su servidor, más largos serán los tiempos de espera. Esto se convierte rápidamente en un problema agravante 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, al menos algunas solicitudes serán atendidas. Mejor algunos que ninguno, ¿verdad?

Puedes usar toobusy instalándolo:

1
npm install toobusy

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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 requiere 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

Al igual que toobusy, realmente no me di cuenta de la utilidad de tiza hasta que realmente me tomé un tiempo para pensarlo y ver dónde había visto solía. 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 única entrada de texto. Entonces, ¿cómo consigues que la información importante se destaque? Una de las mejores maneras 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, por lo que nunca se perderá algo crítico.

Aquí está la lista completa de todos los diferentes tipos de estilo que admite chalk:

Modificadores
  • negrita
  • subrayado
  • tenue
  • restablecer
  • oculto
  • inversa
  • cursiva (no compatible en todas partes)
  • tachado (no soportado en todas partes)
Colores
  • rojo
  • ’negro'
  • verde
  • blanco
  • amarillo
  • blue (en Windows se usa una versión más brillante ya que el azul normal es ilegible)
  • cian
  • ‘gris’
  • magenta
Colores de fondo
  • bgAzul
  • bgBlack
  • bgRojo
  • bgVerde
  • bgCian
  • bgAmarillo
  • bgBlanco
  • bgMagenta

Si bien estos son los únicos colores admitidos oficialmente, cualquier terminal compatible con xterm puede usar 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. Por lo tanto, si desea que el usuario vea un error crítico, es posible que desee agregar un formato como este:

1
2
3
4
var chalk = require('chalk');

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

inspector de nodos {#inspector de nodos}

Los buenos depuradores pueden ser difíciles de encontrar, especialmente los que tienen GUI fáciles de usar, por lo que soy un gran admirador de [inspector de nodos] (https://www.npmjs.com/package/node-inspector) . Este depurador funciona mostrándole una GUI de página web para depurar su código. Tiene todas las funciones 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, la inspección de solicitudes de clientes de red y la capacidad de editar código en ejecución en vivo. Esta última función es una de mis favoritas, ya que te ahorrará mucho tiempo.

node-inspector

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 que se hizo 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 literalmente me ha ahorrado horas de tiempo 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 ejemplo.

kit de terminal {#kit de terminal}

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 estar usando kit de terminal. 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 terminal-kit son:

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

Hay bastantes casos de uso que se aplican a terminal-kit. 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 tienes que hacer algo como esto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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 fue tomado del terminal-kit README:

terminal-kit progress bar

validador

El paquete validador 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 recibe información de un usuario. Casi puedes pensar en tu usuario como la mayor amenaza para tu 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 por usted y evitar la corrupción de datos o fallas del servidor.

Algunos de los validadores más útiles son:

  • isEmail(cadena [, opciones])
  • isIP(cadena [, versión])
  • isMobilePhone(cadena, configuración regional)
  • isURL(cadena [, opciones])

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:

  • lista negra (entrada, caracteres)
  • escape (entrada)
  • normalizeEmail(correo electrónico [, opciones])
  • lista blanca (entrada, caracteres)

El método normalizeEmail() 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 tenía el correo electrónico [correo electrónico protegido], normalizeEmail() lo normalizará a [correo electrónico protegido] ya que GMail ignora los puntos (.) y las etiquetas.

formidable

Una de las tareas más difíciles que he abordado en el pasado fue manejar la carga de archivos, razón por la cual formidable apareció en 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 de gran tamaño, muchas sí permiten imágenes de perfil, lo que significa que debe recibir la imagen, validarla y escribirla en el disco, lo que puede no ser una tarea fácil. dependiendo de 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 muy bien.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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 == '/') {
    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:\n\n' + 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:\n\n ' + 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 + '/');

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 necesita escribir tanto bash * como * scripts por lotes para sus proyectos. shelljs le brinda un entorno similar a Unix para 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:

1
2
3
4
5
6
7
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);
});

Ejecutar comandos comunes:

1
2
3
4
require('shelljs/global');

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

Compruebe los binarios disponibles:

1
2
3
4
5
6
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:

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

Conclusión

Esperamos que a partir de 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 (al 1/10/15) en npmjs.com, por lo que lo que esté buscando probablemente esté allí.

¿Cuál es tu paquete 'desconocido' favorito? ¡Cuéntanos en los comentarios! tarios!*