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




node.js arguments (18)

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'

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

$ node server.js folder

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

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

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


आप सभी तर्कों का विश्लेषण कर सकते हैं और जांच सकते हैं कि वे मौजूद हैं या नहीं।

फ़ाइल: 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;
}

बस इतना करें:

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

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

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

$ node args.js arg1 arg2

फ़ाइल: args.js

console.log(process.argv)

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

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

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

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

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

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

यहां कई महान उत्तर हैं, लेकिन यह सब बहुत जटिल लगता है। यह बहुत ही समान है कि बैश स्क्रिप्ट्स तर्क मानों तक कैसे पहुंचती हैं और यह पहले से ही node.js के साथ मानक प्रदान की जाती है क्योंकि म्यूगु ने इंगित किया था। (बस किसी को यह समझने योग्य बनाने के लिए कि node.js के लिए नया है)

उदाहरण:

$ 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

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

Promptly

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

Co-Prompt

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


अधिकांश लोगों ने अच्छे जवाब दिए हैं। मैं यहां कुछ योगदान देना चाहूंगा। मैं ऐप शुरू करते समय पास किए गए सभी कमांड लाइन तर्कों के माध्यम से lodash लाइब्रेरी का उपयोग करके उत्तर प्रदान कर रहा हूं:

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

कोड ऊपर चलाने के लिए बस निम्न आदेश चलाएं:

npm install
node index.js xyz abc 123 456

नतीजा होगा:

xyz 
abc 
123
456

Nconf https://github.com/flatiron/nconf जैसे कुछ का उपयोग करके केंद्रीकृत तरीके से अपनी कॉन्फ़िगरेशन को प्रबंधित करना शायद एक अच्छा विचार है

यह आपको कॉन्फ़िगरेशन फ़ाइलों, पर्यावरण चर, कमांड-लाइन तर्कों के साथ काम करने में मदद करता है।


स्टडीओ लाइब्रेरी

नोडजेएस में कमांड लाइन तर्कों का विश्लेषण करने का सबसे आसान तरीका stdio मॉड्यूल का उपयोग कर रहा है। यूनिक्स getopt उपयोगिता से प्रेरित, यह निम्नानुसार छोटा है:

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

यदि आप इस आदेश के साथ पिछले कोड चलाते हैं:

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

फिर ops ऑब्जेक्ट निम्नानुसार होगा:

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

तो आप इसे वैसे ही इस्तेमाल कर सकते हैं जैसा आप चाहते हैं। उदाहरण के लिए:

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

समूहबद्ध विकल्प भी समर्थित हैं, इसलिए आप -o -m बजाय लिख सकते हैं।

इसके अलावा, stdio स्वचालित रूप से एक सहायता / उपयोग आउटपुट उत्पन्न कर सकते हैं। यदि आप ops.printHelp() कॉल ops.printHelp() तो आपको निम्नलिखित मिलेंगे:

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

पिछला संदेश तब भी दिखाया गया है जब एक अनिवार्य विकल्प नहीं दिया गया है (त्रुटि संदेश से पहले) या यदि इसे गलत टाइप किया गया है (उदाहरण के लिए, यदि आप किसी विकल्प के लिए एक एकल तर्क निर्दिष्ट करते हैं और इसे 2 की आवश्यकता है)।

आप NPM का उपयोग कर stdio मॉड्यूल स्थापित कर सकते हैं:

npm install stdio

अगर आपकी स्क्रिप्ट को 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'

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

जंगली में मौजूदा रुझानों के आधार पर 2018 उत्तर:

वेनिला जावास्क्रिप्ट तर्क पार्सिंग:

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

यह रिटर्न:

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

आधिकारिक दस्तावेज़

बहस पार्सिंग के लिए सबसे अधिक इस्तेमाल किए गए एनपीएम पैकेज:

Minimist : न्यूनतम तर्क पार्सिंग के लिए।

Commander.js : तर्क पार्सिंग के लिए सबसे अधिक इस्तेमाल मॉड्यूल।

Meow : Commander.js के लिए हल्का विकल्प

Yargs : अधिक परिष्कृत तर्क पार्सिंग (भारी)।

Vorpal.js : तर्क पार्सिंग के साथ परिपक्व / इंटरैक्टिव कमांड लाइन अनुप्रयोग।


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


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 उपयोग मार्गदर्शिका एक अच्छा असली जीवन उदाहरण है।

आगे की पढाई

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


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

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

अद्यतन करें

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


आप 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 जैसे नामांकित तर्कों का उपयोग करना चाहिए।





command-line-arguments