Como passo os argumentos da linha de comando para um nó.programa js?
tenho um servidor web escrito em nó.js e eu gostaria de lançar com uma pasta específica. Não sei como aceder a argumentos em JavaScript. Estou a executar um nó como este:
$ node server.js folder
Aqui está o meu código do servidor. No.js help diz que isto é possível:
$ node -h
Usage: node [options] script.js [arguments]
Como acederia a esses argumentos em JavaScript? De alguma forma, não consegui encontrar esta informação na web.
26 answers
Método Padrão (sem Biblioteca)
Os argumentos são armazenados em process.argv
Aqui estão os documentos do nó na linha de comandos args:
process.argv
é uma lista que contém os argumentos da linha de comandos. 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);
});
Isto 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 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']
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' }
Então podes usá-lo como quiseres. Por exemplo:
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,
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
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'
Ou algo do género:
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]});
Agora não precisas de saber o índice do argumento. usa-o como args.whatever
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}`);
});
A lançar o nó.processo js como:
$ 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
para iterar todos os argumentos da linha de comandos que passamos ao iniciar a aplicação:
// 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));
});