Eu tenho um servidor Web escrito em Node.js e gostaria de iniciar com uma pasta específica. Não sei como acessar argumentos em JavaScript. Estou executando o nó assim:

$ node server.js folder

Aqui server.jsestá o código do meu servidor. A ajuda do Node.js diz que isso é possível:

$ node -h
Usage: node [options] script.js [arguments]

Como eu acessaria esses argumentos em JavaScript? De alguma forma, não consegui encontrar essas informações na web.

Método Padrão (sem biblioteca)

Os argumentos são armazenados em process.argv

Aqui estão os documentos do nó sobre como lidar com argumentos de linha de comando:

process.argvé uma matriz que contém os argumentos da linha de comando. O primeiro elemento será 'node', o segundo elemento será o nome do arquivo JavaScript. Os próximos elementos serão quaisquer argumentos adicionais da linha de comando.

// print process.argv
process.argv.forEach(function (val, index, array) {
  console.log(index + ': ' + val);
});

Isso irá gerar:

$ 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 os argumentos como uma função javascript regular receberia, eu faço isso nos meus scripts de shell node.js.

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

Observe que o primeiro argumento geralmente é o caminho para o nodejs e o segundo argumento é o local do script que você está executando.

A resposta correta atualizada para isso é usar a biblioteca minimista . Costumávamos usar otimista de nós, mas ele foi descontinuado.

Aqui está um exemplo de como usá-lo, retirado diretamente 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' }

Resposta de 2018 com base nas tendências atuais em estado selvagem:

Análise de argumento javascript de baunilha:

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

Isso retorna:

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

Documentos oficiais

Pacotes NPM mais usados ​​para análise de argumento:

Minimista : Para análise mínima de argumentos.

Commander.js : módulo mais adotado para análise de argumentos.

Miau : alternativa mais leve ao Commander.js

Yargs : Análise de argumento mais sofisticada (pesada).

Vorpal.js : aplicativos de linha de comando maduros / interativos com análise de argumento.

Otimista (otimista de nós)

Confira a biblioteca otimista , é muito melhor do que analisar as opções de linha de comando manualmente.

Atualizar

O Optimist está obsoleto. Tente yargs, que é um garfo ativo de otimista.

Várias ótimas respostas aqui, mas tudo parece muito complexo. Isso é muito semelhante ao modo como os scripts bash acessam os valores dos argumentos e já é fornecido como padrão no node.js, como o MooGoo apontou. (Apenas para torná-lo compreensível para alguém novo no node.js)

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"

Commander.js

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

Prontamente

Funciona muito bem para obter informações do usuário, se você gosta da abordagem de retorno de chamada.

Co-Prompt

Funciona muito bem para obter informações do usuário, se você gosta da abordagem do gerador.

Nenhum Libs com sinalizadores formatados em um objeto simples

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

Exemplos

Simples

entrada

node test.js -D --name=Hello

resultado

{ D: true, name: 'Hello' }

Mundo real

entrada

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

resultado

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

Biblioteca Stdio

A maneira mais fácil de analisar argumentos da linha de comandos no NodeJS é usando o módulo stdio . Inspirado no getoptutilitário UNIX , é tão trivial quanto a seguir:

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

Se você executar o código anterior com este comando:

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

O opsobjeto será o seguinte:

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

Então você pode usá-lo como quiser. Por exemplo:

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

As opções agrupadas também são suportadas, para que você possa escrever em -omvez de-o -m .

Além disso, stdiopode gerar uma saída de ajuda / uso automaticamente. Se você ligar, ops.printHelp()obterá 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 uma opção obrigatória não for fornecida (precedida pela mensagem de erro) ou se for especificada incorretamente (por exemplo, se você especificar um único argumento para uma opção e ela precisar de 2).

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

npm install stdio

Se o seu script for chamado myScript.js e você quiser passar o nome e o sobrenome, 'Sean Worthington', como argumentos abaixo:

node myScript.js Sean Worthington

Então, dentro do seu script, você escreve:

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

command-line-args vale uma olhada!

Você pode definir opções usando os principais padrões de notação ( saiba mais ). Esses comandos são todos equivalentes, configurando 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 acessar os valores, primeiro crie uma lista de definições de opções descrevendo as opções que seu aplicativo aceita. A typepropriedade é uma função setter (o valor fornecido é passado por isso), fornecendo controle 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 }
]

Em seguida, analise as opções usando commandLineArgs () :

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

options agora se parece com isso:

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

Uso avançado

Além do uso típico acima, você pode configurar argumentos de linha de comando para aceitar formulários de sintaxe mais avançados.

Sintaxe baseada em comando (estilo git) no formato:

$ executable <command> [options]

Por exemplo.

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

Sintaxe de comando e subcomando (estilo docker) no formato:

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

Por exemplo.

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

Geração de guia de uso

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

Um exemplo típico de guia de uso.

O guia de uso do polímero-cli é um bom exemplo da vida real.

Leitura adicional

Há muito mais para aprender, consulte o wiki para exemplos e documentação.

Existe um aplicativo para isso. Bem, módulo. Bem, mais de um, provavelmente centenas.

Yargs é um dos mais divertidos, seus documentos são legais 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._);

