Node.js ile yazılmış bir web sunucum var ve belirli bir klasörle başlatmak istiyorum. JavaScript'te bağımsız değişkenlere nasıl erişeceğinizden emin değilim. Böyle bir düğümü çalıştırıyorum:

$ node server.js folder

işte server.jsbenim sunucu kodum. Node.js yardımı bunun mümkün olduğunu söylüyor:

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

JavaScript'te bu bağımsız değişkenlere nasıl erişebilirim? Bir şekilde bu bilgiyi web'de bulamadım.

Standart Yöntem (kütüphane yok)

Bağımsız değişkenler process.argv

Komut satırı bağımsız değişkenlerini işlemede kullanılan düğüm belgeleri şunlardır :

process.argvkomut satırı bağımsız değişkenlerini içeren bir dizidir. İlk öğe 'düğüm', ikinci öğe JavaScript dosyasının adı olacaktır. Sonraki öğeler herhangi bir ek komut satırı bağımsız değişkeni olacaktır.

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

Bu aşağıdakileri üretecektir:

$ 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

Normal bir javascript işlevi alacağı gibi bağımsız değişkenleri normalleştirmek için bunu node.js kabuk komut dosyalarında yaparım:

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

İlk argüman genellikle nodejs yoludur ve ikinci argüman yürüttüğünüz komut dosyasının konumudur.

Minimist kütüphaneyi kullanması için güncel doğru cevap . Biz kullanmak için kullanılan düğüm-iyimser ama beri kaldırılmıştır.

İşte doğrudan minimist belgelerden alınan bir örnek:

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

Doğada mevcut eğilimlere dayanan 2018 cevabı:

Vanilya javascript argüman ayrıştırma:

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

Bu döndürür:

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

Resmi dokümanlar

Bağımsız değişken ayrıştırma için en çok kullanılan NPM paketleri:

Minimist : Minimum argüman ayrıştırma için.

Commander.js : Bağımsız değişken ayrıştırma için en çok benimsenen modül.

Miyav : Commander.js'ye daha hafif bir alternatif

Yargs : Daha karmaşık argüman ayrıştırma (ağır).

Vorpal.js : Bağımsız değişken ayrıştırmalı olgun / etkileşimli komut satırı uygulamaları.

İyimser (düğüm iyimser)

İyimser kitaplığı kontrol edin , komut satırı seçeneklerini elle ayrıştırmaktan çok daha iyidir.

Güncelleme

İyimser kullanımdan kaldırıldı. İyimserlerin aktif bir çatalı olan iplikleri deneyin .

Burada birkaç harika cevap var, ama hepsi çok karmaşık görünüyor. Bu, bash komut dosyalarının bağımsız değişken değerlerine nasıl eriştiğine çok benzer ve MooGoo'nun işaret ettiği gibi zaten node.js ile standart olarak sağlanmıştır. (Sadece node.js için yeni olan biri tarafından anlaşılabilir olması için)

Misal:

$ 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

Seçeneklerinizi, eylemlerinizi ve bağımsız değişkenlerinizi tanımlamak için harika çalışır. Ayrıca sizin için yardım sayfaları oluşturur.

Derhal

Geri arama yaklaşımını beğendiyseniz, kullanıcıdan girdi almak için harika çalışır.

Eş İstemi

Jeneratör yaklaşımını beğenirseniz, kullanıcıdan girdi almak için harika çalışır.

Basit Bir Nesneye Biçimlendirilmiş Bayraklı Lib yok

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

Örnekler

Basit

giriş

node test.js -D --name=Hello

çıktı

{ D: true, name: 'Hello' }

Gerçek dünya

giriş

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

çıktı

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

Stdio Kütüphanesi

NodeJS'de komut satırı bağımsız değişkenlerini ayrıştırmanın en kolay yolu stdio modülünü kullanmaktır. UNIX getopthizmetinden esinlenerek , aşağıdaki gibi önemsizdir:

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

Önceki kodu bu komutla çalıştırırsanız:

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

Sonra opsnesne aşağıdaki gibi olacaktır:

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

Böylece istediğiniz gibi kullanabilirsiniz. Örneğin:

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

Gruplanmış seçenekler de desteklenir, -ombunun yerine yazabilirsiniz -o -m.

Ayrıca, stdiootomatik olarak bir yardım / kullanım çıktısı oluşturabilir. Aradığınızda şunları ops.printHelp()elde edersiniz:

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

Önceki mesaj, zorunlu bir seçenek verilmemişse (hata iletisinden önce gelirse) veya yanlış tanımlanmışsa (örneğin, bir seçenek için tek bir bağımsız değişken belirtirseniz ve 2 gerekiyorsa) da gösterilir.

Stdio modülünü NPM kullanarak kurabilirsiniz :

npm install stdio

