¿Cómo paso argumentos de línea de comando a un programa Node.js?

2659

Tengo un servidor web escrito en Node.js y me gustaría iniciarlo con una carpeta específica. No estoy seguro de cómo acceder a los argumentos en JavaScript. Estoy ejecutando un nodo como este:

$ node server.js folder

aquí server.jsestá mi código de servidor. La ayuda de Node.js dice que esto es posible:

$ node -h
Usage: node [options] script.js [arguments]

¿Cómo accedería a esos argumentos en JavaScript? De alguna manera no pude encontrar esta información en la web.

2
  • Probablemente sea una buena idea administrar su configuración de manera centralizada usando algo como nconf github.com/flatiron/nconf Le ayuda a trabajar con archivos de configuración, variables de entorno, argumentos de línea de comandos. 250R 26 de mayo de 2012 a las 0:10
  • Y aquí está la configuración , mi propia interfaz mínima de solo lectura para nconf. Joel Purra 26 de enero de 2014 a las 12:02
3294

Método estándar (sin biblioteca)

Los argumentos se almacenan en process.argv

Aquí están los documentos de nodo sobre el manejo de argumentos de línea de comando:

process.argv is an array containing the command line arguments. The first element will be 'node', the second element will be the name of the JavaScript file. The next elements will be any additional command line arguments.

// print process.argv
process.argv.forEach(function (val, index, array) {
  console.log(index + ': ' + val);
});

Esto generará:

$ node process-2.js one two=three four
0: node
1: /Users/mjr/work/node/process-2.js
2: one
3: two=three
4: four
9
  • 13
    ¿Qué debo escribir en el símbolo del sistema para ejecutar un script node.js con argumentos de línea de comandos? Anderson Green 16/10/12 a las 0:58
  • 11
    ACTUALIZACIÓN: Encontré la respuesta a la pregunta anterior. stackoverflow.com/questions/12925802/…Anderson Green 17/10/12 a las 1:30
  • 3
    Minimist es un analizador de argumentos excelente y simpleGuilherme Nagatomo 22 de mayo de 2014 a las 2:04
  • 8
    También puede acceder a un solo argumento cuando conoce su posición: process.argv[n]dónde nestá el índice de base ceroLuca Steeb 1 feb.15 a las 15:12
  • 10
    el segundo elemento (process.argv [1]) puede ser o no un archivo js. la sintaxis del comando de nodo es node [options] [ -e script | script.js ] [arguments]o node debug script.js [arguments]. por ejemplo: node --harmony script.js balalao node --no-deprecation --enable-ssl2 script.js balalapodemos usar process.execArgv con process.argvcuixiping 7 de enero de 2016 a las 12:43
771

Para normalizar los argumentos como los recibiría una función javascript normal, hago esto en mis scripts de shell node.js:

var args = process.argv.slice(2);

Tenga en cuenta que el primer argumento suele ser la ruta a nodejs, y el segundo argumento es la ubicación del script que está ejecutando.

2
  • 41
    Solo una nota de que escribí esta respuesta hace 4 años y el código que estoy ejecutando todavía funciona 100% bien hoy. Aún manteniéndose actualizado con las últimas versiones de node y aún sin problemas: es solo un simple script de shell, chicos. No es parte de un gran objeto global lleno de bibliotecas JS. Todavía estoy detrás de mi respuesta hoy. Daré otra actualización en 4 años más. Mauvis Ledford 5 de marzo de 2015 a las 1:18
  • 2
    Han pasado 6 años más. 🤣. Me quedé despierto toda la noche el 5 de marzo de 2019.Chuck Taylor 23 de agosto a las 20:09
424

La respuesta correcta actualizada para esto es usar la biblioteca minimista . Solíamos usar node-optimist, pero desde entonces ha quedado obsoleto.

Aquí hay un ejemplo de cómo usarlo tomado directamente de la documentación minimista:

var argv = require('minimist')(process.argv.slice(2));
console.dir(argv);

-

$ node example/parse.js -a beep -b boop
{ _: [], a: 'beep', b: 'boop' }

-