A saída está aqui (lê opções com traços, etc, curto e longo, numérico, 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' ]

Aqui está 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, isso falhará quando o argumento contiver a =. Isso é apenas para uso muito simples.

Provavelmente, é uma boa ideia gerenciar sua configuração de maneira centralizada usando algo como nconf https://github.com/flatiron/nconf

Ajuda a trabalhar com arquivos de configuração, variáveis ​​de ambiente, argumentos da linha de comando.

sem librairies: 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' }

Além disso,

nós podemos mudar

    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

analisar automaticamente Boolean & Number

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

Passar, analisar argumentos é um processo fácil. O Node fornece a propriedade process.argv, que é uma matriz de cadeias, que são os argumentos que foram usados ​​quando o Node foi chamado. A primeira entrada da matriz é o executável do Nó e a segunda entrada é o nome do seu script.

Se você executar o script com os argumentos abaixo

$ node args.js arg1 arg2

Arquivo: args.js

console.log(process.argv)

Você terá uma matriz como

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

npm install ps-grab

Se você deseja executar algo como isto:

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

-

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

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

Explicação:

0 : O diretório do node.exe na sua usinagem (C: \ Arquivos de Programas \ nodejs \ node.exe ')

1: O diretório do seu arquivo de projeto. (proj.js)

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

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

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

seus argumentos reais iniciam o 2ndíndice do argvarray, ou seja process.argv[2].

Você pode acessar argumentos da linha de comando usando system.args. E eu uso a solução abaixo para analisar argumentos em um objeto, para que eu possa obter qual deles 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]});

agora você não precisa conhecer o índice do argumento. use-o comoargs.whatever

Nota: você deve usar argumentos nomeados como file.js x=1 y=2para usar esta solução.

Você pode analisar todos os argumentos e verificar se eles existem.

arquivo: parse-cli-argument.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:

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

Sem bibliotecas

Se você quiser fazer isso no JS / ES6 de baunilha, poderá usar 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 esse 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

ps Corrija o código no mapa e reduza a função se encontrar uma solução mais elegante, obrigado;)

Embora as respostas acima sejam perfeitas e alguém já tenha sugerido yargs, usar o pacote é realmente fácil. Este é um pacote interessante que facilita a transmissão de argumentos para a linha de comando.

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

Visite https://yargs.js.org/ para obter mais informações.

Passar argumentos é fácil, e recebê-los é apenas uma questão de ler o processo.argv array O Node torna acessível de qualquer lugar, basicamente. Mas com certeza você deseja lê-los como pares de chave / valor, portanto precisará de um pedaço de script para interpretá-lo.

Joseph Merdrignac postou um belo usando o método reduzir, mas contava com uma key=valuesintaxe em vez de -k valuee --key value. Eu o reescrevi muito mais feio e mais longo para usar esse segundo padrão, e vou publicá-lo como resposta, porque ele não se encaixa como um comentário. Mas faz o trabalho.

   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
   },{})

Com esse código, um comando node script.js alpha beta -charlie delta --echo foxtrotforneceria o seguinte objeto

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

A maneira mais simples de recuperar argumentos no Node.js é através da matriz process.argv. Este é um objeto global que você pode usar sem importar nenhuma biblioteca adicional para usá-lo. Você simplesmente precisa passar argumentos para um aplicativo Node.js., como mostramos anteriormente, e esses argumentos podem ser acessados ​​no aplicativo por meio da matriz process.argv.

O primeiro elemento da matriz process.argv sempre será um caminho do sistema de arquivos apontando para o nó executável. O segundo elemento é o nome do arquivo JavaScript que está sendo executado. E o terceiro elemento é o primeiro argumento que foi realmente passado pelo usuário.

'use strict';

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

Tudo o que esse script faz é percorrer a matriz process.argv e imprimir os índices, juntamente com os elementos armazenados nesses índices. É muito útil para depuração se você questionar quais argumentos você está recebendo e em que ordem.

Você também pode usar bibliotecas como yargs para trabalhar com argumentos de linha de comunicação.

Solução TypeScript sem 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

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

process.argvé seu amigo, a captura de argumentos de linha de comando é suportada nativamente no Nó JS. Veja o exemplo abaixo:

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

conforme indicado nos documentos do nó A propriedade process.argv retorna uma matriz que contém os argumentos da linha de comandos passados ​​quando o processo Node.js. foi iniciado.

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

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

Ativando o processo Node.js como:

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

Geraria a saída:

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

A maioria das pessoas deu boas respostas. Eu também gostaria de contribuir com algo aqui. Estou fornecendo a resposta usando a lodashbiblioteca para iterar todos os argumentos da linha de comando que transmitimos ao iniciar o aplicativo:

// 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 executar o código acima, basta executar os seguintes comandos:

npm install
node index.js xyz abc 123 456

O resultado será:

xyz 
abc 
123
456

A melhor maneira de passar argumentos de linha de comando para um programa Node.js. é usando uma interface de linha de comando (CLI)

Existe um módulo npm bacana chamado nodejs-cli que você pode usar.

Se você deseja criar um sem dependências, eu tenho um no meu Github, se você quiser conferir, é realmente muito simples e fácil de usar, clique aqui .

Solução sem dependência do 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());