Komut dosyanız myScript.js olarak adlandırılmışsa ve aşağıdaki gibi bağımsız değişkenler olarak 'Sean Worthington' adını ve soyadını geçirmek istiyorsanız:

node myScript.js Sean Worthington

Sonra senaryonuza şunları yazabilirsiniz:

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

komut satırı-args bir göz atmaya değer!

Ana gösterim standartlarını kullanarak seçenekler belirleyebilirsiniz ( daha fazla bilgi edinin ). Bu komutların tümü eşdeğerdir ve aynı değerleri ayarlar:

$ 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

Değerlere erişmek için önce uygulamanızın kabul ettiği seçenekleri açıklayan bir seçenek tanımları listesi oluşturun . typeÖzelliğiniz alınan değerin üzerinde tam kontrol veren bir ayarlayıcı işlevi (bu geçirilir verilen değer) vardır.

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

Ardından, commandLineArgs () öğesini kullanarak seçenekleri ayrıştırın :

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

options şimdi şöyle görünüyor:

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

Gelişmiş kullanım

Yukarıdaki tipik kullanımın yanı sıra, komut satırı bağımsız değişkenlerini daha gelişmiş sözdizimi formlarını kabul edecek şekilde yapılandırabilirsiniz.

Formdaki komut tabanlı sözdizimi (git stili):

$ executable <command> [options]

Örneğin.

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

Formdaki komut ve alt komut sözdizimi (docker stili):

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

Örneğin.

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

Kullanım kılavuzu oluşturma

Komut satırı kullanımı--help kullanılarak bir kullanım kılavuzu (genellikle ayarlandığında yazdırılır ) oluşturulabilir . Aşağıdaki örneklere bakın ve bunları oluşturma talimatları için belgeleri okuyun .

Tipik bir kullanım kılavuzu örneği.

Polimer-cli kullanım kılavuzu iyi bir gerçek yaşam örneğidir.

Daha fazla okuma

Öğrenecek daha çok şey var, örnekler ve belgeler için lütfen wiki'ye bakın .

Bunun için bir uygulama var. Pekala, modül. Birden fazla, muhtemelen yüzlerce.

Yargs eğlenceli olanlardan biri, belgeleri okumak için havalı.

İşte github / npm sayfasından bir örnek:

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

Çıktı burada (kısa çizgi, kısa çizgi, sayısal vb. İle seçenekleri okur).

$ ./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' ]

İşte adlandırılmış argümanlar için 0-dep çözüm:

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)

Misal:

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

Not: Doğal olarak bu, bir argüman a içerdiğinde başarısız olur =. Bu sadece çok basit kullanım içindir.

Yapılandırmanızı nconf gibi bir şey kullanarak merkezi bir şekilde yönetmek muhtemelen iyi bir fikirdir https://github.com/flatiron/nconf

Yapılandırma dosyaları, ortam değişkenleri, komut satırı bağımsız değişkenleri ile çalışmanıza yardımcı olur.

kütüphaneler olmadan: Array.prototype.reduce () kullanma

const args = process.argv.slice(2).reduce((acc, arg) => {

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

}, {})

bu komut için node index.js count=2 print debug=false msg=hi

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

Ayrıca,

Değiştirebiliriz

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

tarafından (çok daha uzun)

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

Boole ve Sayıları otomatik olarak ayrıştırmak için

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

Geçmek, argümanları ayrıştırmak kolay bir süreçtir. Düğüm, Düğüm çağrıldığında kullanılan bağımsız değişkenler olan bir dizeler dizisi olan process.argv özelliğini sağlar. Dizinin ilk girdisi Düğüm yürütülebiliridir ve ikinci girdisi komut dosyanızın adıdır.

Komut dosyasını aşağıdaki atguments ile çalıştırırsanız

$ node args.js arg1 arg2

Dosya: args.js

console.log(process.argv)

Gibi dizi alacaksınız

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

npm install ps-grab

Böyle bir şey çalıştırmak istiyorsanız:

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

-

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

Ya da şöyle bir şey:

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"

Sonuç:

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.

Açıklama:

0 : Makinenizdeki node.exe dizini (C: \ Program Files \ nodejs \ node.exe ')

1: Proje dosyanızın dizini. (Proj.js)

2 : Düğüme ilk argümanınız (arg1)

3 : Düğüme ikinci argümanınız (arg2)

4 : Düğüme üçüncü argümanınız (arg3)

gerçek argümanlarınız dizinin 2nddizinini oluşturur argv, yani process.argv[2].

Komut satırı bağımsız değişkenlerine ile erişebilirsiniz system.args. Ve bir nesneye bağımsız değişkenler ayrıştırmak için aşağıdaki çözümü kullanın, böylece adıyla istediğim alabilirsiniz.

var system = require('system');

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

şimdi argümanın dizinini bilmenize gerek yok. gibi kullanargs.whatever

Not: file.js x=1 y=2Bu çözümü kullanmak için adlandırılmış bağımsız değişkenler kullanmalısınız.

Tüm argümanları ayrıştırabilir ve var olup olmadığını kontrol edebilirsiniz.

dosya: parse-cli-arguments.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;
}

