javascript - receive - yargs




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

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.

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.


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

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


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


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


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

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

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

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'




command-line-arguments