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


2417

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.

Respuestas:


3048

Método estándar (sin biblioteca)

Los argumentos se almacenan en process.argv

Estos son los documentos de nodo sobre el manejo de argumentos de línea de comando:

process.argves una matriz que contiene los argumentos de la línea de comando. El primer elemento será 'nodo', el segundo elemento será el nombre del archivo JavaScript. Los siguientes elementos serán argumentos de línea de comando adicionales.

// 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

77
¿Qué debo escribir en el símbolo del sistema para ejecutar un script node.js con argumentos de línea de comandos?
Anderson Green

8
ACTUALIZACIÓN: Encontré la respuesta a la pregunta anterior. stackoverflow.com/questions/12925802/…
Anderson Green

2
Minimist es un excelente y simple analizador de argumentos
Guilherme Nagatomo

44
También puede acceder a un único argumento cuando conoce su posición: ¿ process.argv[n]dónde nestá el índice basado en cero?
Luca Steeb

66
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 balala, podemos usar process.execArgv con process.argv
cuixiping

679

Para normalizar los argumentos como recibiría una función de 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.


19
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. Todavía actualizado con las últimas versiones de nodo y sin problemas: es solo un simple script de shell, chicos. No forma 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

36
@cuixiping pero noexecArgv están en el 2 por lo que es suficienteargv
Tommi Kyntola

77
Después de mirar el historial de edición de esta respuesta, me gustaría tomar un momento para simpatizar con @MauvisLedford. No hay nada tan molesto como las ediciones no solicitadas de su código en nombre de la preferencia personal (sin ningún beneficio cuantificable, para arrancar). A quien le hace eso: descartar.
Jonathan Dumaine

77
Hola @MauvisLedford, han pasado cuatro años más. ¡Me encantaría una actualización!
Andrew Lorien

13
NOprocess.argv.splice(process.execArgv.length + 2) : para un comando node --harmony script.js --version, el process.argves ['/usr/local/bin/node', 'script.js', '--version']. ¡Las banderas nonode están incluidas en ! process.argv
Константин Ван

360

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

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' }

32
En realidad, esta solución es más útil para desarrollar una herramienta de línea de comandos con más indicadores y argumentos, y debería votarse más en mi humilde opinión.
JK ABC

2
Imo, esta es una alternativa más simple a npmjs.com/package/command-line-args
klodoma el

55
@JKABC No llamaría a esto la respuesta más correcta, ya que el OP solo pide acceder a información trivial de la línea de comando. Pero estoy de acuerdo en que tanto minimist como command-line-args son muy útiles si planea extender su CLI.
Justus Romijn

2
Me pregunto por qué '-n5' no produce 'n5: verdadero', eso tendría sentido para mí.
Max Waterman

77
@MaxWaterman: porque las opciones que comienzan con un solo guión solo se suponen para un solo personaje. Todo lo que sigue a una sola opción de carácter se toma como argumento para la opción (no se requiere espacio). Iniciar la opción con dos guiones (es decir, --n5) debería producir 'n5: verdadero'. Este es un comportamiento bastante estándar para la mayoría de las herramientas de línea de comandos de Unix (pero no todas desafortunadamente).
Menno Smits

313

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


Análisis de argumentos de Javascript de vainilla:

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


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

Minimista : para análisis de argumentos mínimos.

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

Miau : 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.


76
"$ npm install -g yargs" produjo 1.9 MB de código JavaScript. ¿Cuándo va a terminar esta locura cuando una biblioteca de analizador argv necesita dos megabytes de código? Aumento de la superficie de ataque, RAM desperdiciada, etc ...
joonas.fi

99
Yargs es una herramienta más grande que también analiza los argumentos de la línea de comandos. Sin locura, solo falta de información. Si quieres algo más ligero, usa JS, Meow o Minimist sin procesar.
dthree

