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




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

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.


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

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"

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

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

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

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

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

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'

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

Documentos oficiales

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.


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

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.


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


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

¡También puedes usar el paquete yargs que hará las cosas mucho más fáciles! aquí tienes :) Yargs


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


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.


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

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.


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.


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.







command-line-arguments