Para normalizar os argumentos como uma função normal de javascript receberia, faço isto no meu nó.programas de consola js:

var args = process.argv.slice(2);

Note que o primeiro arg é geralmente o caminho para nodejs, e o segundo arg é a localização do script que você está executando.

A resposta actualizada à direita para isto é usar a biblioteca minimista . Nós usávamos o node-optimist mas desde então foi depreciado.

Aqui está um exemplo de como usá-lo retirado directamente da documentação 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' }

2018 resposta baseada nas tendências actuais no estado selvagem:

Vanilla javascript argument parsing:

const args = process.argv;
console.log(args);

Isto devolve:

$ node server.js one two=three four
['node', '/home/server.js', 'one', 'two=three', 'four']

Documentos oficiais

Os pacotes NPM mais usados para análise de argumentos:

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

Comandante.js: a maioria dos módulos adotados para análise de argumentos.

Miau: alternativa mais leve para Comandante.js

Yargs: análise de argumentos mais sofisticada (pesada).

Vorpal.js: aplicações Maduras / interactivas da linha de comandos com análise de argumentos.

Optimist (node-optimist)

Check out Optimist library , it is much better than parsing command line options by hand.

Actualizar

O optimista está desacreditado. Tente yargs que é um garfo activo do optimista.

Exemplo:

$ 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"

Comandante.js

Funciona muito bem para definir as suas opções, acções e argumentos. Ele também gera as páginas de Ajuda para você.

Prontamente

Funciona muito bem para obter dados do utilizador, se Gostar da abordagem de callback.

Co-Prompt

Funciona bem para obter a entrada do Usuário, se você gosta da aproximação do gerador.

Biblioteca De Stdio

A maneira mais fácil de analisar os argumentos da linha de comandos no NodeJS é usar o módulo stdio. Inspirado pelo utilitário UNIX getopt, é tão trivial como se segue:

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

Se executar o código anterior com este comando:

node <your_script.js> -c 23 45 --map -k 23 file1 file2

Então ops o objecto será o seguinte:

{ check: [ '23', '45' ],
  args: [ 'file1', 'file2' ],
  map: true,
  kaka: '23' }

if (ops.kaka && ops.check) {
    console.log(ops.kaka + ops.check[0]);
}

As opções agrupadas também são suportadas, por isso você pode escrever -om em vez de -o -m.

Além disso, stdio pode gerar uma saída de Ajuda/utilização automaticamente. Se ligar para ops.printHelp() receberá o seguinte:

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

A mensagem anterior é mostrada também se não for indicada uma opção obrigatória (precedida pela mensagem de erro) ou se for incorrecto (por exemplo, se indicar um único arg para uma opção e precisar de 2).

Você pode instalar o stdio com o módulo NPM:

npm install stdio

node myScript.js Sean Worthington

Depois, no seu guião, escreve:

var firstName = process.argv[2]; // Will be set to 'Sean'
var lastName = process.argv[3]; // Will be set to 'Worthington'

A linha de comando-args vale a pena ver!

Você pode definir opções usando os principais padrões de notação (saiba mais). Estes comandos são todos equivalentes, definindo os mesmos 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 aceder aos valores, primeiro crie uma lista de definições de opções descrevendo as opções que a sua aplicação Aceita. O type a propriedade é uma função de setter( o valor fornecido é passado por isto), dando-lhe o controlo total sobre o valor recebido.

const optionDefinitions = [
  { name: 'verbose', alias: 'v', type: Boolean },
  { name: 'src', type: String, multiple: true, defaultOption: true },
  { name: 'timeout', alias: 't', type: Number }
]

A seguir, analisa as opções usando as linhas de comandos():

const commandLineArgs = require('command-line-args')
const options = commandLineArgs(optionDefinitions)

options agora parece isto:

{
  src: [
    'one.js',
    'two.js'
  ],
  verbose: true,
  timeout: 1000
}

Utilização avançada

Ao lado da utilização típica acima, poderá configurar a linha de comandos-args para aceitar formas de sintaxe mais avançadas.

Sintaxe baseada em comandos (estilo git) na forma:

$ executable <command> [options]

Por exemplo.

$ git commit --squash -m "This is my commit message"

A sintaxe do comando e Sub-comando (estilo docker) no formulário:

$ executable <command> [options] <sub-command> [options]

Por exemplo.

$ docker run --detached --image centos bash -c yum install -y httpd

Geração do Guia de Utilização

Um guia de Utilização (normalmente impresso quando --help está definido) pode ser gerado usando a utilização da linha de comandos . Veja os exemplos abaixo e leia a documentação para obter instruções sobre como criá-los.

Um exemplo típico de guia de Utilização.

O Guia de Utilização do polímero-cli é um bom exemplo da vida real.

Além disso Leitura

Há muito mais para aprender, por favor veja o wiki para exemplos e documentação.

