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


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


1764
2017-12-04 01:56


origen


Respuestas:


Método estándar (sin biblioteca)

Los argumentos se almacenan en process.argv

Aquí están el nodo documenta el manejo de los 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

2344
2017-12-04 02:05



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.


472
2018-04-23 23:13



La actualización derecho responder por esto para usar el minimista biblioteca. Solíamos usar node-optimist pero desde entonces ha sido desaprobado.

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

234
2017-07-08 17:26



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:

Minimista: Para un análisis mínimo de argumentos.

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

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


203
2018-01-14 05:26



Optimista (nodo-optimista)

Revisa biblioteca optimista, es mucho mejor que analizar las opciones de línea de comando a mano.

Actualizar

Optimist está en desuso. Tratar Yargs que es una bifurcación activa de optimista.


107
2017-07-04 04:02



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"

68
2017-12-12 05:19



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.


65
2017-09-20 10:20



Biblioteca Stdio

La forma más fácil de analizar argumentos de línea de comandos en NodeJS es usar el stdio módulo. Inspirado por UNIX getopt utilidad, 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 ops objeto 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 en lugar de -o -m.

Además, stdio puede generar una salida de ayuda / uso de forma automática. Si llamas ops.printHelp() obtendrás 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 se especifica mal (por ejemplo, si especifica un único argumento para una opción y necesita 2).

Puedes instalar stdio módulo que usa NPM:

npm install stdio

35
2017-08-13 10:30



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'

28
2018-06-17 00:04



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

Puede establecer opciones usando los estándares de notación principal (aprende más) 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 crea una lista de definiciones de opciones describiendo las opciones que su aplicación acepta. los type propiedad 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 }
]

A continuación, analiza 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 command-line-args 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 comandos y subcomandos (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ía de uso

Una guía de uso (típicamente impresa cuando --help se establece) se puede generar usando uso de línea de comandos. Vea los ejemplos a continuación y lee la documentación para obtener instrucciones sobre cómo crearlos.

Un ejemplo típico de guía de uso.

usage

los polímero-cli la guía de uso es un buen ejemplo de la vida real.

usage

Otras lecturas

Hay mucho más por aprender, ver la wiki para ejemplos y documentación.


19
2017-11-15 16:00