$ node example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz
{ _: [ 'foo', 'bar', 'baz' ],
  x: 3,
  y: 4,
  n: 5,
  a: true,
  b: true,
  c: true,
  beep: 'boop' }
1
  • 41
    En realidad, esta solución es más útil para desarrollar una herramienta de línea de comandos con más banderas y argumentos, y debería recibir más votos en mi humilde opinión. JK ABC 6 de febrero de 2015 a las 3:15
354

Respuesta de 2018 basada en las tendencias actuales en la naturaleza:


Análisis de argumentos de vainilla javascript:

const args = process.argv;
console.log(args);

Esto devuelve:

$ node server.js one two=three four
['node', '/home/server.js', 'one', 'two=three', 'four']

Documentos oficiales


Los paquetes NPM más utilizados para el análisis de argumentos:

Minimista : para un análisis mínimo de argumentos.

Commander.js : el módulo más adoptado para el análisis de argumentos.

Meow : alternativa más ligera a Commander.js

Yargs : análisis de argumentos más sofisticado (pesado).

Vorpal.js : aplicaciones de línea de comandos maduras / interactivas con análisis de argumentos.

1
  • 101
    "$ npm install -g yargs" produjo 1,9 MB de código JavaScript. ¿Cuándo terminará esta locura cuando una biblioteca de analizador argv necesite dos megabytes de código? El aumento de la superficie de ataque, memoria RAM desperdiciada, etc ...joonas.fi 13/10/2016 a las 17:21
128

Optimista (optimista de nodos)

Consulte la biblioteca optimista , es mucho mejor que analizar las opciones de la línea de comandos a mano.

Actualizar

Optimist está en desuso. Prueba yargs, que es una bifurcación activa de optimista.

1
111

Varias respuestas geniales aquí, pero todo parece muy complejo. Esto es muy similar a cómo los scripts de bash acceden a los valores de los argumentos y ya se proporciona de manera estándar con node.js como señaló MooGoo. (Solo para que sea comprensible para alguien que sea nuevo en node.js)

Ejemplo:

$ node yourscript.js banana monkey

var program_name = process.argv[0]; //value will be "node"
var script_path = process.argv[1]; //value will be "yourscript.js"
var first_value = process.argv[2]; //value will be "banana"
var second_value = process.argv[3]; //value will be "monkey"
0
85

Commander.js

Funciona muy bien para definir sus opciones, acciones y argumentos. También genera las páginas de ayuda para usted.

Prontamente

Funciona muy bien para obtener información del usuario, si le gusta el enfoque de devolución de llamada.

Co-solicitud

Funciona muy bien para obtener información del usuario, si le gusta el enfoque del generador.

1
  • 27
    @Evan Carroll, por favor, no edite mi respuesta para promocionar una biblioteca. No uso stackoverflow.com/posts/7483600/revisions, especialmente debido a una característica que falta, estas opiniones deben guardarse para comentarios o solicitudes de extracción. los autores del módulo, no las ediciones de las respuestas de otras personas. balupton 11/11/2013 a las 1:56
77

Sin bibliotecas con banderas formateadas en un objeto simple

function getArgs () {
    const args = {};
    process.argv
        .slice(2, process.argv.length)
        .forEach( arg => {
        // long arg
        if (arg.slice(0,2) === '--') {
            const longArg = arg.split('=');
            const longArgFlag = longArg[0].slice(2,longArg[0].length);
            const longArgValue = longArg.length > 1 ? longArg[1] : true;
            args[longArgFlag] = longArgValue;
        }
        // flags
        else if (arg[0] === '-') {
            const flags = arg.slice(1,arg.length).split('');
            flags.forEach(flag => {
            args[flag] = true;
            });
        }
    });
    return args;
}
const args = getArgs();
console.log(args);

Ejemplos de

Sencillo

aporte

node test.js -D --name=Hello

producción

{ D: true, name: 'Hello' }

Mundo real

aporte

node config/build.js -lHRs --ip=$HOST --port=$PORT --env=dev

producción

{ 
  l: true,
  H: true,
  R: true,
  s: true,
  ip: '127.0.0.1',
  port: '8080',
  env: 'dev'
}
0
70

Biblioteca Stdio

