javascript - मैं एक नोडजेस प्रोग्राम में कमांड लाइन तर्क कैसे पास करूं?




node.js arguments (15)

मेरे पास Node.js में लिखा गया एक वेब सर्वर है और मैं एक विशिष्ट फ़ोल्डर के साथ लॉन्च करना चाहता हूं। मुझे यकीन नहीं है कि जावास्क्रिप्ट में तर्कों का उपयोग कैसे करें। मैं इस तरह नोड चला रहा हूँ:

$ node server.js folder

यहां server.js मेरा सर्वर कोड है। Node.js मदद करता है यह कहता है:

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

मैं जावास्क्रिप्ट में उन तर्कों का उपयोग कैसे करूं? किसी भी तरह से मैं इस जानकारी को वेब पर नहीं ढूंढ पाया।

https://code.i-harness.com


librairies के बिना: Array.prototype.reduce () का उपयोग

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

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

}, {})

इस कमांड के लिए node index.js count=2 print debug=false msg=hi

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

भी,

हम बदल सकते हैं

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

द्वारा (बहुत लंबा)

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

ऑटो पार्स बूलियन और संख्या के लिए

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

आशावादी (नोड-आशावादी)

आशावादी लाइब्रेरी देखें , हाथ से कमांड लाइन विकल्पों को पार्स करने से यह काफी बेहतर है।

अद्यतन करें

आशावादी बहिष्कृत है। आशावादी की एक सक्रिय कांटा जो yargs कोशिश करें।


पुस्तकालयों के बिना

यदि आप वेनिला जेएस / ईएस 6 में ऐसा करना चाहते हैं तो आप निम्न समाधान का उपयोग कर सकते हैं

केवल नोडजेएस> 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;
  }, {});

और यह आदेश

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

निम्नलिखित परिणाम देगा

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 कृपया मानचित्र में कोड को सही करें और यदि आपको अधिक सुरुचिपूर्ण समाधान मिल जाए तो धन्यवाद कम करें; धन्यवाद;)


मानक विधि (कोई पुस्तकालय नहीं)

तर्क process.argv में संग्रहीत हैं

कमांड लाइन तर्कों को संभालने पर नोड दस्तावेज़ यहां दिए गए हैं :

process.argv एक सरणी है जिसमें कमांड लाइन तर्क होते हैं। पहला तत्व 'नोड' होगा, दूसरा तत्व जावास्क्रिप्ट फ़ाइल का नाम होगा। अगले तत्व कोई अतिरिक्त कमांड लाइन तर्क होंगे।

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

यह उत्पन्न होगा:

$ 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

Commander.js

अपने विकल्पों, कार्यों और तर्कों को परिभाषित करने के लिए बहुत अच्छा काम करता है। यह आपके लिए सहायता पृष्ठ भी उत्पन्न करता है।

Promptly

यदि आप कॉलबैक दृष्टिकोण पसंद करते हैं, तो उपयोगकर्ता से इनपुट प्राप्त करने के लिए बहुत अच्छा काम करता है।

Co-Prompt

यदि आप जनरेटर दृष्टिकोण पसंद करते हैं, तो उपयोगकर्ता से इनपुट प्राप्त करने के लिए बहुत अच्छा काम करता है।


अगर आपकी स्क्रिप्ट को myScript.js कहा जाता है और आप पहले और अंतिम नाम, 'शॉन वर्थिंगटन' को नीचे दिए गए तर्कों के रूप में पास करना चाहते हैं:

node myScript.js Sean Worthington

फिर अपनी लिपि में आप लिखते हैं:

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

आप system.args का उपयोग कर कमांड लाइन तर्क तक पहुंच सकते हैं। और मैं किसी ऑब्जेक्ट में तर्कों का विश्लेषण करने के लिए नीचे दिए गए समाधान का उपयोग करता हूं, इसलिए मैं इसे प्राप्त कर सकता हूं जिसे मैं नाम से चाहता हूं।

var system = require('system');

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

अब आपको तर्क की अनुक्रमणिका जानने की आवश्यकता नहीं है। इसे args.whatever तरह इस्तेमाल करें। जो args.whatever

नोट: इस समाधान का उपयोग करने के लिए आपको file.js x=1 y=2 जैसे नामांकित तर्कों का उपयोग करना चाहिए।


