Argumentos de la línea de comandos en Node.js

    ¬ŅQu√© son los argumentos de la l√≠nea de comandos?

    Los argumentos de la línea de comandos son cadenas de texto que se utilizan para pasar información adicional a un programa cuando se ejecuta una aplicación a través del interfaz de línea de comandos (CLI) de un sistema operativo. Los argumentos de la línea de comandos suelen incluir información que se utiliza para establecer la configuración o los valores de propiedad de una aplicación.

    En la mayoría de los casos, los argumentos se pasan después del nombre del programa en su indicador. Un ejemplo de la sintaxis de los argumentos de la línea de comandos se ve así:

    $ [runtime] [script_name] [argument-1 argument-2 argument-3 ... argument-n]
    

    Aqu√≠ el tiempo de ejecuci√≥n puede ser cualquier cosa que ejecute un programa / script, por ejemplo sh, java, node, etc. Los argumentos suelen estar separados por un espacio; sin embargo, hay algunos tiempos de ejecuci√≥n que utilizan comas para distinguir entre varios argumentos de la l√≠nea de comandos. Adem√°s, seg√ļn el programa, puede pasar argumentos en forma de pares clave-valor, que veremos m√°s adelante en este art√≠culo.

    ¬ŅPor qu√© utilizar argumentos de l√≠nea de comandos?

    Los siguientes son algunos de los principales beneficios de usar argumentos de línea de comando:

    • Puede pasar informaci√≥n a una aplicaci√≥n antes de que comience. Esto es particularmente √ļtil si desea realizar ajustes de configuraci√≥n de gran n√ļmero.
    • Los argumentos de la l√≠nea de comandos se pasan como cadenas a su programa. Los tipos de datos de cadena se pueden convertir f√°cilmente a otros tipos de datos dentro de una aplicaci√≥n, lo que hace que los argumentos sean muy flexibles.
    • Puede pasar un n√ļmero ilimitado de argumentos a trav√©s de la l√≠nea de comando.
    • Los argumentos de la l√≠nea de comandos se utilizan junto con scripts y archivos por lotes, lo que es particularmente √ļtil para las pruebas automatizadas.

    Y estas son algunas de las desventajas de usarlas:

    • La mayor desventaja de pasar informaci√≥n a trav√©s de la l√≠nea de comandos es que la interfaz tiene una curva de aprendizaje pronunciada, por lo que es dif√≠cil de usar para la mayor√≠a de las personas a menos que tengan mucha experiencia en el uso de herramientas CLI.
    • Las aplicaciones de l√≠nea de comandos pueden ser dif√≠ciles de usar a menos que est√© usando una computadora de escritorio o port√°til, por lo que normalmente no se usan en dispositivos m√°s peque√Īos como tel√©fonos o tabletas.

    Pasando argumentos de línea de comando en Node.js

    Como muchos otros lenguajes, las aplicaciones de Node.js tambi√©n aceptan argumentos de l√≠nea de comando. Por defecto, Node se encargar√° de aceptar los argumentos por usted, pero tambi√©n hay algunos paquetes de terceros excelentes que agregan algunas caracter√≠sticas muy √ļtiles.

    En esta sección, le mostraremos cómo usar argumentos a través de la forma incorporada (process.argv), así como con los populares paquetes minimist y yargs.

    Usando process.argv

    La forma más sencilla de recuperar argumentos en Node.js es a través del process.argv formación. Este es un objeto global que puede usar sin importar bibliotecas adicionales para usarlo. Simplemente necesita pasar argumentos a una aplicación Node.js, tal como mostramos anteriormente, y se puede acceder a estos argumentos dentro de la aplicación a través del process.argv formación.

    El primer elemento del process.argv La matriz siempre será una ruta del sistema de archivos que apunta al node ejecutable. El segundo elemento es el nombre del archivo JavaScript que se está ejecutando. Y el tercer elemento es el primer argumento que realmente pasó el usuario.

    Para evitar confusiones, me gustar√≠a recordarles a los principiantes que JavaScript usa √≠ndices de base cero en matrices (como muchos otros lenguajes), lo que significa que el primer elemento se almacenar√° en el √≠ndice “0” y el √ļltimo elemento se almacenar√° en √ćndice “n-1”, donde “n” es el n√ļmero total de elementos de la matriz.

    Ahora escribamos un script de node simple que imprima todos los argumentos de la l√≠nea de comando pasados ‚Äč‚Äča la aplicaci√≥n, junto con su √≠ndice. Copie y pegue el siguiente c√≥digo en un archivo llamado “processargv.js”.

    'use strict';
    
    for (let j = 0; j < process.argv.length; j++) {
        console.log(j + ' -> ' + (process.argv[j]));
    }
    

    Todo lo que hace este script es recorrer el process.argv array e imprime los √≠ndices, junto con los elementos almacenados en esos √≠ndices. Es muy √ļtil para depurar si alguna vez te preguntas qu√© argumentos est√°s recibiendo y en qu√© orden.

    Ahora, para ejecutar esto, escriba el siguiente comando. Solo aseg√ļrese de estar en el directorio donde se guarda el archivo “processargv.js”.

    $ node processargv.js tom jack 43
    

    Aqu√≠ estamos pasando tres argumentos al programa “processargv.js”. Ver√° que “tom” se almacenar√° en el segundo √≠ndice, mientras que “jack” y “43” se almacenar√°n en el tercer y cuarto √≠ndice, respectivamente. La salida deber√≠a verse as√≠:

    $ node processargv.js tom jack 43
    0 -> /Users/scott/.nvm/versions/node/v4.8.0/bin/node
    1 -> /Users/scott/javascript/processargv.js
    2 -> tom
    3 -> jack
    4 -> 43
    

    Puede ver que el primer índice contiene la ruta a nuestro node ejecutable (que probablemente tendrá una ruta diferente a la mía), el segundo índice contiene la ruta al archivo de script y el resto de los índices contienen los argumentos que pasamos en su secuencia respectiva.

    Usando el módulo minimista

    Otra forma de recuperar argumentos de l√≠nea de comando en una aplicaci√≥n Node.js es usando el minimista m√≥dulo. El m√≥dulo minimista analizar√° los argumentos del process.argv array y transformarlo en un array asociativo m√°s f√°cil de usar. En la matriz asociativa puede acceder a los elementos mediante nombres de √≠ndice adem√°s de los n√ļmeros de √≠ndice. Eche un vistazo al siguiente ejemplo.

    'use strict';
    
    const args = require('minimist')(process.argv.slice(2));
    
    console.log(args);
    console.log(args.i);
    

    Guarde el c√≥digo anterior en “minimist.js”. En el c√≥digo anterior usamos el slice m√©todo del process.argv objeto global. los slice En este caso, el m√©todo elimina todos los elementos de la matriz anteriores a partir del √≠ndice que se le pasa como par√°metro. Aqu√≠ sabemos que los argumentos que pasamos manualmente se almacenan a partir del segundo √≠ndice, pasamos 2 a la funci√≥n slice. Luego imprimimos el args objeto. Tambi√©n imprimimos un solo elemento de la matriz usando el √≠ndice nombrado, es decir, “i”, en lugar del n√ļmero de √≠ndice.

    Ahora, cuando pasamos un argumento a este programa, tambi√©n podemos especificar el car√°cter por el cual queremos acceder al elemento. Dado que en el script usamos el nombre del √≠ndice “i” para acceder al elemento, tenemos que especificar el elemento almacenado en este √≠ndice. Eche un vistazo al script para ejecutar el programa anterior.

    $ node minimist.js ‚Äďi jacob ‚Äďj 45
    

    Observe que aqu√≠ especificamos “i” como el nombre del segundo √≠ndice, el valor almacenado en ese √≠ndice es “jacob”. De manera similar, el tercer √≠ndice se denomina “j” y el valor en este √≠ndice es 45. La salida del comando anterior ser√° la siguiente:

    $ node minimist.js -i jacob -j 45
    { _: [], i: 'jacob', j: 45 }
    jacob
    

    Si bien no es tan rico en funciones como algunos de los otros m√≥dulos de an√°lisis de argumentos (consulte yargs a continuaci√≥n), minimist tiene algunas caracter√≠sticas √ļtiles que quiz√°s desee consultar, como aliasing y valores predeterminados.

    Si establece un alias, la persona que llama a su programa puede usar el alias adem√°s del nombre de la opci√≥n normal. Esto es √ļtil si desea tener una notaci√≥n abreviada para sus opciones, como se ve a continuaci√≥n:

    'use strict';
    
    const minimist = require('minimist');
    
    let args = minimist(process.argv.slice(2), {
        alias: {
            h: 'help',
            v: 'version'
        }
    });
    
    console.log('args:', args);
    

    Llamar a este código con el -h la opción establece ambos h: true y help: true en los argumentos de salida:

    $ node minimist-alias.js -h
    args: { _: [], h: true, help: true }
    

    En cuanto a la funci√≥n de valores predeterminados de minimist, si no se pasa ning√ļn valor para una opci√≥n, el valor predeterminado que establezca en su programa se utilizar√° autom√°ticamente.

    'use strict';
    
    const minimist = require('minimist');
    
    let args = minimist(process.argv.slice(2), {
        default: {
            port: 8080
        },
    });
    
    console.log('args:', args);
    

    Llamar a este código sin el -port La opción todavía te da una port valor en el devuelto args objeto:

    $ node minimist-defaults.js
    args: { _: [], port: 8080 }
    

    Para obtener m√°s opciones, consulte el L√ČAME.

    Usando el módulo yargs

    Otro m√≥dulo que le ayudar√° a analizar los argumentos de la l√≠nea de comandos pasados ‚Äč‚Äča los programas de node es el yargs m√≥dulo. Con este m√≥dulo, puede pasar argumentos en forma de pares clave-valor y luego acceder a los valores de los argumentos en su programa usando las claves correspondientes.

    Nota: puede instalar el yargs módulo con el siguiente comando:

    $ npm install yargs
    

    Ahora, eche un vistazo al siguiente script:

    'use strict';
    
    const args = require('yargs').argv;
    
    console.log('Name: ' + args.name);
    console.log('Age: ' + args.age);
    

    En el script anterior mostramos los valores proporcionados para los argumentos ‘nombre’ y ‘edad’, que se pasaron a trav√©s de la l√≠nea de comando. Ahora guarde el script anterior en un archivo llamado “yargs.js”.

    Nota: Cuando ejecuta el programa anterior, debe pasar valores para los argumentos ‘nombre’ y ‘edad’, de lo contrario undefined se proporcionar√° para los argumentos de forma predeterminada y ver√° undefined escrito en la consola.

    Para ejecutar el programa anterior, ejecute el siguiente comando en su indicador:

    $ node yargs.js --name=jacob --age=45
    

    Aquí estamos pasando valores para los argumentos de nombre y edad. La salida del script anterior se verá así:

    $ node yargs.js --name=jacob --age=45
    Name: jacob
    Age: 45
    

    los yargs package es muy poderoso, no solo proporciona las características estándar de análisis de argumentos, sino también muchas características avanzadas. Si bien no repasaremos todas las funciones de este artículo, al menos tocaremos una de sus funciones más populares.

    Una de las formas más poderosas de usar yargs es el .command() , que le ayuda a crear, exponer y llamar funciones de node a través de la línea de comando. Aquí hay un ejemplo simple de esta función en acción:

    'use strict';
    
    const argv = require('yargs')
        .command('upload', 'upload a file', (yargs) => {}, (argv) => {
            console.log('Uploading your file now...');
    
            // Do stuff here
        }).argv;
    

    Llamar a este programa con el comando “upload” invocar√° la funci√≥n que le pas√≥, que en este caso solo se imprime en la l√≠nea de comando. Sin embargo, estoy seguro de que puede imaginarse pasar una funci√≥n mucho m√°s capaz que utiliza el analizado argv objeto para determinar qu√© archivo enviar d√≥nde.

    Por ejemplo, este comando podr√≠a llamarse as√≠ (asumiendo que el c√≥digo anterior est√° almacenado en un archivo llamado “s3-tool.js”:

    $ node s3-tool.js upload --file=my-file.txt --bucket=my-s3-bucket
    Uploading your file now...
    

    Y no tiene que detenerse allí, incluso puede crear un comando predeterminado:

    'use strict';
    
    const argv = require('yargs')
        .command('*', 'the default command handler', () => {}, (argv) => {
            console.log('This function is called by default');
        }).argv;
    

    los .command() La función es incluso lo suficientemente potente como para inferir los parámetros obligatorios y opcionales de una cadena:

    'use strict';
    
    const yargs = require('yargs');
    
    yargs.command('login <username> [password]', 'authenticate with the server').argv
    

    Para obtener más información sobre las funciones avanzadas, consulte el yargs documentación de temas avanzados.

    Conclusión

    Puede que te sorprenda un poco, pero como habrás notado, el análisis de argumentos puede ser un tema bastante complejo. Dependiendo de tus necesidades puedes hacerlo tan simple o complicado como quieras. Independientemente, existe una solución adecuada para todas las necesidades, ya sea la básica process.argv matriz o el poderoso yargs paquete.

    Como has usado minimist y yargs para crear programas CLI? ¬°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 *