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

Tengo un servidor web escrito en Node.js y me gustaría lanzarlo 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.js es 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.

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 es 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 cualquier argumento de línea de comando adicional.

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

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

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

Tenga en cuenta que la primera arg suele ser la ruta a nodejs, y la segunda arg es la ubicación de la secuencia de comandos que está ejecutando.

La respuesta correcta y actualizada para que use 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' } 

2018 respuesta basada en las tendencias actuales en la naturaleza:


Análisis de argumento de JavaScript de Vanilla:

 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


La mayoría de los paquetes NPM usados ​​para el análisis de argumentos:

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

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.

Optimista (nodo-optimista)

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

Actualizar

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

Varias respuestas excelentes aquí, pero todo parece muy complejo. Esto es muy similar a cómo los scripts bash acceden a valores de argumento y ya se proporciona de manera estándar con node.js como señaló MooGoo. (Solo para que sea comprensible para alguien 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" 

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 callback.

Co-Prompt

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

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 por la utilidad getopt 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, mandatory: true}, 'ooo': {key: 'o'} }); 

Si ejecuta el código anterior con este comando:

 node  -c 23 45 --map -k 23 file1 file2 

Entonces el objeto ops 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 -om lugar de -o -m .

Además, stdio puede generar un resultado de ayuda / uso de forma automática. Si llama a ops.printHelp() obtendrá lo siguiente:

 USAGE: node something.js [--check  ] [--kaka] [--ooo] [--map] -c, --check   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 se especifica mal (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 

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

 node myScript.js Sean Worthington 

Luego, dentro de tu script, escribes:

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

¡command-line-args vale la pena mirar!

Puede establecer opciones utilizando los estándares de notación principal ( obtenga más información ). Estos comandos son todos equivalentes, estableciendo 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 propiedad type es una función setter (el valor suministrado se pasa a través de esto), 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 } ] 

Luego, analiza las opciones usando commandLineArgs () :

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

options ahora se ven así:

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

Uso avanzado

Además del uso típico anterior, puede configurar command-line-args para aceptar formularios de syntax más avanzados.

Sintaxis basada en comandos (estilo git) en el formulario:

 $ executable  [options] 

Por ejemplo.

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

Sintaxis de comandos y subcomandos (estilo docker) en el formulario:

 $ executable  [options]  [options] 

Por ejemplo.

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

Generación de guía de uso

Se puede generar una guía de uso (normalmente impresa cuando se configura --help ) utilizando el uso de línea de comandos . Consulte 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 polymer-cli es un buen ejemplo de la vida real.

uso

Otras lecturas

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

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 opciones con guiones, etc., corto y largo, numérico, 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' ] 

Probablemente sea una buena idea administrar su configuración de forma centralizada usando 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.

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

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

sin librairies: 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 node index.js count=2 print debug=false msg=hi 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' } 

Puede analizar todos los argumentos y verificar si existen.

archivo: parse-cli-arguments.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']); 
 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 así como:

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

 var grab=require('ps-grab'); grab('-OS') // return 'redhat' grab('-VM') // return 'template-12332' 

Puede llegar a los argumentos de línea de comando usando system.args . Y utilizo la solución a continuación para analizar los argumentos en un objeto, por lo que puedo 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. args.whatever como args.whatever

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

proj.js

 for(var i=0;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 maching (C: \ Archivos de progtwig \ nodejs \ node.exe ')

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

2 : su primer argumento al nodo (arg1)

3 : tu segundo argumento al nodo (arg2)

4 : su tercer argumento al nodo (arg3)

sus argumentos reales comienzan desde el 2nd índice de argv Array, que es process.argv[2] .

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.

Sin bibliotecas

Si quieres hacer esto en vanilla JS / ES6 puedes 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 Corrija el código en el mapa y reduzca la función si encuentra una solución más elegante, gracias;);

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 el 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 pregunta qué argumentos está recibiendo y en qué orden.

También puede usar bibliotecas como yargs para trabajar con argumentos de comandline.

como se indica en los documentos del nodo La propiedad process.argv devuelve una matriz que contiene los argumentos de línea de comando 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}`); }); 

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 

La mayoría de la gente ha dado buenas respuestas. También me gustaría contribuir con algo aquí. Proporciono la respuesta usando la biblioteca lodash para iterar a través de todos los argumentos de línea de comandos 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 solo ejecuta los siguientes comandos:

 npm install node index.js xyz abc 123 456 

El resultado será:

 xyz abc 123 456 

process.argv es tu amigo, la captura de líneas de comando args se admite de forma nativa en Node JS. Vea el siguiente ejemplo ::

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

¡También puedes usar el paquete de yargs para que sea mucho más fácil! aquí tienes 🙂 Yargs

Un fragmento simple si alguno lo necesita:

 var fs = require('fs'), objMod = {}; process.argv.slice(2).map(function(y, i) { y = y.split('='); if (y[0] && y[1]) objMod[y[0]] = y[1]; else console.log('Error in argument number ' + (i+1)); });