आप यार्ग पैकेज का भी उपयोग कर सकते हैं इससे चीज बहुत आसान हो जाएगी! यहाँ आप जाओ :) Yargs


इसके लिए एक ऐप है। खैर, मॉड्यूल। खैर, एक से अधिक, शायद सैकड़ों।

Yargs मजेदार लोगों में से एक है, इसके दस्तावेज़ पढ़ने के लिए शांत हैं।

यहां github / npm पृष्ठ से एक उदाहरण दिया गया है:

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

आउटपुट यहां है (यह डैश आदि के साथ विकल्प पढ़ता है, लघु और लंबा, संख्यात्मक आदि)।

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

उत्तीर्ण करना, तर्कों को पार्स करना एक आसान प्रक्रिया है। नोड आपको process.argv प्रॉपर्टी प्रदान करता है, जो तारों की एक सरणी है, जो तर्क हैं जिनका उपयोग नोड को लागू किया गया था। सरणी की पहली प्रविष्टि नोड निष्पादन योग्य है, और दूसरी प्रविष्टि आपकी स्क्रिप्ट का नाम है।

यदि आप नीचे दिए गए स्क्रिप्ट के साथ स्क्रिप्ट चलाते हैं

$ node args.js arg1 arg2

फ़ाइल: args.js

console.log(process.argv)

आपको सरणी मिल जाएगी

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

नियमित जावास्क्रिप्ट फ़ंक्शन जैसे तर्कों को सामान्यीकृत करने के लिए, मैं इसे अपने node.js खोल स्क्रिप्ट में करता हूं:

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

ध्यान दें कि पहला तर्क आम तौर पर नोडज का मार्ग होता है, और दूसरा तर्क उस स्क्रिप्ट का स्थान होता है जिसे आप निष्पादित कर रहे हैं।


यदि कोई आवश्यकता हो तो एक साधारण स्निपेट:

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

command-line-args एक लायक है!

आप मुख्य नोटेशन मानकों का उपयोग करके विकल्प सेट कर सकते हैं (और जानें )। ये आदेश सभी समकक्ष हैं, समान मूल्य निर्धारित करते हैं:

$ 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

मानों तक पहुंचने के लिए, पहले अपने आवेदन स्वीकार करने वाले विकल्पों का वर्णन करने वाले विकल्प परिभाषाओं की एक सूची बनाएं। type संपत्ति एक सेटर फ़ंक्शन है (प्रदान की गई मान इस के माध्यम से पारित की जाती है), जिससे आपको प्राप्त मूल्य पर पूर्ण नियंत्रण मिलता है।

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

इसके बाद, commandLineArgs() का उपयोग कर विकल्पों को पार्स करें:

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

options अब इस तरह दिखते हैं:

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

उन्नत उपयोग

उपर्युक्त सामान्य उपयोग के अलावा, आप अधिक उन्नत वाक्यविन्यास रूपों को स्वीकार करने के लिए कमांड-लाइन-एर्ग कॉन्फ़िगर कर सकते हैं।

फॉर्म में कमांड-आधारित सिंटैक्स (गिट स्टाइल):

$ executable <command> [options]

उदाहरण के लिए।

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

फॉर्म में कमांड और सब-कमांड सिंटैक्स (डॉकर स्टाइल):

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

उदाहरण के लिए।

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

उपयोग गाइड पीढ़ी

एक उपयोग मार्गदर्शिका (आमतौर पर मुद्रित जब --help सेट है) command-line-usage करके उत्पन्न किया जा सकता है। नीचे दिए गए उदाहरण देखें और उन्हें बनाने के निर्देशों के लिए command-line-usage

एक ठेठ उपयोग गाइड उदाहरण।

polymer-cli उपयोग मार्गदर्शिका एक अच्छा असली जीवन उदाहरण है।

आगे की पढाई

सीखने के लिए बहुत कुछ है, कृपया उदाहरण और दस्तावेज़ीकरण के लिए विकी देखें।


Minimist लाइब्रेरी का उपयोग करने के लिए इसका अद्यतित सही उत्तर। हम node-optimist का उपयोग करते थे लेकिन इसे तब से हटा दिया गया है।

यहां न्यूनतम उदाहरण दस्तावेज से सीधे इसका उपयोग करने का एक उदाहरण दिया गया है:

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

npm install ps-grab

यदि आप इस तरह कुछ चलाने के लिए चाहते हैं:

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'




command-line-arguments