Como passo argumentos de linha de comando para um programa Node.js.


2416

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.

Respostas:


3047

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

7
O que devo digitar no prompt de comando para executar um script node.js com argumentos de linha de comando?
Anderson Green

8
ATUALIZAÇÃO: Encontrei a resposta para a pergunta acima. stackoverflow.com/questions/12925802/…
Anderson Green

2
Minimist é uma grande e simples analisador de argumento
Guilherme Nagatomo

4
Você também pode acessar um único argumento quando você sabe sua posição: process.argv[n]onde né o índice baseado em zero
Luca Steeb

6
o segundo elemento (process.argv [1]) pode ser ou não ser o arquivo js. A sintaxe do comando do nó é node [options] [ -e script | script.js ] [arguments]ou node debug script.js [arguments]. por exemplo: node --harmony script.js balalaou node --no-deprecation --enable-ssl2 script.js balala, podemos usar process.execArgv com process.argv
cuixiping

679

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.


19
Apenas uma observação de que escrevi essa resposta há 4 anos e o código que estou executando ainda está funcionando 100% bem hoje. Ainda mantendo-se atualizado com as versões mais recentes do nó e ainda com zero problemas: é apenas um simples script de shell pessoal. Não faz parte de um grande objeto global cheio de bibliotecas JS. Eu ainda estou por trás da minha resposta hoje. Vou dar outra atualização em mais 4 anos.
Mauvis Ledford

36
@cuixiping mas o execArgvsão não no argvmodo que o 2 é o suficiente
Tommi Kyntola

7
Depois de analisar o histórico de edições desta resposta, gostaria de um momento para simpatizar com @MauvisLedford. Não há nada tão irritante quanto edições não solicitadas no seu código em nome da preferência pessoal (sem benefícios quantificáveis, para inicializar). Para quem faz isso: jogue fora.
Jonathan Dumaine

7
Hey @MauvisLedford já faz mais quatro anos. Eu adoraria uma atualização!
andrew lorien 23/05/19

13
NÃOprocess.argv.splice(process.execArgv.length + 2) : para um comando node --harmony script.js --version, o process.argvé ['/usr/local/bin/node', 'script.js', '--version']. As bandeiras NÃOnode estão incluídas ! process.argv
Константин Ван

360

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

32
Na verdade, esta solução é mais útil para o desenvolvimento de ferramentas de linha de comando com mais sinalizadores e argumentos e deve ser votada mais IMHO.
JK ABC #:

2
Imo, esta é uma alternativa mais simples para npmjs.com/package/command-line-args #
klodoma

5
@JKABC Eu não chamaria isso de a resposta mais correta, pois o OP apenas pede para acessar informações triviais da linha de comando. Mas concordo que os argumentos minimista e de linha de comando são muito úteis se você estiver planejando estender sua CLI.
Justus Romijn 10/09

2
Eu me pergunto por que o '-n5' não produz 'n5: true' - isso faria sentido para mim.
Max Waterman

7
@ MaxWaterman: porque as opções que começam com um único traço são apenas para um único caractere. Tudo o que segue uma única opção char é usado como argumento para a opção (não é necessário espaço). Iniciar a opção com dois hífens (ie --n5) deve produzir 'n5: true'. Esse é um comportamento bastante padrão para a maioria das ferramentas de linha de comando Unix (mas nem todas infelizmente).
Menno Smits

313

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.


76
"$ npm install -g yargs" gerou 1,9 MB de código JavaScript. Quando essa loucura terminará quando uma biblioteca de analisadores argv precisar de dois megabytes de código? Superfície aumentada ataque, RAM desperdiçado etc ...
joonas.fi

9
Yargs é uma ferramenta maior que também analisa argumentos de linha de comando. Sem loucura, apenas falta de informação. Se você quiser algo mais leve, use o JS, Meow ou Minimist bruto.
dthree

1
"$ npm i yargs" -> 800 KB aqui, acho que os proprietários de pacotes finalmente aprenderam a ignorar arquivos irrelevantes. De qualquer forma, ainda grande para projetos bobos, mas pequeno quando você precisa de robustez e em projetos maiores que você já tem dependências ..
Andre Figueiredo

