मेरे पास Node.js में लिखा गया एक वेब सर्वर है और मैं एक विशिष्ट फ़ोल्डर के साथ लॉन्च करना चाहूंगा। मुझे यकीन नहीं है कि जावास्क्रिप्ट में तर्कों का उपयोग कैसे किया जाए। मैं इस तरह से नोड चला रहा हूं:
$ node server.js folderयहाँ server.jsमेरा सर्वर कोड है। Node.js यह कहते हैं कि यह संभव है:
$ node -h
Usage: node [options] script.js [arguments]मैं जावास्क्रिप्ट में उन तर्कों को कैसे एक्सेस करूंगा? किसी तरह मैं वेब पर यह जानकारी नहीं पा रहा था।
जवाबों:
तर्कों को संग्रहीत किया जाता है 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: fourprocess.argv[n]कहां nहै
node [options] [ -e script | script.js ] [arguments]या node debug script.js [arguments]। उदाहरण के लिए: node --harmony script.js balalaया node --no-deprecation --enable-ssl2 script.js balala, हम process.execArgv को process.argv के
नियमित रूप से जावास्क्रिप्ट फ़ंक्शन की तरह तर्कों को सामान्य करने के लिए, मैं अपने नोड.जेएस शेल स्क्रिप्ट में ऐसा करता हूं:
var args = process.argv.slice(2);ध्यान दें कि पहला arg आमतौर पर नोडज के लिए पथ है, और दूसरा arg उस स्क्रिप्ट का स्थान है जिसे आप निष्पादित कर रहे हैं।
execArgv हैं 2 पर्याप्त हैargv
process.argv.splice(process.execArgv.length + 2) : एक आदेश के लिए node --harmony script.js --version, process.argvहै ['/usr/local/bin/node', 'script.js', '--version']। पर झंडे nodeकर रहे हैं नहीं में शामिल process.argv!
इसके लिए अप-टू-डेट सही उत्तर है कि यह न्यूनतम पुस्तकालय का उपयोग करे । हम नोड-आशावादी का उपयोग करते थे, लेकिन तब से इसे हटा दिया गया है।
यहाँ इसका उपयोग करने का एक उदाहरण है कि इसे न्यूनतम दस्तावेज से सीधे लिया गया है:
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' }const args = process.argv;
console.log(args);यह रिटर्न:
$ node server.js one two=three four
['node', '/home/server.js', 'one', 'two=three', 'four']मिनिमिस्ट : न्यूनतम तर्क पार्सिंग के लिए।
कमांडर.जेएस : तर्क पार्सिंग के लिए सबसे अधिक अपनाया गया मॉड्यूल।
म्याऊ : कमांडर.जेएस के लिए हल्का विकल्प
यार्ग : अधिक परिष्कृत तर्क पार्सिंग (भारी)।
Vorpal.js : तर्क पार्सिंग के साथ परिपक्व / इंटरैक्टिव कमांड-लाइन एप्लिकेशन।
की जाँच करें आशावादी पुस्तकालय , यह बहुत हाथ से कमांड लाइन विकल्पों को पार्स से बेहतर है।
अपडेट करें
आशावादी को पदावनत किया जाता है। यारों की कोशिश करें जो आशावादी का एक सक्रिय कांटा है।
यहां कई शानदार जवाब हैं, लेकिन यह सब बहुत जटिल है। यह बहुत ही समान है कि कैसे बैश लिपिक तर्क मूल्यों तक पहुँचता है और यह पहले से ही नोड के साथ मानक प्रदान करता है। जैसा कि MooGoo ने बताया है। (बस किसी को समझ में आने के लिए कि यह नोड के लिए नया है। 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"अपने विकल्पों, कार्यों और तर्कों को परिभाषित करने के लिए महान काम करता है। यह आपके लिए सहायता पृष्ठ भी बनाता है।
यदि आप कॉलबैक दृष्टिकोण पसंद करते हैं, तो उपयोगकर्ता से इनपुट प्राप्त करने के लिए बढ़िया काम करता है।
यदि आप जनरेटर दृष्टिकोण को पसंद करते हैं, तो उपयोगकर्ता से इनपुट प्राप्त करने के लिए बढ़िया काम करता है।
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);इनपुट
node test.js -D --name=Helloउत्पादन
{ D: true, name: 'Hello' }इनपुट
node config/build.js -lHRs --ip=$HOST --port=$PORT --env=devउत्पादन
{
l: true,
H: true,
R: true,
s: true,
ip: '127.0.0.1',
port: '8080',
env: 'dev'
}= longArg[1]आप लिख सकते हैं = longArg.length > 1 ? longArg[1] : true;यह आपको इस प्रकार के तर्क को पारित करने देगा:node config/build.js --flag1 --flag2
NodeJS में कमांड-लाइन तर्कों को पार्स करने का सबसे आसान तरीका stdio मॉड्यूल का उपयोग करना है । UNIX 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, required: 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]);
}समूहीकृत विकल्प भी समर्थित हैं, इसलिए आप -omइसके बजाय लिख सकते हैं -o -m।
इसके अलावा, stdioस्वचालित रूप से मदद / उपयोग आउटपुट उत्पन्न कर सकता है। यदि आप कहते हैं 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पिछला संदेश यह भी दिखाया जाता है कि यदि कोई अनिवार्य विकल्प नहीं दिया गया है (त्रुटि संदेश से पहले) या यदि यह गलत है (उदाहरण के लिए, यदि आप किसी विकल्प के लिए एक एकल arg निर्दिष्ट करते हैं और उसे 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'कमांड-लाइन-आर्ग्स देखने लायक है!
आप मुख्य अंकन मानकों ( अधिक जानें ) का उपयोग करके विकल्प सेट कर सकते हैं । ये कमांड सभी समान हैं, समान मान सेट करते हैं:
$ 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 }
]इसके बाद, कमांडलाइन कमांड का उपयोग करके विकल्पों को पार्स करें () :
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सेट किया जाता है) कमांड-लाइन-उपयोग का उपयोग करके उत्पन्न किया जा सकता है । नीचे दिए गए उदाहरण देखें और निर्देशों के लिए प्रलेखन पढ़ें कि उन्हें कैसे बनाया जाए।
एक विशिष्ट उपयोग गाइड उदाहरण।
बहुलक-CLI उपयोग गाइड एक अच्छा वास्तविक जीवन उदाहरण है।
सीखने के लिए बहुत कुछ है, उदाहरण और प्रलेखन के लिए विकी देखें ।
उसके लिए एक ऐप है। खैर, मॉड्यूल। खैर, एक से अधिक, शायद सैकड़ों।
यार्ग मज़ेदार लोगों में से एक है, इसके डॉक्स पढ़ने में मस्त हैं।
यहाँ 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' ]यहाँ नामित तर्क के लिए मेरा 0-dep समाधान है:
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)उदाहरण:
$ node test.js foo=bar fizz=buzz
bar
buzzनोट: स्वाभाविक रूप से यह विफल हो जाएगा जब तर्क में ए =। यह केवल बहुत ही सरल उपयोग के लिए है।
Nconf https://github.com/flatiron/nconf जैसी किसी चीज़ का उपयोग करके केंद्रीकृत तरीके से अपने कॉन्फ़िगरेशन को प्रबंधित करना शायद एक अच्छा विचार है
यह आपको कॉन्फ़िगरेशन फ़ाइलों, पर्यावरण चर, कमांड-लाइन तर्कों के साथ काम करने में मदद करता है।
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' }countऔर cकमांड लाइन विकल्पों का समर्थन करना चाहता हूं ( cएक उपनाम के रूप में / के लिए shorcut count)?
तर्क पारित करना, तर्क देना एक आसान प्रक्रिया है। नोड आपको process.argv प्रॉपर्टी प्रदान करता है, जो स्ट्रिंग्स की एक सरणी है, जो कि वे तर्क हैं जिनका उपयोग नोड के लागू होने पर किया गया था। सरणी की पहली प्रविष्टि नोड निष्पादन योग्य है, और दूसरी प्रविष्टि आपकी स्क्रिप्ट का नाम है।
यदि आप स्क्रिप्ट को निचले स्तर पर चलाते हैं
$ node args.js arg1 arg2फ़ाइल: args.js
console.log(process.argv)आपको ऐरे जैसा मिलेगा
['node','args.js','arg1','arg2']npm install ps-grabnode 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'proj.js
for(var i=0;i<process.argv.length;i++){
console.log(process.argv[i]);
}टर्मिनल:
nodemon app.js "arg1" "arg2" "arg3"परिणाम:
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.explaination:
0 : आपके मचिंग में नोड.exe की निर्देशिका (C: \ Program Files \ nodejs \ node.exe):
1: आपकी परियोजना फ़ाइल की निर्देशिका। (Proj.js)
2 : नोड के लिए आपका पहला तर्क (arg1)
3 : नोड के लिए आपका दूसरा तर्क (arg2)
4 : नोड के लिए आपका तीसरा तर्क (arg3)
आपकी वास्तविक दलीलें सरणी का 2ndसूचकांक है argv, जो शुरू होता है process.argv[2]।
आप कमांड लाइन तर्कों का उपयोग करके पहुंच सकते हैं 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
नोट: आपको
file.js x=1 y=2इस समाधान का उपयोग करने के लिए नामित तर्कों का उपयोग करना चाहिए ।
mapसंपत्ति अपरिभाषित है।
आप सभी तर्कों को पार्स कर सकते हैं और जांच सकते हैं कि क्या वे मौजूद हैं।
फ़ाइल: पार्स-क्ली-तर्क। 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']);यदि आप वैनिला JS / ES6 में ऐसा करना चाहते हैं, तो आप निम्न समाधान का उपयोग कर सकते हैं
केवल 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;
}, {});और यह आज्ञा
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);//trueps कृपया मानचित्र में कोड को सही करें और फ़ंक्शन को कम करें यदि आप अधिक सुरुचिपूर्ण समाधान पाते हैं, धन्यवाद;)
let args = process.argv.slice(2).reduce((acc, arg) => { let [k, v] = arg.split('=') acc[k] = v return acc }, {})
हालांकि उपरोक्त उत्तर एकदम सही हैं, और किसी ने पहले से ही yargs का सुझाव दिया है, पैकेज का उपयोग करना वास्तव में आसान है। यह एक अच्छा पैकेज है जो कमांड लाइन को पास करने के लिए तर्क देता है वास्तव में आसान है।
npm i yargs
const yargs = require("yargs");
const argv = yargs.argv;
console.log(argv);अधिक जानकारी के लिए कृपया https://yargs.js.org/ पर जाएं ।
तर्कों को पारित करना आसान है, और उन्हें प्राप्त करना प्रक्रिया को पढ़ने का सिर्फ एक मामला है। आरजीवी सरणी नोड हर जगह, मूल रूप से सुलभ बनाता है। लेकिन आप उन्हें कुंजी / मान जोड़े के रूप में पढ़ना चाहते हैं, इसलिए आपको इसकी व्याख्या करने के लिए स्क्रिप्ट की आवश्यकता होगी।
यूसुफ Merdrignac एक सुंदर एक कम का उपयोग कर पोस्ट, लेकिन यह एक पर भरोसा key=valueकरने के बजाय वाक्य रचना -k valueऔर --key value। मैंने उस दूसरे मानक का उपयोग करने के लिए इसे बहुत बदसूरत और लंबे समय तक लिखा, और मैं इसे एक उत्तर के रूप में पोस्ट करूंगा क्योंकि यह एक टिप्पणी के रूप में फिट नहीं होगा। लेकिन यह काम हो जाता है।
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
},{})इस कोड के साथ एक कमांड node script.js alpha beta -charlie delta --echo foxtrotआपको निम्नलिखित वस्तु देगा
args = {
"alpha":true,
"beta":true,
"c":true,
"h":true,
"a":true,
"r":true
"l":true,
"i":true,
"e":"delta",
"echo":"foxtrot"
}Node.js में तर्कों को पुनर्प्राप्त करने का सबसे सरल तरीका process.argv सरणी के माध्यम से है। यह एक वैश्विक वस्तु है जिसका उपयोग करने के लिए आप किसी भी अतिरिक्त पुस्तकालयों को आयात किए बिना उपयोग कर सकते हैं। आपको बस Node.js एप्लिकेशन के लिए तर्कों को पास करने की आवश्यकता है, जैसे हमने पहले दिखाया था, और इन तर्कों को आवेदन के भीतर पहुँचा जा सकता है।
Process.argv एरे का पहला तत्व हमेशा एक फाइल सिस्टम पथ होगा जो नोड एक्जीक्यूटिव की ओर इशारा करता है। दूसरा तत्व जावास्क्रिप्ट फ़ाइल का नाम है जिसे निष्पादित किया जा रहा है। और तीसरा तत्व पहला तर्क है जो वास्तव में उपयोगकर्ता द्वारा पारित किया गया था।
'use strict';
for (let j = 0; j < process.argv.length; j++) {
console.log(j + ' -> ' + (process.argv[j]));
}यह सब स्क्रिप्ट प्रक्रिया के माध्यम से लूप है। आरजीवी सरणी और अनुक्रमित को मुद्रित करता है, साथ ही उन अनुक्रमित तत्वों में संग्रहीत करता है। यह डिबगिंग के लिए बहुत उपयोगी है यदि आप कभी सवाल करते हैं कि आप क्या तर्क प्राप्त कर रहे हैं, और किस क्रम में हैं।
आप कमोडिटी तर्कों के साथ काम करने के लिए पुस्तकालयों जैसे यारों का भी उपयोग कर सकते हैं।
कोई पुस्तकालयों के साथ टाइपस्क्रिप्ट समाधान:
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);इनपुट: ts-node index.js -p param --parameter parameter
आउटपुट: { p: 'param ', parameter: 'parameter' }
नोड डॉक्स में कहा गया है। जब Node.js प्रक्रिया लॉन्च की गई थी, तो कमांड लाइन के तर्कों को शामिल करने के लिए process.argv संपत्ति एक सरणी देता है।
उदाहरण के लिए, प्रक्रिया-args.js के लिए निम्न स्क्रिप्ट मान:
// print process.argv
process.argv.forEach((val, index) => {
console.log(`${index}: ${val}`);
});Node.js प्रक्रिया को इस प्रकार लॉन्च करना:
$ node process-args.js one two=three fourउत्पादन उत्पन्न करेगा:
0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: fourज्यादातर लोगों ने अच्छे जवाब दिए हैं। मैं यहां कुछ योगदान देना भी चाहूंगा। मैं 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कमांड लाइन तर्क को Node.js प्रोग्राम में पास करने का सबसे अच्छा तरीका है कमांड लाइन इंटरफेस (CLI) का उपयोग करना।
एक निफ्टी एनपीएम मॉड्यूल है जिसे नोडज-क्ली कहा जाता है जिसे आप उपयोग कर सकते हैं।
यदि आप एक निर्भरता के साथ एक बनाना चाहते हैं जो मुझे अपने गितुब पर मिल गया है यदि आप इसे देखना चाहते हैं, तो यह वास्तव में काफी सरल और उपयोग में आसान है, यहां क्लिक करें ।
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());