La forma más fácil de analizar los argumentos de la línea de comandos en NodeJS es usando el módulo stdio . Inspirado en la getoptutilidad UNIX , es tan trivial como sigue:

var stdio = require('stdio');
var ops = stdio.getopt({
    'check': {key: 'c', args: 2, description: 'What this option means'},
    'map': {key: 'm', description: 'Another description'},
    'kaka': {args: 1, required: true},
    'ooo': {key: 'o'}
});

Si ejecuta el código anterior con este comando:

node <your_script.js> -c 23 45 --map -k 23 file1 file2

Entonces el opsobjeto será el siguiente:

{ check: [ '23', '45' ],
  args: [ 'file1', 'file2' ],
  map: true,
  kaka: '23' }

Para que puedas usarlo como quieras. Por ejemplo:

if (ops.kaka && ops.check) {
    console.log(ops.kaka + ops.check[0]);
}

También se admiten las opciones agrupadas, por lo que puede escribir en -omlugar de -o -m.

Además, stdiopuede generar una salida de ayuda / uso automáticamente. Si llama ops.printHelp(), obtendrá lo siguiente:

USAGE: node something.js [--check <ARG1> <ARG2>] [--kaka] [--ooo] [--map]
  -c, --check <ARG1> <ARG2>   What this option means (mandatory)
  -k, --kaka                  (mandatory)
  --map                       Another description
  -o, --ooo

El mensaje anterior también se muestra si no se proporciona una opción obligatoria (precedida por el mensaje de error) o si está mal especificada (por ejemplo, si especifica un solo argumento para una opción y necesita 2).

Puede instalar el módulo stdio usando NPM :

npm install stdio
0
54

Si su secuencia de comandos se llama myScript.js y desea pasar el nombre y apellido, 'Sean Worthington', como argumentos como a continuación:

node myScript.js Sean Worthington

Luego, dentro de su guión, escribe:

var firstName = process.argv[2]; // Will be set to 'Sean'
var lastName = process.argv[3]; // Will be set to 'Worthington'
0
32

¡ Vale la pena echarle un vistazo a command-line-args !

Puede establecer opciones utilizando los principales estándares de notación ( más información ). Estos comandos son todos equivalentes y establecen los mismos valores:

$ example --verbose --timeout=1000 --src one.js --src two.js
$ example --verbose --timeout 1000 --src one.js two.js
$ example -vt 1000 --src one.js two.js
$ example -vt 1000 one.js two.js

Para acceder a los valores, primero cree una lista de definiciones de opciones que describan las opciones que acepta su aplicación. La typepropiedad es una función de establecimiento (el valor proporcionado se pasa a través de este), lo que le da un control total sobre el valor recibido.

const optionDefinitions = [
  { name: 'verbose', alias: 'v', type: Boolean },
  { name: 'src', type: String, multiple: true, defaultOption: true },
  { name: 'timeout', alias: 't', type: Number }
]

A continuación, analice las opciones usando commandLineArgs () :

const commandLineArgs = require('command-line-args')
const options = commandLineArgs(optionDefinitions)

options ahora se ve así:

{
  src: [
    'one.js',
    'two.js'
  ],
  verbose: true,
  timeout: 1000
}

Uso avanzado

Además del uso típico anterior, puede configurar los argumentos de línea de comandos para aceptar formas de sintaxis más avanzadas.

Sintaxis basada en comandos (estilo git) en la forma:

$ executable <command> [options]

Por ejemplo.

$ git commit --squash -m "This is my commit message"

Sintaxis de comando y subcomando (estilo Docker) en la forma:

$ executable <command> [options] <sub-command> [options]

Por ejemplo.

$ docker run --detached --image centos bash -c yum install -y httpd

Generación de guías de uso

Se --helppuede generar una guía de uso (normalmente impresa cuando está configurada) mediante el uso de la línea de comandos . Vea los ejemplos a continuación y lea la documentación para obtener instrucciones sobre cómo crearlos.

Un ejemplo de guía de uso típico.

uso

La guía de uso de polímero-cli es un buen ejemplo de la vida real.

uso

Otras lecturas

Hay mucho más que aprender, consulte la wiki para ver ejemplos y documentación.

