javascript - pass - ¿Cómo paso los argumentos de la línea de comandos a un programa Node.js?
parse args node (26)
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 corriendo 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 puedo acceder a esos argumentos en JavaScript? De alguna manera no pude encontrar esta información en la web.
2018 respuesta basada en las tendencias actuales en la naturaleza:
Análisis de argumento 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'']
Los paquetes NPM más utilizados para el análisis de argumentos:
Minimist : Para análisis de argumentos mínimos.
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.
Biblioteca stdio
La forma más fácil de analizar los argumentos de la línea de comandos en NodeJS es usar el módulo stdio . Inspirado en 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 <your_script.js> -c 23 45 --map -k 23 file1 file2
Entonces el objeto de ops será el siguiente:
{ check: [ ''23'', ''45'' ],
args: [ ''file1'', ''file2'' ],
map: true,
kaka: ''23'' }
Así que 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 una salida de ayuda / uso automáticamente. Si llama a 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 se muestra también si no se da una opción obligatoria (precedida por el mensaje de error) o si se especifica erróneamente (por ejemplo, si especifica un solo argumento para una opción y necesita 2).
Puedes instalar el módulo stdio usando NPM :
npm install stdio
Método estándar (sin biblioteca)
Los argumentos se almacenan en process.argv
Aquí están los documentos del nodo sobre el manejo de la línea de comando args:
process.argves una matriz que contiene los argumentos de la línea de comandos. El primer elemento será ''nodo'', el segundo elemento será el nombre del archivo JavaScript. Los siguientes elementos serán los 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
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 yargs que es un activo tenedor de optimista.
Sin bibliotecas
Si desea hacer esto en vainilla JS / ES6 puede usar la siguiente solución
trabajado 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;)
Sin bibliotecas: utilizando 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 auto-analizar booleano y número
console.log(args) // { count: 2, print: true, debug: false, msg: ''hi'' }
Commander.js
Funciona muy bien para definir sus opciones, acciones y argumentos. También genera las páginas de ayuda para ti.
Promptly
Funciona muy bien para obtener información del usuario, si te 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.
¡También puedes usar el paquete yargs que hará las cosas mucho más fáciles! aquí tienes :) Yargs
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 uso muy simple.
Hay una aplicación para eso. Bueno, módulo. Bueno, más de uno, probablemente cientos.
Yargs es uno de los 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'' ]
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 debe pasar los argumentos a una aplicación Node.js, tal como lo 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 nodo ejecutable. El segundo elemento es el nombre del archivo JavaScript que se está ejecutando. Y el tercer elemento es el primer argumento que realmente fue pasado por 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 cuestiona qué argumentos está recibiendo y en qué orden.
También puede usar bibliotecas como yargs para trabajar con argumentos de línea de comunicación.
La mayoría de las personas han dado buenas respuestas. También me gustaría aportar algo aquí. Estoy proporcionando la respuesta utilizando la biblioteca lodash para recorrer todos los argumentos de la línea de comandos que lodash 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 ejecuta los siguientes comandos:
npm install
node index.js xyz abc 123 456
El resultado será:
xyz
abc
123
456
La respuesta correcta actualizada para esto es usar la biblioteca Minimist . Solíamos usar el 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'' }
Para normalizar los argumentos como 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.
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 utilizaron 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 script con los siguientes atguments
$ node args.js arg1 arg2
Archivo: args.js
console.log(process.argv)
Obtendrá una matriz como
[''node'',''args.js'',''arg1'',''arg2'']
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.
Puedes analizar todos los argumentos y comprobar 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 acaba de hacer:
var arguments = require(''./parse-cli-arguments'')([''foo'', ''bar'', ''xpto'']);
Puedes llegar a los argumentos de la línea de comando usando system.args . Y utilizo la solución a continuación para analizar los argumentos en un objeto, así 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 necesitas saber el índice del argumento. args.whatever como args.whatever
Nota: debe usar argumentos con nombre como
file.js x=1 y=2para usar esta solución.
Si su script se llama myScript.js y desea pasar el nombre y apellido, ''Sean Worthington'', como se indica 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''
Un simple fragmento de código si 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));
});
Vale la pena echar un vistazo a la command-line-args !
Puede establecer opciones utilizando los estándares de notación principales ( 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 de establecimiento (el valor suministrado se pasa a través de esto), 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, commandLineArgs() 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 la línea de comandos para aceptar formularios de sintaxis más avanzados.
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 puede generar una guía de uso (que normalmente se imprime cuando se configura la --help ) utilizando el uso command-line-usage . Vea los ejemplos a continuación y command-line-usage para obtener instrucciones sobre cómo crearlos.
Un ejemplo típico de guía de uso.
La guía de uso de polymer-cli es un buen ejemplo de la vida real.
Otras lecturas
Hay mucho más que aprender, consulte la wiki para ver ejemplos y documentación.
Varias grandes respuestas aquí, pero todo parece muy complejo. Esto es muy similar a la forma en que los scripts de bash acceden a los valores de los argumentos y ya se proporcionó de forma estándar con node.js, como lo 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"
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 que se pasaron 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}`);
});
Lanzar 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
process.argv es tu amigo, la captura de líneas de comandos args se admite de forma nativa en Node JS. Vea el ejemplo a continuación:
process.argv.forEach((val, index) => {
console.log(`${index}: ${val}`);
})
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.
Explicacion
0 : El directorio de node.exe en su mecanización (C: / Archivos de programa / nodejs / node.exe '')
1 : El directorio de su archivo de proyecto. (proj.js)
2 : Tu primer argumento al nodo (arg1)
3 : Su segundo argumento al nodo (arg2)
4 : su tercer argumento al nodo (arg3)
sus argumentos reales comienzan desde el 2nd índice de la matriz argv , que es process.argv[2] .
npm install ps-grab
Si quieres correr 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''