3
Criei um pacote, chamado wily-cli , com o objetivo de tornar uma ferramenta mais poderosa, mais personalizável e mais fácil de usar do que os grandes nomes listados. Para aqueles de vocês que estão interessados, são apenas 94,6 KB na instalação
Jason

1
O custo de importação do vscode me diz que yargs (159.2K) agora é realmente mais leve que o miado (180.2K). O Minimist ainda os vence em 3.4K!
Shivam Tripathi

124

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.


18
+1 para o link. Há uma lista bastante longa de analisadores de opção de linha de comando no github.com/joyent/node/wiki/modules#wiki-parsers-commandline
Thilo

7
Minimista é outro sucessor do otimista agora obsoleto. É "a coragem do analisador de argumentos otimista sem toda a decoração fantasiosa". 23 milhões de downloads no último mês (em 12/2015).
aap

96

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"

80

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.


26
@Evan Carroll, por favor, não edite minha resposta para promover uma biblioteca. Não uso stackoverflow.com/posts/7483600/revisions, especialmente por causa de um recurso ausente que você procura, essas opiniões devem ser salvas para comentários ou receber solicitações para os autores do módulo, não as edições de outras pessoas.
balupton

Commander.js realmente me ajudou. Outras bibliotecas não funcionariam com o compilador nexe, mas esta funciona. Se você deseja obter argumentos ao usar o nexe, certifique-se de passar -f para o compilador nexe.
precisa saber é o seguinte

60

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

1
Como algumas bandeiras têm um formato longo, você pode explicar isso. Em vez de = longArg[1]você poderia escrever = longArg.length > 1 ? longArg[1] : true;Isso iria deixá-lo passar este tipo de argumento:node config/build.js --flag1 --flag2
tralston

Eu gosto disso. Isso fez a linha um pouco longa, então eu terminei. Obrigado por me contar sobre isso.
Michael Warner

54

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

3
De acordo com os TOS da SO, vale mencionar que @sgmonda é o único mantenedor do módulo;) Bom e pequeno módulo, no entanto. Definitivamente útil.
Qix - MONICA FOI ERRADA EM 27/01

1
Realmente útil, embora a atualização mais recente tenha sido em 30 de dezembro de 2014. Pode não ser tão bem mantida quanto alguns outros pacotes.
Fearless_fool

boa lib! tks! apesar de estar sem atualizações recentes .. Ele tem uma funcionalidade suficiente
Pablo Ezequiel

Já faz um tempo, mas eu acabei de lançar a versão 2, com total promessa e suporte para texto datilografado. :-)
sgmonda 19/12/19

47

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'

28

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.

uso

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

uso

Leitura adicional

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


@Loyd, isso está conectado ao problema já levantado - aqui . O Webstorm passa alguns argumentos adicionais.
kboom

@kboom esse problema foi resolvido pelas opções partiale stopAtFirstUnknown. Veja os documentos .
Lloyd

23

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

21

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.


12

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.


E aqui está a configuração , minha própria interface mínima e somente leitura para o nconf.
Joel Purra

12

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

Sua versão mais longa tem um problema com cadeias que contêm pontos.
Berliner

Solução inteligente! E se eu quiser suportar as opções de linha de comando counte c( ccomo um apelido / atalho para count)?
Alex Vang

Isso é lindo! Mas ele não usa o padrão "um traço para uma chave de letra e dois traços para chave de palavra". Infelizmente, minha alternativa é muito longa e feia para postar aqui, então adicionarei como uma resposta diferente.
Isacvale

10

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

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

1
Este repositório não está mais disponível no github.
steadweb

8

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


7

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.


Não é possível fazê-lo funcionar, a mappropriedade é indefinida.
caram 03/02

6

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

4

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


1
eu concordo, mas poderia ser mais curto não? let args = process.argv.slice(2).reduce((acc, arg) => { let [k, v] = arg.split('=') acc[k] = v return acc }, {})
Joseph Merdrignac 13/10

4

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.


Yargs não afeta como os argumentos são transmitidos na linha de comando, apenas ajuda na leitura deles no código.
user3285954

4

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

3

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.


2

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


1

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

0

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

0

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

0

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 .


0

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());
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.