2
  • @Lloyd esto está relacionado con el problema ya surgido, aquí . Webstorm pasa algunos argumentos adicionales. kboom 28 de enero de 2017 a las 18:07
  • @kboom ese problema se resolvió con las opciones partialy stopAtFirstUnknown. Consulte los documentos . Lloyd 28/01/18 a las 19:39
29

Aquí está mi solución 0-dep para argumentos con nombre:

const args = process.argv
    .slice(2)
    .map(arg => arg.split('='))
    .reduce((args, [value, key]) => {
        args[value] = key;
        return args;
    }, {});

console.log(args.foo)
console.log(args.fizz)

Ejemplo:

$ node test.js foo=bar fizz=buzz
bar
buzz

Nota: Naturalmente, esto fallará cuando el argumento contenga un =. Esto es solo para un uso muy simple.

26

Hay una aplicación para eso. Bueno, módulo. Bueno, más de uno, probablemente cientos.

Yargs es uno de los más divertidos, sus documentos son geniales de leer.

Aquí hay un ejemplo de la página de github / npm:

#!/usr/bin/env node
var argv = require('yargs').argv;
console.log('(%d,%d)', argv.x, argv.y);
console.log(argv._);

La salida está aquí (lee opciones con guiones, etc., cortos y largos, numéricos, etc.).

$ ./nonopt.js -x 6.82 -y 3.35 rum
(6.82,3.35)
[ 'rum' ] 
$ ./nonopt.js "me hearties" -x 0.54 yo -y 1.12 ho
(0.54,1.12)
[ 'me hearties', 'yo', 'ho' ]
18

Análisis de argumento basado en la entrada estándar ( --key=value)