1
"$ npm i yargs" -> 800 KB aquí, supongo que los propietarios de paquetes finalmente aprendieron a ignorar los archivos irrelevantes. De todos modos, todavía es grande para proyectos tontos, pero pequeño cuando necesitas robustez y en proyectos más grandes ya tienes dependencias ..
Andre Figueiredo

3
He creado un paquete, llamado wily-cli , con el objetivo de hacer una herramienta más poderosa, más personalizable y más fácil de usar que los grandes nombres enumerados. Para aquellos de ustedes que estén interesados, solo son 94.6 KB después de la instalación
Jason

1
vscode import-cost me dice que yargs (159.2K) ahora es en realidad más liviano que miau (180.2K). ¡Minimist todavía los supera a 3.4K!
Shivam Tripathi

124

Optimista (optimista de nodo)

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

Actualizar

Optimist está en desuso. Pruebe los hilos, que es una bifurcación activa de optimista.


18
+1 para el enlace. Hay una lista bastante larga de analizadores de opciones de línea de comandos en github.com/joyent/node/wiki/modules#wiki-parsers-commandline
Thilo

77
Minimist es otro sucesor del optimista ahora obsoleto. Es "las agallas del analizador de argumentos optimista sin toda la decoración fantasiosa". 23 millones de descargas en el último mes (a partir del 12/2015).
aap

96

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 forma estándar con node.js como señaló MooGoo. (Solo para que sea comprensible para alguien que es 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"

80

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-Prompt

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


26
@Evan Carroll, por favor, no edite mi respuesta para promocionar una biblioteca que 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 para los autores del módulo, no editan las respuestas de otras personas.
Balupton

Commander.js realmente me ayudó. Otras bibliotecas no funcionarían con el compilador nexe, pero esta es la solución. Si desea obtener args al usar nexe, asegúrese de pasar -f al compilador de nexe.
pierce.jason

60

Sin Libs 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

Simple

entrada

node test.js -D --name=Hello

salida

{ D: true, name: 'Hello' }

Mundo real

entrada

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

salida

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

1
Dado que algunas banderas tienen una forma larga, puede explicar esto. En lugar de = longArg[1]poder escribir, = longArg.length > 1 ? longArg[1] : true;esto le permitiría pasar este tipo de argumento:node config/build.js --flag1 --flag2
tralston

Me gusta. Hizo la línea un poco larga, así que la separé. Gracias por contarme sobre esto.
Michael Warner

54

Biblioteca Stdio

La forma más fácil de analizar argumentos de línea de comandos en NodeJS es usar 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' }

Entonces puedes usarlo como quieras. Por ejemplo:

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

Las opciones agrupadas también son compatibles, 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 único argumento para una opción y necesita 2).

Puede instalar el módulo stdio usando NPM :

npm install stdio

3
De acuerdo con los TOS de SO, vale la pena mencionar que @sgmonda es el único responsable del módulo;) Sin embargo, es un pequeño módulo agradable. Definitivamente útil.
Qix - MONICA FUE MALTRATADA el

1
De hecho útil, aunque la actualización más reciente fue el 30 de diciembre de 2014. Puede que no se mantenga tan bien como algunos otros paquetes.
fearless_fool

buena lib! tks! aunque no tiene actualizaciones recientes. Tiene bastante buena funcionalidad
Pablo Ezequiel

Ha pasado un tiempo, pero acabo de lanzar la versión 2, con total promesa y soporte de mecanografía. :-)
sgmonda

47

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

node myScript.js Sean Worthington

Luego, dentro de tu guión, escribes:

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

28

¡ vale la pena echar un vistazo a command-line-args !

Puede establecer opciones utilizando los principales estándares de notación ( más información ). Todos estos comandos son 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 esto), lo que le brinda 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 comandos-line-args 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

Guía de uso de generación

Se --helppuede generar una guía de uso (generalmente impresa cuando se configura) usando 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 típico de guía de uso.

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.


