Paquetes de nodes √ļtiles que quiz√°s no conozca

    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!

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *