මා සතුව වෙබ් සේවාදායකයක් 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: four

සාමාන්‍ය ජාවාස්ක්‍රිප්ට් ශ්‍රිතයක් වැනි තර්ක සාමාන්‍යකරණය කිරීම සඳහා, මම මෙය කරන්නේ මගේ node.js ෂෙල් ස්ක්‍රිප්ට් වලිනි:

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

පළමු ආරුක්කුව සාමාන්‍යයෙන් nodejs වෙත යන මාර්ගය වන අතර දෙවන arg යනු ඔබ ක්‍රියාත්මක කරන ස්ක්‍රිප්ටයේ පිහිටීමයි.

මේ සඳහා අවම නිවැරදි පුස්තකාලය භාවිතා කිරීම සඳහා යාවත්කාලීන නිවැරදි පිළිතුර . අපි භාවිතා කළේ 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/server.js', 'one', 'two=three', 'four']

නිල ලියකියවිලි

තර්ක විග්‍රහ කිරීම සඳහා වැඩිපුරම භාවිතා කරන එන්පීඑම් පැකේජ:

Minimist : අවම තර්කය අන්තහ්කරණය සඳහා.

Commander.js : තර්ක විග්‍රහ කිරීම සඳහා බොහෝ සම්මත මොඩියුලය.

Meow : Commander.js සඳහා සැහැල්ලු විකල්පය

යාර්ග්ස් : වඩාත් නවීන තර්ක විග්‍රහ කිරීම (බර).

Vorpal.js : තර්ක විග්‍රහ කිරීම සමඟ පරිණත / අන්තර්ක්‍රියාකාරී විධාන රේඛා යෙදුම්.

සුභවාදී (නෝඩ්-සුභවාදී)

ශුභවාදී පුස්තකාලය පරීක්ෂා කරන්න , එය විධාන රේඛා විකල්ප අතින් විග්‍රහ කිරීමට වඩා හොඳය.

යාවත්කාලීන කරන්න

සුභවාදීන් ඉවත් කරනු ලැබේ. සුභවාදීන්ගේ ක්‍රියාකාරී දෙබලක වන යාර උත්සාහ කරන්න .

මෙහි විශිෂ්ට පිළිතුරු කිහිපයක් ඇත, නමුත් ඒ සියල්ල ඉතා සංකීර්ණ බව පෙනේ. මෙය බාෂ් ස්ක්‍රිප්ට් තර්ක අගයන්ට ප්‍රවේශ වන ආකාරය හා සමාන වන අතර MooGoo පෙන්වා දුන් පරිදි එය දැනටමත් 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

ඔබගේ විකල්ප, ක්‍රියා සහ තර්ක නිර්වචනය කිරීම සඳහා විශිෂ්ට ලෙස ක්‍රියා කරයි. එය ඔබට උදව් පිටු ද ජනනය කරයි.

වහාම

ඔබ ඇමතුම් ලබා ගැනීමේ ප්‍රවේශයට කැමති නම්, පරිශීලකයාගෙන් ආදානය ලබා ගැනීම සඳහා විශිෂ්ට ලෙස ක්‍රියා කරයි.

සම-විමසුම

ඔබ උත්පාදක ප්‍රවේශයට කැමති නම්, පරිශීලකයාගෙන් ආදානය ලබා ගැනීම සඳහා විශිෂ්ට ලෙස ක්‍රියා කරයි.

සරල වස්තුවකට ආකෘතිගත කර ඇති කොඩි සහිත ලිබ්ස් නැත

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

Stdio පුස්තකාලය

NodeJS හි විධාන රේඛා විග්‍රහ කිරීමට පහසුම ක්‍රමය වන්නේ 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, 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

අනිවාර්ය විකල්පයක් ලබා නොදුනහොත් (දෝෂ පණිවිඩයට පෙර) හෝ එය වැරදි ලෙස අර්ථ දක්වා ඇත්නම් (උදාහරණයක් ලෙස, ඔබ විකල්පයක් සඳහා තනි ආරුක්කුවක් නියම කළහොත් එයට 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 }
]

ඊළඟට, commandLineArgs () භාවිතා කර විකල්ප විග්‍රහ කරන්න :

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

options දැන් මේ වගේ ය:

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

උසස් භාවිතය

ඉහත සාමාන්‍ය භාවිතයට අමතරව, ඔබට වඩාත් දියුණු සින්ටැක්ස් ආකෘති පිළිගැනීමට විධාන රේඛා-ආග්ස් වින්‍යාසගත කළ හැකිය.

ස්වරූපයෙන් විධාන මත පදනම් වූ සින්ටැක්ස් (git style):

$ 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

සටහන: තර්කය a අඩංගු වන විට ස්වාභාවිකවම මෙය අසාර්ථක වේ =. මෙය ඉතා සරල භාවිතය සඳහා පමණි.

Nconf https://github.com/flatiron/nconf වැනි දෙයක් භාවිතා කර ඔබේ වින්‍යාසය මධ්‍යගතව කළමනාකරණය කිරීම හොඳ අදහසකි.

වින්‍යාස ගොනු, පරිසර විචල්‍යයන්, විධාන රේඛා තර්ක සමඟ වැඩ කිරීමට එය ඔබට උපකාරී වේ.

පුස්තකාල නොමැතිව: 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' }

තර්ක විග්‍රහ කිරීම පහසු ක්‍රියාවලියකි. Node මඟින් ඔබට process.argv දේපල ලබා දෙයි, එය නූල් සමූහයකි, ඒවා Node ආයාචනය කරන විට භාවිතා කරන ලද තර්ක වේ. අරාවේ පළමු ප්‍රවේශය නෝඩ් ක්‍රියාත්මක කළ හැකි අතර දෙවන ප්‍රවේශය ඔබේ ස්ක්‍රිප්ටයේ නමයි.

ඔබ පහත අක්ෂර සමඟ ස්ක්‍රිප්ට් ධාවනය කරන්නේ නම්

$ node args.js arg1 arg2

ගොනුව: args.js

console.log(process.argv)

ඔබට අරාව ලැබෙනු ඇත

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

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'

proj.js

for(var i=0;i<process.argv.length;i++){
  console.log(process.argv[i]);
}

පර්යන්තය:

nodemon app.js "arg1" "arg2" "arg3"

ප්‍රති ult ලය:

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.

පැහැදිලි කිරීම:

0 : ඔබේ යන්ත්‍රයේ node.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මෙම විසඳුම භාවිතා කිරීමට ඔබ නම් කළ තර්ක භාවිතා කළ යුතුය .

ඔබට සියලු තර්ක විග්‍රහ කර ඒවා තිබේදැයි පරීක්ෂා කළ හැකිය.

ගොනුව: parse-cli-argument.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);//true

ps කරුණාකර සිතියමේ කේතය නිවැරදි කර වඩාත් අලංකාර විසඳුමක් සොයා ගන්නේ නම් ක්‍රියාකාරිත්වය අඩු කරන්න, ස්තූතියි;)

ඉහත පිළිතුරු පරිපූර්ණ වුවත්, යමෙකු දැනටමත් යාර යෝජනා කර ඇතත්, පැකේජය භාවිතා කිරීම ඇත්තෙන්ම පහසුය. විධාන රේඛාවට තර්ක ඉදිරිපත් කිරීම සැබවින්ම පහසු කරවන හොඳ පැකේජයකි.

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

වැඩි විස්තර සඳහා කරුණාකර https://yargs.js.org/ වෙත පිවිසෙන්න .

තර්ක ඉදිරිපත් කිරීම පහසු වන අතර ඒවා ලැබීම ක්‍රියාවලිය කියවීම පමණි. Argv අරාව නෝඩ් සෑම තැනකින්ම ප්‍රවේශ විය හැකිය. නමුත් ඔබට ඒවා යතුරු / අගය යුගල ලෙස කියවීමට අවශ්‍ය බව විශ්වාසයි, එබැවින් එය අර්ථ නිරූපණය කිරීම සඳහා ඔබට ස්ක්‍රිප්ටයට කෑල්ලක් අවශ්‍ය වේ.

අඩු කිරීම භාවිතා කරමින් ජෝශප් මර්ඩ්රිග්නැක් ලස්සන එකක් පළ කළ නමුත් එය රඳා පැවතියේ සහ 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 අරාව හරහා ප්‍රවේශ කළ හැකිය.

Process.argv අරාවෙහි පළමු අංගය සැමවිටම ක්‍රියාත්මක කළ හැකි නෝඩ් වෙත යොමු කරන ගොනු පද්ධති මාර්ගයක් වනු ඇත. දෙවන අංගය වන්නේ ක්‍රියාත්මක වන ජාවාස්ක්‍රිප්ට් ගොනුවේ නමයි. තෙවන මූලද්‍රව්‍යය යනු පරිශීලකයා විසින් සත්‍ය වශයෙන්ම සම්මත කරන ලද පළමු තර්කයයි.

'use strict';

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

මෙම ස්ක්‍රිප්ට් සියල්ලම කරන්නේ process.argv අරාව හරහා ලූපයක් වන අතර එම දර්ශකවල ගබඩා කර ඇති මූලද්‍රව්‍ය සමඟ දර්ශක මුද්‍රණය කරයි. ඔබට ලැබෙන්නේ කුමන තර්කද, කුමන අනුපිළිවෙලද යන්න ඔබ කවදා හෝ ප්‍රශ්න කරන්නේ නම් එය නිදොස්කරණය සඳහා ඉතා ප්‍රයෝජනවත් වේ.

පොදු තර්ක සමඟ වැඩ කිරීම සඳහා ඔබට යාර වැනි පුස්තකාල භාවිතා කළ හැකිය.

පුස්තකාල නොමැති ටයිප්ස්ක්‍රිප්ට් විසඳුම:

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

process.argvඔබේ මිතුරා, විධාන රේඛා ආග්ස් අල්ලා ගැනීම Node JS හි දේශීයව සහාය වේ. පහත උදාහරණය බලන්න ::

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

node.cs හි දක්වා ඇති පරිදි process.argv දේපල විසින් Node.js ක්‍රියාවලිය දියත් කරන විට සම්මත කරන ලද විධාන රේඛා තර්ක ඇතුළත් අරාවක් ලබා දෙයි.

උදාහරණයක් ලෙස, process-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

ප්රති result ලය වනු ඇත්තේ:

xyz 
abc 
123
456

විධාන රේඛා තර්ක Node.js වැඩසටහනකට යැවිය හැකි හොඳම ක්‍රමය වන්නේ විධාන රේඛා අතුරුමුහුණතක් (CLI) භාවිතා කිරීමයි.

ඔබට භාවිතා කළ හැකි nodejs-cli නමින් nifty npm මොඩියුලයක් ඇත.

ඔබට කිසිදු පරායත්තතාවයක් නොමැති එකක් නිර්මාණය කිරීමට අවශ්‍ය නම්, මගේ ගිතුබ් එකෙන් එකක් ලබා ගැනීමට ඔබට අවශ්‍ය නම් එය පරීක්ෂා කර බැලීමට ඔබට අවශ්‍ය නම්, එය ඇත්තෙන්ම සරල හා භාවිතයට පහසුය, මෙහි ක්ලික් කරන්න .

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