ฉันมีเว็บเซิร์ฟเวอร์เขียนด้วยNode.jsและฉันต้องการที่จะเปิดตัวด้วยโฟลเดอร์เฉพาะ ฉันไม่แน่ใจว่าจะเข้าถึงอาร์กิวเมนต์ใน JavaScript ได้อย่างไร ฉันใช้โหนดเช่นนี้

$ node server.js folder

นี่server.jsคือรหัสเซิร์ฟเวอร์ของฉัน ความช่วยเหลือของ Node.js บอกได้ว่าสิ่งนี้เป็นไปได้:

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

ฉันจะเข้าถึงอาร์กิวเมนต์เหล่านี้ใน JavaScript ได้อย่างไร อย่างใดฉันไม่สามารถค้นหาข้อมูลนี้บนเว็บ

วิธีมาตรฐาน (ไม่มีไลบรารี)

อาร์กิวเมนต์จะถูกเก็บไว้ใน process.argv

นี่คือโหนดเอกสารในการจัดการบรรทัดคำสั่ง args:

process.argvเป็นอาร์เรย์ที่มีอาร์กิวเมนต์บรรทัดคำสั่ง องค์ประกอบแรกจะเป็น 'โหนด' องค์ประกอบที่สองจะเป็นชื่อของไฟล์ JavaScript องค์ประกอบถัดไปจะเป็นอาร์กิวเมนต์บรรทัดคำสั่งเพิ่มเติมใด ๆ

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

โปรดทราบว่า arg แรกมักจะเป็นเส้นทางไปยัง nodejs และ arg ที่สองคือตำแหน่งของสคริปต์ที่คุณกำลังดำเนินการ

คำตอบที่ถูกต้องทันสมัยเพื่อให้มันใช้ห้องสมุด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/server.js', 'one', 'two=three', 'four']

เอกสารอย่างเป็นทางการ

แพ็กเกจ NPM ที่ใช้มากที่สุดสำหรับการแยกวิเคราะห์อาร์กิวเมนต์:

Minimist : สำหรับการแยกอาร์กิวเมนต์ขั้นต่ำ

Commander.js : โมดูลที่นำมาใช้ส่วนใหญ่สำหรับการแยกวิเคราะห์

Meow : ทางเลือกที่เบากว่าสำหรับ Commander.js

Yargs : การแยกอาร์กิวเมนต์ที่ซับซ้อนมากขึ้น (หนัก)

Vorpal.js : แอปพลิเคชันบรรทัดคำสั่งสำหรับผู้ใหญ่ / โต้ตอบพร้อมการแยกวิเคราะห์

Optimist (node-optimist)

ลองใช้ห้องสมุด optimistมันดีกว่าการแยกตัวเลือกบรรทัดคำสั่งด้วยมือ

ปรับปรุง

Optimist เลิกใช้แล้ว ลองใช้yargsซึ่งเป็นทางแยกของ optimist

คำตอบที่ยอดเยี่ยมมากมายที่นี่ แต่ดูเหมือนจะซับซ้อน สิ่งนี้คล้ายกับวิธีที่สคริปต์ทุบตีเข้าถึงค่าอาร์กิวเมนต์และมีการจัดเตรียมมาตรฐานพร้อมกับ node.js ตามที่ MooGoo ชี้ให้เห็น (เพียงเพื่อทำให้เข้าใจได้สำหรับผู้ที่ยังใหม่กับ 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

ใช้งานได้ดีสำหรับการกำหนดตัวเลือกการกระทำและข้อโต้แย้งของคุณ มันยังสร้างหน้าช่วยเหลือสำหรับคุณ

พลัน

ใช้งานได้ดีสำหรับการรับข้อมูลจากผู้ใช้ถ้าคุณชอบวิธีการโทรกลับ

ร่วม Prompt

ใช้งานได้ดีสำหรับการรับข้อมูลจากผู้ใช้ถ้าคุณชอบวิธีสร้าง

ไม่มี Libs ที่มีการจัดรูปแบบเป็นวัตถุแบบง่าย

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ยูทิลิตี้UNIX มันเป็นเรื่องเล็กน้อยดังต่อไปนี้:

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)

คุณสามารถติดตั้งโมดูลstdioโดยใช้NPM :

npm install stdio

หากสคริปต์ของคุณชื่อ myScript.js และคุณต้องการส่งชื่อและนามสกุล 'Sean Worthington' เป็นอาร์กิวเมนต์ดังนี้

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'

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
}

การใช้งานขั้นสูง

นอกเหนือจากการใช้งานทั่วไปข้างต้นคุณสามารถกำหนดค่า command-line-args เพื่อยอมรับรูปแบบไวยากรณ์ขั้นสูงเพิ่มเติม

ไวยากรณ์คำสั่ง (สไตล์ git) ในรูปแบบ:

$ 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คู่มือการใช้งานเป็นตัวอย่างที่แท้จริงของชีวิตที่ดี

อ่านเพิ่มเติม

มีอะไรอีกมากมายให้เรียนรู้โปรดดูวิกิสำหรับตัวอย่างและเอกสารประกอบ