@Lloyd esto está relacionado con un problema que ya ha surgido, aquí . Webstorm pasa algunos argumentos adicionales.
kboom

@kboom ese problema fue resuelto por las opciones partialy stopAtFirstUnknown. Ver los documentos .
Lloyd

23

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 para leer.

Aquí hay un ejemplo de la página 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 las 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' ]

21

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 a =. Esto es solo para un uso muy simple.


12

Probablemente sea una buena idea administrar su configuración de manera centralizada utilizando algo como nconf https://github.com/flatiron/nconf

Le ayuda a trabajar con archivos de configuración, variables de entorno, argumentos de línea de comandos.


Y aquí está la configuración , mi propia interfaz mínima de solo lectura para nconf.
Joel Purra

12

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 tiempo)

    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' }

Su versión más larga tiene un problema con las cadenas que contienen puntos.
berliner

Solución inteligente! ¿Qué sucede si quiero admitir las opciones de línea de comandos county las de ambos c( ccomo un alias / shorcut para count)?
Alex Vang

¡Esto es hermoso! Pero no utiliza el estándar "un guión para una tecla de letra y dos guiones para la tecla de palabra". Desafortunadamente, mi alternativa es demasiado larga y fea para publicar aquí, así que agregaré como una respuesta diferente.
isacvale

10

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

Si ejecuta un script con los siguientes argumentos

$ node args.js arg1 arg2

Archivo: args.js

console.log(process.argv)

Obtendrás una matriz como

 ['node','args.js','arg1','arg2']

9
npm install ps-grab

Si quieres 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
Este repositorio ya no está disponible en github.
steadweb

8

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:

0 : El directorio de node.exe en su mecanizado (C: \ Archivos de programa \ nodejs \ node.exe ')

1: El directorio de su archivo de proyecto. (proj.js)

2 : Su primer argumento para el nodo (arg1)

3 : Su segundo argumento para el nodo (arg2)

4 : Su tercer argumento para el nodo (arg3)

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


7

Puede llegar a los argumentos de la línea de comandos usando system.args. Y uso 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 saber el índice del argumento. úsalo comoargs.whatever

Nota: debe usar argumentos con nombre file.js x=1 y=2para usar esta solución.


No se puede hacer que funcione, la mappropiedad no está definida.
caram

6

Puede analizar todos los argumentos y verificar si existen.

archivo: parse-cli-argumentos.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']);

4

Sin bibliotecas

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

trabajó 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
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

4

Aunque las respuestas anteriores son perfectas, y alguien ya ha sugerido hilos, 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.


Yargs no afecta cómo se pasan los argumentos en la línea de comandos, solo ayuda a leerlos en código.
user3285954

4

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

Joseph Merdrignac publicó una hermosa usando reduce, pero se basó en una key=valuesintaxis en lugar de -k valuey --key value. Reescribí mucho más feo y largo 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"
}

3

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 ninguna biblioteca adicional 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 apunte 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 la depuración si alguna vez cuestionas qué argumentos estás recibiendo y en qué orden.

También puede usar bibliotecas como yargs para trabajar con argumentos de línea de comandos.


2

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);

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

Salida: { p: 'param ', parameter: 'parameter' }


1

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

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

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, suponiendo el siguiente script para process-args.js:

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

Lanzando el proceso 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 las personas han dado buenas respuestas. También me gustaría contribuir con algo aquí. Estoy proporcionando la respuesta usando la lodashbiblioteca para iterar a través de todos los argumentos de 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

0

La mejor manera de pasar argumentos de línea de comandos a un programa Node.js es mediante el uso de una interfaz de línea de comandos (CLI)

Hay un ingenioso módulo npm llamado nodejs-cli que puede usar.

Si quieres crear uno sin dependencias, tengo uno en mi Github si quieres comprobarlo, en realidad es bastante simple y fácil de usar, haz clic aquí .


0

Solución sin dependencias de 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());
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.