Sadece yapmaktan:

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

Kütüphanesiz

Bunu vanilya JS / ES6'da yapmak istiyorsanız aşağıdaki çözümü kullanabilirsiniz

sadece NodeJS'de çalıştı > 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;
  }, {});

Ve bu komut

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

aşağıdaki sonucu verecektir

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 Haritadaki kodu düzeltin ve daha zarif bir çözüm bulursanız işlevi azaltın, teşekkürler;)

Yukarıdaki cevaplar mükemmel olsa da ve birisi zaten iplikler önerdi, paketi kullanmak gerçekten çok kolay. Bu, komut satırına argüman aktarmayı gerçekten kolaylaştıran güzel bir paket.

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

Daha fazla bilgi için lütfen https://yargs.js.org/ adresini ziyaret edin .

Bağımsız değişkenleri iletmek kolaydır ve bunları almak sadece process.argv dizisinin okunmasıyla ilgilidir. Düğüm temelde her yerden erişilebilir hale gelir. Ancak bunları anahtar / değer çiftleri olarak okumak istediğinizden eminiz, bu yüzden yorumlamak için komut dosyası yazmak için bir parçaya ihtiyacınız olacaktır.

Joseph Merdrignac azaltma kullanarak güzel bir yayın gönderdi, ancak key=valueyerine bir sözdizimine güveniyordu .-k value ve--key value . Bu ikinci standardı kullanmak çok daha çirkin ve daha uzun bir süre yeniden yazdım ve bir yorum olarak uymayacağı için cevap olarak göndereceğim. Ama işi hallediyor.

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

Bu kodla bir komut node script.js alpha beta -charlie delta --echo foxtrotsize aşağıdaki nesneyi verir:

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

Node.js'de argüman almanın en basit yolu process.argv dizisidir. Bu, kullanmak için herhangi bir ek kitaplığı içe aktarmadan kullanabileceğiniz global bir nesnedir. Daha önce gösterdiğimiz gibi bir Node.js uygulamasına argüman iletmeniz yeterlidir ve bu argümanlara process.argv dizisi aracılığıyla uygulama içinden erişilebilir.

Process.argv dizisinin ilk öğesi her zaman çalıştırılabilir düğüme işaret eden bir dosya sistemi yolu olacaktır. İkinci öğe, yürütülmekte olan JavaScript dosyasının adıdır. Ve üçüncü eleman, aslında kullanıcı tarafından iletilen ilk argüman.

'use strict';

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

Tüm bu komut dosyası process.argv dizisi arasında döngü yapar ve bu dizinlerde depolanan öğelerle birlikte dizinleri yazdırır. Hangi argümanları ve hangi sırayla aldığınızı sorgularsanız hata ayıklama için çok kullanışlıdır.

Commnadline argümanlarıyla çalışmak için yargs gibi kütüphaneleri de kullanabilirsiniz.

Kütüphanesi olmayan TypeScript çözümü:

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

Giriş: ts-node index.js -p param --parameter parameter

Çıktı: { p: 'param ', parameter: 'parameter' }

process.argvarkadaşınızsa, komut satırı argümanlarını yakalamak Düğüm JS'de yerel olarak desteklenir. Aşağıdaki örneğe bakın ::

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

process.argv özelliği, Node.js işlemi başlatıldığında iletilen komut satırı bağımsız değişkenlerini içeren bir dizi döndürür.

Örneğin, process-args.js için aşağıdaki komut dosyasını varsayarak:

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

Node.js işlemini şu şekilde başlatmak:

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

Çıktı oluşturur:

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

İnsanların çoğu iyi cevaplar verdi. Burada da bir şeyler yapmak istiyorum. lodashUygulamayı başlatırken geçirdiğimiz tüm komut satırı bağımsız değişkenlerini yinelemek için kitaplığı kullanarak yanıt sağlıyorum :

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

Yukarıdaki kodu çalıştırmak için aşağıdaki komutları çalıştırın:

npm install
node index.js xyz abc 123 456

Sonuç:

xyz 
abc 
123
456

Komut satırı bağımsız değişkenlerini bir Node.js programına geçirmenin en iyi yolu bir Komut Satırı Arabirimi (CLI) kullanmaktır

Kullanabileceğiniz nodejs-cli adlı şık bir npm modülü var .

Bağımlılığı olmayan bir tane oluşturmak istiyorsanız Github'ımda bir tane var, kontrol etmek istiyorsanız, aslında oldukça basit ve kullanımı kolaydır, buraya tıklayın .

ES6 tarzı bağımlılık yok çözümü:

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