มีแอพสำหรับสิ่งนั้น ดีโมดูล มากกว่าหนึ่งอาจเป็นร้อย

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

นี่คือโซลูชัน 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

ช่วยให้คุณทำงานกับไฟล์การกำหนดค่าตัวแปรสภาพแวดล้อมอาร์กิวเมนต์บรรทัดคำสั่ง

ไม่มีการใช้ librairies: using 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' }

ผ่านการแยกวิเคราะห์ข้อโต้แย้งเป็นกระบวนการที่ง่าย โหนดให้คุณสมบัติ process.argv ซึ่งเป็นอาร์เรย์ของสตริงซึ่งเป็นอาร์กิวเมนต์ที่ใช้เมื่อมีการเรียกใช้โหนด รายการแรกของอาร์เรย์คือ Node executable และรายการที่สองคือชื่อสคริปต์ของคุณ

หากคุณเรียกใช้สคริปต์ด้วย atguments ด้านล่าง

$ 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"

ผลลัพธ์:

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 ใน maching ของคุณ (C: \ Program Files \ nodejs \ node.exe ')

1: ไดเรกทอรีของไฟล์โครงการของคุณ (proj.js)

2 : อาร์กิวเมนต์แรกของคุณไปยังโหนด (arg1)

3 : อาร์กิวเมนต์ที่สองของคุณไปยังโหนด (arg2)

4 : อาร์กิวเมนต์ที่สามของคุณไปยังโหนด (arg3)

ข้อโต้แย้งที่เกิดขึ้นจริงของคุณเริ่มต้นรูปแบบ2ndดัชนีของอาร์เรย์ที่เป็นargvprocess.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-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']);

ไม่มีห้องสมุด

หากคุณต้องการทำเช่นนี้ใน vanilla 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

ป.ล. โปรดแก้ไขรหัสในแผนที่และลดฟังก์ชั่นถ้าคุณพบคำตอบที่ดีกว่านี้ขอบคุณ;)

แม้ว่าคำตอบข้างต้นนั้นสมบูรณ์แบบและมีคนแนะนำให้ใช้เวลานานแล้วการใช้แพ็คเกจเป็นเรื่องง่ายมาก นี่เป็นแพคเกจที่ดีซึ่งทำให้การส่งผ่านอาร์กิวเมนต์ไปยังบรรทัดคำสั่งนั้นง่ายมาก

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

กรุณาเยี่ยมชมhttps://yargs.js.org/สำหรับข้อมูลเพิ่มเติม

การผ่านข้อโต้แย้งนั้นง่ายและการรับนั้นเป็นเพียงเรื่องของการอ่าน process.argv array Node ทำให้สามารถเข้าถึงได้จากทุกที่โดยทั่วไป แต่คุณแน่ใจว่าต้องการอ่านพวกเขาเป็นคู่ของคีย์ / ค่าดังนั้นคุณจะต้องมีสคริปต์ในการตีความ

โจเซฟ 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

องค์ประกอบแรกของอาร์เรย์ process.argv จะเป็นเส้นทางของระบบไฟล์ที่ชี้ไปยังโหนดที่ทำงานได้ องค์ประกอบที่สองคือชื่อของไฟล์ JavaScript ที่กำลังดำเนินการ และองค์ประกอบที่สามคืออาร์กิวเมนต์แรกที่ผู้ใช้ส่งผ่านจริง

'use strict';

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

สคริปต์ทั้งหมดนี้ทำคือวนลูปผ่านอาร์เรย์ process.argv และพิมพ์ดัชนีพร้อมกับองค์ประกอบที่เก็บไว้ในดัชนีเหล่านั้น มันมีประโยชน์มากสำหรับการแก้ไขข้อบกพร่องหากคุณเคยสงสัยว่าคุณได้รับข้อโต้แย้งอะไรและเรียงลำดับอย่างไร

คุณยังสามารถใช้ไลบรารีเช่น yargs สำหรับทำงานกับอาร์กิวเมนต์ commnadline

โซลูชั่น TypeScript ที่ไม่มีไลบรารี:

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เป็นเพื่อนของคุณการจับ args ของบรรทัดคำสั่งได้รับการสนับสนุนในโหนด JS ดูตัวอย่างด้านล่าง ::

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

ตามที่ระบุในโหนดเอกสารคุณสมบัติ 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

ผลลัพธ์จะเป็น:

xyz 
abc 
123
456

วิธีที่ดีที่สุดในการส่งผ่านอาร์กิวเมนต์บรรทัดคำสั่งไปยังโปรแกรม Node.js คือการใช้ Command Line Interface (CLI)

มีโมดูลที่ดีที่สุดที่เรียกว่าnodejs-cliที่คุณสามารถใช้เป็น

หากคุณต้องการที่จะสร้างหนึ่งที่มีการอ้างอิงที่ไม่มีฉันมีหนึ่งบน Github ของฉันถ้าคุณอยากจะลองตรวจสอบออกก็จริงค่อนข้างง่ายและง่ายต่อการใช้งานคลิกที่นี่

โซลูชันไม่มีการพึ่งพาสไตล์ 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());