Yargs é um dos mais divertidos, os seus documentos são Fixes de ler.

Aqui está um exemplo da página github / npm:

#!/usr/bin/env node
var argv = require('yargs').argv;
console.log('(%d,%d)', argv.x, argv.y);
console.log(argv._);

O resultado está aqui (lê as opções com traços, etc, curtos e longos, 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' ]

É provavelmente uma boa idéia para gerenciar sua configuração de forma centralizada, usando algo como nconf https://github.com/flatiron/nconf

Ajuda-o a trabalhar com ficheiros de configuração, variáveis de ambiente, argumentos da linha de comandos.

Se executar o programa com atgumments abaixo

$ node args.js arg1 arg2

Ficheiro : args.js

console.log(process.argv)

Você vai ter array como

 ['node','args.js','arg1','arg2']

Whithout librairies: usando Array.prototipo.reduzir ()

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

Também,

    let [k, v = true] = arg.split('=')
    acc[k] = v

Por (muito mais tempo)

    let [k, v] = arg.split('=')
    acc[k] = v === undefined ? true : /true|false/.test(v) ? v === 'true' : /[\d|\.]+/.test(v) ? Number(v) : v

Para analisar automaticamente o & número booleano

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

Pode analisar todos os argumentos e verificar se existem.

Ficheiro: analisar-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;
}

Do que apenas fazer:

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

npm install ps-grab

Se queres fazer algo assim:

node greeting.js --user Abdennour --website http://abdennoor.com 

--

var grab=require('ps-grab');
grab('--username') // return 'Abdennour'
grab('--action') // return 'http://abdennoor.com'

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

--

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

Poderá chegar aos argumentos da linha de comandos usando system.args. E eu uso a solução abaixo para analisar argumentos em um objeto, para que eu possa obter qual eu quero pelo nome.

var system = require('system');

var args = {};
system.args.map(function(x){return x.split("=")})
    .map(function(y){args[y[0]]=y[1]});

Nota: deve usar argumentos com nomes como file.js x=1 y=2 para usar solucao.

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.

Explicação:

0 : o directório do nó.exe in your maching (C:\Program ficheiros\nodejs\node.exe')

1 : o directório do seu ficheiro de projecto. (proj.js)

2 : o seu primeiro argumento para o nó (arg1)

3 : o seu segundo argumento para o nó (arg2)

4 : o seu terceiro argumento para o nó (arg3)

Os seus argumentos actuais iniciam o formulário 2nd Índice de argv, isto é process.argv[2].

Aqui está a minha solução 0-dep para argumentos nomeados:

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)

Exemplo:

$ node test.js foo=bar fizz=buzz
bar
buzz

Nota: naturalmente isto irá falhar quando o argumento contiver um =. Isto é apenas para uso muito simples.

Sem bibliotecas

Se quiser fazer isto em vanilla JS / ES6 pode utilizar a seguinte solução

Trabalhou apenas em 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;
  }, {});

E este comando

node index.js host=http://google.com port=8080 production

Produzirá o seguinte 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

P. S. Por favor, corrija o código no mapa e reduza a função se você encontrar uma solução mais elegante, obrigado;)

A forma mais simples de obter argumentos no nó.js é através do processo.array argv. Este é um objeto global que você pode usar sem importar bibliotecas adicionais para usá-lo. Você simplesmente precisa passar argumentos para um nó.aplicação js, como mostramos anteriormente, e esses argumentos podem ser acessados dentro da aplicação através do processo.array argv.

O primeiro elemento do processo.argv array será sempre um caminho do sistema de arquivos apontando para o executável do nó. Segundo elemento é o nome do arquivo JavaScript que está sendo executado. E o terceiro elemento é o primeiro argumento que foi realmente aprovado pelo Usuário.

'use strict';

for (let j = 0; j < process.argv.length; j++) {  
    console.log(j + ' -> ' + (process.argv[j]));
}

Tudo o que este script faz é circular através do processo.argv array e imprime os índices, juntamente com os elementos armazenados nesses índices. É muito útil para depuração se você alguma vez questionar que argumentos você está recebendo, e em que ordem.

Você também pode usar bibliotecas como yargs para trabalhar com argumentos commnadline.

Tal como indicado nos documentos do nó Processo.a propriedade argv devolve uma lista que contém os argumentos da linha de comandos passados quando o nó.o processo js foi lançado.

Por exemplo, assumindo o seguinte script para process-args.js:

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

 $ node process-args.js one two=three four

Iria gerar o resultado:

0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: four

// 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 correr acima do Código, basta executar os seguintes comandos:

npm install
node index.js xyz abc 123 456

O resultado será:

xyz 
abc 
123
456

process.argv é seu amigo, capturar linha de comando args é nativamente suportado no nó JS. Ver exemplo abaixo:

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

Você também pode usar yargs pacote que vai tornar as coisas muito mais fácil! aqui tens.

Um excerto simples, se for necessário:

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