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 *