const argv = (() => {
    const arguments = {};
    process.argv.slice(2).map( (element) => {
        const matches = element.match( '--([a-zA-Z0-9]+)=(.*)');
        if ( matches ){
            arguments[matches[1]] = matches[2]
                .replace(/^['"]/, '').replace(/['"]$/, '');
        }
    });
    return arguments;
})();

Ejemplo de comando

node app.js --name=stackoverflow --id=10 another-argument --text="Hello World"

Resultado de argv: console.log(argv)

{
    name: "stackoverflow",
    id: "10",
    text: "Hello World"
}
3
  • ¿Por qué se vota en contra de esta respuesta? ¿ Realmente no proporciona ninguna información útil? Todd 25 abr.20 a las 12:42
  • 3
    También me sorprende. En mi opinión, es la mejor solución aquí. Lo usé muchas veces en mis proyectos. Manvel 25 abr.20 a las 21:27
  • funciona perfectamente pero con un par de errores de eslint. aquí está la versión fija. const argv = (() => {const args = {} process.argv.slice (2) .forEach (element => {const matches = element.match ('- ([a-zA-Z0-9] + ) = (. *) ') if (coincide con) {args [coincide con [1]] = coincide con [2] .replace (/ ^ [' "] /, '') .replace (/ ['"] $ /, '')}}) return args}) ()fatlinesofcode 25 feb a las 23:09
17

proj.js

for(var i=0;i<process.argv.length;i++){
  console.log(process.argv[i]);
}

Terminal:

nodemon app.js "arg1" "arg2" "arg3"

Resultado:

0 'C:\\Program Files\\nodejs\\node.exe'
1 'C:\\Users\\Nouman\\Desktop\\Node\\camer nodejs\\proj.js'
2 'arg1' your first argument you passed.
3 'arg2' your second argument you passed.
4 'arg3' your third argument you passed.

Explicación:

  1. El directorio de node.exe en su máquina ( C:\Program Files\nodejs\node.exe)
  2. El directorio de su archivo de proyecto ( proj.js)
  3. Tu primer argumento para node ( arg1)
  4. Su segundo argumento para node ( arg2)
  5. Su tercer argumento para node ( arg3)

sus argumentos reales comienzan desde el segundo índice de la argvmatriz, es decir process.argv[2].

15

sin bibliotecas: usando Array.prototype.reduce ()

const args = process.argv.slice(2).reduce((acc, arg) => {

    let [k, v = true] = arg.split('=')
    acc[k] = v
    return acc

}, {})

para este comando node index.js count=2 print debug=false msg=hi

console.log(args) // { count: '2', print: true, debug: 'false', msg: 'hi' }

además,

podemos cambiar

    let [k, v = true] = arg.split('=')
    acc[k] = v

por (mucho más)

    let [k, v] = arg.split('=')
    acc[k] = v === undefined ? true : /true|false/.test(v) ? v === 'true' : /[\d|\.]+/.test(v) ? Number(v) : v

para analizar automáticamente Boolean & Number

console.log(args) // { count: 2, print: true, debug: false, msg: 'hi' }
3
  • Su versión más larga tiene un problema con las cadenas que contienen puntos. berliner 5 de ene. De 2018 a las 19:33
  • ¡Solución inteligente! ¿Qué pasa si quiero apoyar tanto county copciones de línea de comandos ( ccomo un alias / atajo para count)? Alex Vang 10/04/18 a las 10:48
  • ¡Esto es hermoso! Pero no utiliza el estándar de "un guión por tecla de una letra y dos guiones por tecla de palabra". Desafortunadamente, mi alternativa es demasiado larga y fea para publicar aquí, así que agregaré como una respuesta diferente. isacvale 25 feb 2019 a las 16:11
13

Pasar y analizar argumentos es un proceso sencillo. Node le proporciona la propiedad process.argv, que es una matriz de cadenas, que son los argumentos que se usaron cuando se invocó a Node. La primera entrada de la matriz es el ejecutable de Node y la segunda entrada es el nombre de su script.

Si ejecuta un script con los siguientes atgumentos

$ node args.js arg1 arg2

Archivo: args.js

console.log(process.argv)

Obtendrás una matriz como

 ['node','args.js','arg1','arg2']
10
npm install ps-grab

Si desea ejecutar algo como esto:

node greeting.js --user Abdennour --website http://abdennoor.com 

-

var grab=require('ps-grab');
grab('--username') // return 'Abdennour'
grab('--action') // return 'http://abdennoor.com'

O algo como:

node vbox.js -OS redhat -VM template-12332 ;

-

var grab=require('ps-grab');
grab('-OS') // return 'redhat'
grab('-VM') // return 'template-12332'
1
  • 2
    Este repositorio ya no está disponible en github. steadweb 3 feb 2017 a las 17:37
8

Puede acceder a los argumentos de la línea de comandos usando system.args. Y utilizo la solución a continuación para analizar los argumentos en un objeto, de modo que pueda obtener cuál quiero por nombre.

var system = require('system');

var args = {};
system.args.map(function(x){return x.split("=")})
    .map(function(y){args[y[0]]=y[1]});

ahora no necesita conocer el índice del argumento. úsalo comoargs.whatever

Note: you should use named arguments like file.js x=1 y=2 to use this solution.

1
  • No puedo hacerlo funcionar, la mappropiedad no está definida. caram 3 feb.20 a las 12:55
7

Puede analizar todos los argumentos y comprobar si existen.

archivo: parse-cli-argument.js:

module.exports = function(requiredArguments){
    var arguments = {};

    for (var index = 0; index < process.argv.length; index++) {
        var re = new RegExp('--([A-Za-z0-9_]+)=([A/-Za-z0-9_]+)'),
            matches = re.exec(process.argv[index]);

        if(matches !== null) {
            arguments[matches[1]] = matches[2];
        }
    }

    for (var index = 0; index < requiredArguments.length; index++) {
        if (arguments[requiredArguments[index]] === undefined) {
            throw(requiredArguments[index] + ' not defined. Please add the argument with --' + requiredArguments[index]);
        }
    }

    return arguments;
}

Que solo hacer:

var arguments = require('./parse-cli-arguments')(['foo', 'bar', 'xpto']);
0
7

Pasar argumentos es fácil, y recibirlos es solo una cuestión de leer el proceso.argv array Node hace accesible desde cualquier lugar, básicamente. Pero seguramente querrá leerlos como pares clave / valor, por lo que necesitará un fragmento de script para interpretarlo.

Joseph Merdrignac publicó uno hermoso usando reduce, pero se basaba en una key=valuesintaxis en lugar de -k valuey --key value. Lo reescribí mucho más feo y más largo para usar ese segundo estándar, y lo publicaré como respuesta porque no encajaría como comentario. Pero hace el trabajo.

   const args = process.argv.slice(2).reduce((acc,arg,cur,arr)=>{
     if(arg.match(/^--/)){
       acc[arg.substring(2)] = true
       acc['_lastkey'] = arg.substring(2)
     } else
     if(arg.match(/^-[^-]/)){
       for(key of arg.substring(1).split('')){
         acc[key] = true
         acc['_lastkey'] = key
       }
     } else
       if(acc['_lastkey']){
         acc[acc['_lastkey']] = arg
         delete acc['_lastkey']
       } else
         acc[arg] = true
     if(cur==arr.length-1)
       delete acc['_lastkey']
     return acc
   },{})

Con este código, un comando node script.js alpha beta -charlie delta --echo foxtrotle daría el siguiente objeto


args = {
 "alpha":true,
 "beta":true,
 "c":true,
 "h":true,
 "a":true,
 "r":true
 "l":true,
 "i":true,
 "e":"delta",
 "echo":"foxtrot"
}
5

Sin bibliotecas

Si desea hacer esto en vanilla JS / ES6, puede usar la siguiente solución

funcionó solo en NodeJS> 6

const args = process.argv
  .slice(2)
  .map((val, i)=>{
    let object = {};
    let [regexForProp, regexForVal] = (() => [new RegExp('^(.+?)='), new RegExp('\=(.*)')] )();
    let [prop, value] = (() => [regexForProp.exec(val), regexForVal.exec(val)] )();
    if(!prop){
      object[val] = true;
      return object;
    } else {
      object[prop[1]] = value[1] ;
      return object
    }
  })
  .reduce((obj, item) => {
    let prop = Object.keys(item)[0];
    obj[prop] = item[prop];
    return obj;
  }, {});

Y este comando

node index.js host=http://google.com port=8080 production

producirá el siguiente resultado

console.log(args);//{ host:'http://google.com',port:'8080',production:true }
console.log(args.host);//http://google.com
console.log(args.port);//8080
console.log(args.production);//true

ps Por favor, corrija el código en el mapa y reduzca la función si encuentra una solución más elegante, gracias;)

1
  • 1
    Estoy de acuerdo, pero podría ser más corto, ¿no? let args = process.argv.slice(2).reduce((acc, arg) => { let [k, v] = arg.split('=') acc[k] = v return acc }, {})Joseph Merdrignac 13/10/2017 a las 12:23
5

Aunque las respuestas anteriores son perfectas, y alguien ya ha sugerido yargs, usar el paquete es realmente fácil. Este es un paquete agradable que hace que pasar argumentos a la línea de comandos sea realmente fácil.

npm i yargs
const yargs = require("yargs");
const argv = yargs.argv;
console.log(argv);

Visite https://yargs.js.org/ para obtener más información.

1
  • Yargs no afecta la forma en que se pasan los argumentos en la línea de comando, solo ayuda a leerlos en el código. user3285954 3 nov 2019 a las 23:44
4

La forma más sencilla de recuperar argumentos en Node.js es a través de la matriz process.argv. 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 de la matriz process.argv.

El primer elemento de la matriz process.argv siempre será una ruta del sistema de archivos que apunta al ejecutable del nodo. 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.

'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 la matriz process.argv 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.

También puede utilizar bibliotecas como yargs para trabajar con argumentos commnadline.

4

Solución TypeScript sin bibliotecas:

interface IParams {
  [key: string]: string
}

function parseCliParams(): IParams {
  const args: IParams = {};
  const rawArgs = process.argv.slice(2, process.argv.length);
  rawArgs.forEach((arg: string, index) => {
    // Long arguments with '--' flags:
    if (arg.slice(0, 2).includes('--')) {
      const longArgKey = arg.slice(2, arg.length);
      const longArgValue = rawArgs[index + 1]; // Next value, e.g.: --connection connection_name
      args[longArgKey] = longArgValue;
    }
    // Shot arguments with '-' flags:
    else if (arg.slice(0, 1).includes('-')) {
      const longArgKey = arg.slice(1, arg.length);
      const longArgValue = rawArgs[index + 1]; // Next value, e.g.: -c connection_name
      args[longArgKey] = longArgValue;
    }
  });
  return args;
}

const params = parseCliParams();
console.log('params: ', params);

Aporte: ts-node index.js -p param --parameter parameter

Producción: { p: 'param ', parameter: 'parameter' }

2

process.argves su amigo, la captura de argumentos de línea de comando se admite de forma nativa en Node JS. Vea el ejemplo a continuación:

process.argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
})
2

Solución sin dependencias estilo ES6:

const longArgs = arg => {
    const [ key, value ] = arg.split('=');
    return { [key.slice(2)]: value || true }
};

const flags = arg => [...arg.slice(1)].reduce((flagObj, f) => ({ ...flagObj, [f]: true }), {});


const args = () =>
    process.argv
        .slice(2)
        .reduce((args, arg) => ({
            ...args,
            ...((arg.startsWith('--') && longArgs(arg)) || (arg[0] === '-' && flags(arg)))
        }), {});

console.log(args());
1
  • escribir demasiado es6 como este puede hacer que el código se sienta ilegible a primera vistaEndless 27 de febrero a las 3:41
1

Extendí la getArgsfunción solo para obtener también comandos, así como banderas ( -f, --anotherflag) y nombrados args ( --data=blablabla):

  1. El módulo
/**
 * @module getArgs.js
 * get command line arguments (commands, named arguments, flags)
 *
 * @see https://stackoverflow.com/a/54098693/1786393
 *
 * @return {Object}
 *
 */
function getArgs () {
  const commands = []
  const args = {}
  process.argv
    .slice(2, process.argv.length)
    .forEach( arg => {
      // long arg
      if (arg.slice(0,2) === '--') {
        const longArg = arg.split('=')
        const longArgFlag = longArg[0].slice(2,longArg[0].length)
        const longArgValue = longArg.length > 1 ? longArg[1] : true
        args[longArgFlag] = longArgValue
     }
     // flags
      else if (arg[0] === '-') {
        const flags = arg.slice(1,arg.length).split('')
        flags.forEach(flag => {
          args[flag] = true
        })
      }
     else {
      // commands
      commands.push(arg)
     } 
    })
  return { args, commands }
}


// test
if (require.main === module) {
  // node getArgs test --dir=examples/getUserName --start=getUserName.askName
  console.log( getArgs() )
}

module.exports = { getArgs }

  1. Ejemplo de uso:
$ node lib/getArgs test --dir=examples/getUserName --start=getUserName.askName
{
  args: { dir: 'examples/getUserName', start: 'getUserName.askName' },
  commands: [ 'test' ]
}

$ node lib/getArgs --dir=examples/getUserName --start=getUserName.askName test tutorial
{
  args: { dir: 'examples/getUserName', start: 'getUserName.askName' },
  commands: [ 'test', 'tutorial' ]
}

0

como se indica en los documentos del nodo La propiedad process.argv devuelve una matriz que contiene los argumentos de la línea de comandos pasados ​​cuando se inició el proceso Node.js.

Por ejemplo, asumiendo el siguiente script para process-args.js:

// print process.argv
process.argv.forEach((val, index) => {
   console.log(`${index}: ${val}`);
});

Lanzamiento del proceso de Node.js como:

 $ node process-args.js one two=three four

Generaría la salida:

0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: four
0

La mayoría de la gente ha dado buenas respuestas. También me gustaría aportar algo aquí. Estoy proporcionando la respuesta usando la lodashbiblioteca para iterar a través de todos los argumentos de la línea de comando que pasamos al iniciar la aplicación:

// Lodash library
const _ = require('lodash');

// Function that goes through each CommandLine Arguments and prints it to the console.
const runApp = () => {
    _.map(process.argv, (arg) => {
        console.log(arg);
    });
};

// Calling the function.
runApp();

Para ejecutar el código anterior, simplemente ejecute los siguientes comandos:

npm install
node index.js xyz abc 123 456

El resultado será:

xyz 
abc 
123
456