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 ejecutando un nodo como este:

$ node server.js folder

Aquí server.jsestá 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

Estos son los documentos de nodo sobre el manejo de argumentos de línea de comando:

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

Para normalizar los argumentos como recibiría una función de 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.

La respuesta correcta actualizada para esto es usar 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' }

Respuesta de 2018 basada en las tendencias actuales en la naturaleza:

Análisis de argumentos de Javascript de vainilla:

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

Paquetes NPM más utilizados para el análisis de argumentos:

Minimista : para análisis de argumentos mínimos.

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 (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 los hilos, que es una bifurcación activa de optimista.

Varias respuestas geniales aquí, pero todo parece muy complejo. Esto es muy similar a cómo los scripts de bash acceden a los valores de los argumentos y ya se proporciona de forma estándar con node.js como 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"

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.

Sin Libs con banderas formateadas en un objeto simple

function getArgs () {
    const args = {};
    process.argv
        .slice(2, process.argv.length)
        .forEach( arg => {
        // long arg
        if (arg.slice(0,2) === '--') {
            const longArg = arg.split('=');
            const longArgFlag = longArg[0].slice(2,longArg[0].length);
            const longArgValue = longArg.length > 1 ? longArg[1] : true;
            args[longArgFlag] = longArgValue;
        }
        // flags
        else if (arg[0] === '-') {
            const flags = arg.slice(1,arg.length).split('');
            flags.forEach(flag => {
            args[flag] = true;
            });
        }
    });
    return args;
}
const args = getArgs();
console.log(args);

Ejemplos

Simple

entrada

node test.js -D --name=Hello

salida

{ D: true, name: 'Hello' }

Mundo real

entrada

node config/build.js -lHRs --ip=$HOST --port=$PORT --env=dev

salida

{ 
  l: true,
  H: true,
  R: true,
  s: true,
  ip: '127.0.0.1',
  port: '8080',
  env: 'dev'
}

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 en la getoptutilidad 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, required: 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 opsobjeto 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 en -omlugar de-o -m .

Además, stdiopuede generar una salida de ayuda / uso automáticamente. Si llama 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 también se muestra si no se proporciona una opción obligatoria (precedida por el mensaje de error) o si está mal especificada (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 desea pasar el nombre y el apellido, 'Sean Worthington', como argumentos 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'

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

Puede establecer opciones utilizando los principales estándares de notación ( más información ). Todos estos comandos son equivalentes y establecen 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 typepropiedad es una función de establecimiento (el valor proporcionado se pasa a través de esto), lo que le brinda 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, analice 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 comandos-line-args para aceptar formas de sintaxis más avanzadas.

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

Guía de uso de generación

Se --helppuede generar una guía de uso (generalmente impresa cuando se configura) usando el uso de la línea de comandos . Vea 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.

La guía de uso de polímero-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.

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

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.

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.

sin bibliotecas: 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 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 analizar automáticamente Boolean & Number

console.log(args) // { count: 2, print: true, debug: false, msg: 'hi' }

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

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 como:

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

-

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

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.

Explicación:

0 : El directorio de node.exe en su mecanizado (C: \ Archivos de programa \ nodejs \ node.exe ')

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

2 : Su primer argumento para el nodo (arg1)

3 : Su segundo argumento para el nodo (arg2)

4 : Su tercer argumento para el nodo (arg3)

sus argumentos reales comienzan el 2ndíndice de forma de la argvmatriz, es decir process.argv[2].

Puede llegar a los argumentos de la línea de comandos usando system.args. Y uso la solución a continuación para analizar los argumentos en un objeto, de modo que pueda 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. úsalo comoargs.whatever

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

Puede analizar todos los argumentos y verificar 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 solo hacer:

var arguments = require('./parse-cli-arguments')(['foo', 'bar', 'xpto']);

Sin bibliotecas

Si desea hacer esto en vanilla JS / ES6, puede usar la siguiente solución

trabajó 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 Por favor, corrija el código en el mapa y reduzca la función si encuentra una solución más elegante, gracias;)

Aunque las respuestas anteriores son perfectas, y alguien ya ha sugerido hilos, usar el paquete es realmente fácil. Este es un paquete agradable que hace que pasar argumentos a la línea de comandos sea realmente fácil.

npm i yargs
const yargs = require("yargs");
const argv = yargs.argv;
console.log(argv);

Visite https://yargs.js.org/ para obtener más información.

Pasar argumentos es fácil, y recibirlos es solo una cuestión de leer el proceso.argv array Node hace accesible desde todas partes, básicamente. Pero seguramente querrá leerlos como pares clave / valor, por lo que necesitará una pieza para escribir para interpretarlo.

Joseph Merdrignac publicó una hermosa usando reduce, pero se basó en una key=valuesintaxis en lugar de -k valuey --key value. Reescribí mucho más feo y largo usar ese segundo estándar, y lo publicaré como respuesta porque no encajaría como comentario. Pero hace el trabajo.

   const args = process.argv.slice(2).reduce((acc,arg,cur,arr)=>{
     if(arg.match(/^--/)){
       acc[arg.substring(2)] = true
       acc['_lastkey'] = arg.substring(2)
     } else
     if(arg.match(/^-[^-]/)){
       for(key of arg.substring(1).split('')){
         acc[key] = true
         acc['_lastkey'] = key
       }
     } else
       if(acc['_lastkey']){
         acc[acc['_lastkey']] = arg
         delete acc['_lastkey']
       } else
         acc[arg] = true
     if(cur==arr.length-1)
       delete acc['_lastkey']
     return acc
   },{})

Con este código, un comando node script.js alpha beta -charlie delta --echo foxtrotle daría el siguiente objeto

args = {
 "alpha":true,
 "beta":true,
 "c":true,
 "h":true,
 "a":true,
 "r":true
 "l":true,
 "i":true,
 "e":"delta",
 "echo":"foxtrot"
}

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

También puede usar bibliotecas como yargs para trabajar con argumentos de línea de comandos.

Solución TypeScript sin bibliotecas:

interface IParams {
  [key: string]: string
}

function parseCliParams(): IParams {
  const args: IParams = {};
  const rawArgs = process.argv.slice(2, process.argv.length);
  rawArgs.forEach((arg: string, index) => {
    // Long arguments with '--' flags:
    if (arg.slice(0, 2).includes('--')) {
      const longArgKey = arg.slice(2, arg.length);
      const longArgValue = rawArgs[index + 1]; // Next value, e.g.: --connection connection_name
      args[longArgKey] = longArgValue;
    }
    // Shot arguments with '-' flags:
    else if (arg.slice(0, 1).includes('-')) {
      const longArgKey = arg.slice(1, arg.length);
      const longArgValue = rawArgs[index + 1]; // Next value, e.g.: -c connection_name
      args[longArgKey] = longArgValue;
    }
  });
  return args;
}

const params = parseCliParams();
console.log('params: ', params);

Entrada: ts-node index.js -p param --parameter parameter

Salida: { p: 'param ', parameter: 'parameter' }

process.argves su amigo, la captura de argumentos de línea de comandos se admite de forma nativa en Node JS. Ver ejemplo a continuación ::

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

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 pasados ​​cuando se inició el proceso Node.js.

Por ejemplo, suponiendo 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 las personas han dado buenas respuestas. También me gustaría contribuir con algo aquí. Estoy proporcionando la respuesta usando la lodashbiblioteca para iterar a través de todos los argumentos de línea de comando 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, simplemente ejecute los siguientes comandos:

npm install
node index.js xyz abc 123 456

El resultado será:

xyz 
abc 
123
456

La mejor manera de pasar argumentos de línea de comandos a un programa Node.js es mediante el uso de una interfaz de línea de comandos (CLI)

Hay un ingenioso módulo npm llamado nodejs-cli que puede usar.

Si quieres crear uno sin dependencias, tengo uno en mi Github si quieres comprobarlo, en realidad es bastante simple y fácil de usar, haz clic aquí .

Solución sin dependencias de estilo ES6:

const longArgs = arg => {
    const [ key, value ] = arg.split('=');
    return { [key.slice(2)]: value || true }
};

const flags = arg => [...arg.slice(1)].reduce((flagObj, f) => ({ ...flagObj, [f]: true }), {});


const args = () =>
    process.argv
        .slice(2)
        .reduce((args, arg) => ({
            ...args,
            ...((arg.startsWith('--') && longArgs(arg)) || (arg[0] === '-' && flags(arg)))
        }), {});

console.log(args());