Tôi có một máy chủ web được viết bằng Node.js và tôi muốn khởi chạy với một thư mục cụ thể. Tôi không chắc làm thế nào để truy cập các đối số trong JavaScript. Tôi đang chạy nút như thế này:

$ node server.js folder

đây server.jslà mã máy chủ của tôi Trợ giúp của Node.js cho biết điều này là có thể:

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

Làm cách nào để truy cập các đối số đó trong JavaScript? Bằng cách nào đó tôi không thể tìm thấy thông tin này trên web.

Phương pháp chuẩn (không có thư viện)

Các đối số được lưu trữ trong process.argv

Dưới đây là các tài liệu nút về xử lý dòng lệnh args:

process.argvlà một mảng chứa các đối số dòng lệnh. Phần tử đầu tiên sẽ là 'nút', phần tử thứ hai sẽ là tên của tệp JavaScript. Các yếu tố tiếp theo sẽ là bất kỳ đối số dòng lệnh bổ sung.

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

Điều này sẽ tạo ra:

$ 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

Để bình thường hóa các đối số như một hàm javascript thông thường sẽ nhận được, tôi thực hiện điều này trong các tập lệnh shell của node.js:

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

Lưu ý rằng đối số thứ nhất thường là đường dẫn đến nodejs và đối số thứ hai là vị trí của tập lệnh bạn đang thực thi.

Các up-to-date ngay câu trả lời cho điều này nó sử dụng minimist thư viện. Chúng tôi đã từng sử dụng nút lạc quan nhưng nó đã bị từ chối.

Dưới đây là một ví dụ về cách sử dụng nó được lấy thẳng từ tài liệu thu nhỏ:

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

Câu trả lời năm 2018 dựa trên các xu hướng hiện tại trong tự nhiên:

Phân tích cú pháp đối số javascript của Vanilla:

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

Điều này trả về:

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

Tài liệu chính thức

Các gói NPM được sử dụng nhiều nhất để phân tích cú pháp đối số:

Minimist : Để phân tích cú pháp đối số tối thiểu.

Commander.js : Mô-đun được chấp nhận nhiều nhất để phân tích cú pháp đối số.

Meow : Thay thế nhẹ hơn cho Commander.js

Yargs : Phân tích cú pháp đối số phức tạp hơn (nặng).

Vorpal.js : Các ứng dụng dòng lệnh trưởng thành / tương tác với phân tích cú pháp đối số.

Người lạc quan (người lạc quan nút)

Kiểm tra thư viện lạc quan , nó tốt hơn nhiều so với phân tích các tùy chọn dòng lệnh bằng tay.

Cập nhật

Người lạc quan bị phản đối. Hãy thử yargs là một ngã ba tích cực của người lạc quan.

Một số câu trả lời tuyệt vời ở đây, nhưng tất cả có vẻ rất phức tạp. Điều này rất giống với cách các tập lệnh bash truy cập các giá trị đối số và nó đã được cung cấp chuẩn với node.js như MooGoo đã chỉ ra. (Chỉ để làm cho nó dễ hiểu đối với ai đó mới biết về node.js)

Thí dụ:

$ 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

Hoạt động tuyệt vời để xác định các tùy chọn, hành động và đối số của bạn. Nó cũng tạo ra các trang trợ giúp cho bạn.

Kịp thời

Hoạt động tuyệt vời để nhận đầu vào từ người dùng, nếu bạn thích phương pháp gọi lại.

Đồng nhắc

Hoạt động tuyệt vời để nhận đầu vào từ người dùng, nếu bạn thích cách tiếp cận trình tạo.

Không có Libs với cờ được định dạng thành một đối tượng đơn giản

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

Ví dụ

Đơn giản

đầu vào

node test.js -D --name=Hello

đầu ra

{ D: true, name: 'Hello' }

Thế giới thực

đầu vào

node config/build.js -lHRs --ip=$HOST --port=$PORT --env=dev

đầu ra

{ 
  l: true,
  H: true,
  R: true,
  s: true,
  ip: '127.0.0.1',
  port: '8080',
  env: 'dev'
}

Thư viện Stdio

Cách dễ nhất để phân tích các đối số dòng lệnh trong NodeJS là sử dụng mô đun stdio . Lấy cảm hứng từ getopttiện ích UNIX , nó tầm thường như sau:

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

Nếu bạn chạy mã trước đó bằng lệnh này:

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

Sau đó, opsđối tượng sẽ như sau:

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

Vì vậy, bạn có thể sử dụng nó như bạn muốn. Ví dụ:

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

Các tùy chọn được nhóm cũng được hỗ trợ, vì vậy bạn có thể viết -omthay vì -o -m.

Hơn nữa, stdiocó thể tạo ra một đầu ra trợ giúp / sử dụng tự động. Nếu bạn gọi, ops.printHelp()bạn sẽ nhận được những điều sau đây:

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

Thông báo trước cũng được hiển thị nếu một tùy chọn bắt buộc không được đưa ra (trước thông báo lỗi) hoặc nếu nó bị xác định sai (ví dụ: nếu bạn chỉ định một đối số cho một tùy chọn và nó cần 2).

Bạn có thể cài đặt mô-đun stdio bằng NPM :

npm install stdio

Nếu tập lệnh của bạn được gọi là myScript.js và bạn muốn chuyển tên và họ, 'Sean Worthington', như các đối số như dưới đây:

node myScript.js Sean Worthington

Sau đó, trong kịch bản của bạn, bạn viết:

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

dòng lệnh-args là đáng xem!

Bạn có thể đặt các tùy chọn bằng cách sử dụng các tiêu chuẩn ký hiệu chính ( tìm hiểu thêm ). Các lệnh này đều tương đương, thiết lập các giá trị giống nhau:

$ 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

Để truy cập các giá trị, trước tiên hãy tạo một danh sách các định nghĩa tùy chọn mô tả các tùy chọn mà ứng dụng của bạn chấp nhận. Các typebất động sản là một hàm setter (giá trị cung cấp được chuyển qua chuyện này), đem lại cho bạn toàn quyền kiểm soát các giá trị nhận được.

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

Tiếp theo, phân tích các tùy chọn bằng lệnhLineArss () :

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

options bây giờ trông như thế này:

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

Sử dụng nâng cao

Bên cạnh cách sử dụng thông thường ở trên, bạn có thể định cấu hình dòng lệnh để chấp nhận các dạng cú pháp nâng cao hơn.

Cú pháp dựa trên lệnh (kiểu git) ở dạng:

$ executable <command> [options]

Ví dụ.

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

Cú pháp lệnh và lệnh phụ (kiểu docker) ở dạng:

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

Ví dụ.

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

Hướng dẫn sử dụng thế hệ

Hướng dẫn sử dụng (thường được in khi --helpđược đặt) có thể được tạo bằng cách sử dụng dòng lệnh . Xem các ví dụ dưới đây và đọc tài liệu để được hướng dẫn cách tạo chúng.

Một ví dụ hướng dẫn sử dụng điển hình.

Các polymer-cli hướng dẫn sử dụng là một ví dụ thực tế cuộc sống tốt.

Đọc thêm

Còn nhiều điều để tìm hiểu, vui lòng xem wiki để biết ví dụ và tài liệu.

Có một ứng dụng cho điều đó. Vâng, mô-đun. Vâng, nhiều hơn một, có thể là hàng trăm.

Yargs là một trong những trò vui, tài liệu của nó rất hay để đọc.

Đây là một ví dụ từ trang github / npm:

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

Đầu ra là ở đây (nó đọc các tùy chọn với dấu gạch ngang, ngắn và dài, số vv).

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

Đây là giải pháp 0-dep của tôi cho các đối số được đặt tên:

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)

Thí dụ:

$ node test.js foo=bar fizz=buzz
bar
buzz

Lưu ý: Đương nhiên điều này sẽ thất bại khi đối số chứa a =. Điều này chỉ để sử dụng rất đơn giản.

Có lẽ là một ý tưởng tốt để quản lý cấu hình của bạn theo cách tập trung bằng cách sử dụng một cái gì đó như nconf https://github.com/flatiron/nconf

Nó giúp bạn làm việc với các tệp cấu hình, biến môi trường, đối số dòng lệnh.

không có librairies: sử dụng Array.prototype.reduce ()

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

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

}, {})

cho lệnh này node index.js count=2 print debug=false msg=hi

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

cũng thế,

chúng ta có thể thay đổi

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

bởi (lâu hơn nhiều)

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

để tự động phân tích Boolean & Number

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

Vượt qua, phân tích đối số là một quá trình dễ dàng. Node cung cấp cho bạn thuộc tính process.argv, là một chuỗi các chuỗi, là các đối số được sử dụng khi Node được gọi. Mục nhập đầu tiên của mảng là tệp thực thi Node và mục nhập thứ hai là tên tập lệnh của bạn.

Nếu bạn chạy tập lệnh dưới đây

$ node args.js arg1 arg2

Tệp: args.js

console.log(process.argv)

Bạn sẽ nhận được mảng như

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

npm install ps-grab

Nếu bạn muốn chạy một cái gì đó như thế này:

node greeting.js --user Abdennour --website http://abdennoor.com 

-

var grab=require('ps-grab');
grab('--username') // return 'Abdennour'
grab('--action') // return 'http://abdennoor.com'

Hoặc một cái gì đó như:

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

Thiết bị đầu cuối:

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

Kết quả:

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.

Giải thích:

0 : Thư mục của node.exe trong quá trình gia công của bạn (C: \ Program Files \ nodejs \ node.exe ')

1: Thư mục của tập tin dự án của bạn. (proj.js)

2 : Đối số đầu tiên của bạn tới nút (arg1)

3 : Đối số thứ hai của bạn tới nút (arg2)

4 : Đối số thứ ba của bạn tới nút (arg3)

đối số thực tế của bạn bắt đầu 2ndchỉ mục mẫu của argvmảng, đó là process.argv[2].

Bạn có thể đạt được các đối số dòng lệnh bằng cách sử dụng system.args. Và tôi sử dụng giải pháp dưới đây để phân tích các đối số thành một đối tượng, vì vậy tôi có thể lấy cái mà tôi muốn theo tên.

var system = require('system');

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

bây giờ bạn không cần biết chỉ số của đối số. sử dụng nó nhưargs.whatever

Lưu ý: bạn nên sử dụng các đối số được đặt tên như file.js x=1 y=2để sử dụng giải pháp này.

Bạn có thể phân tích tất cả các đối số và kiểm tra nếu chúng tồn tại.

tệp: 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;
}

Hơn chỉ làm:

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

Không có thư viện

Nếu bạn muốn làm điều này trong vanilla JS / ES6, bạn có thể sử dụng giải pháp sau

chỉ hoạt động trong 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;
  }, {});

Và lệnh này

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

sẽ tạo ra kết quả như sau

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 Vui lòng sửa mã trong bản đồ và giảm chức năng nếu bạn tìm thấy giải pháp thanh lịch hơn, cảm ơn;)

Mặc dù câu trả lời ở trên là hoàn hảo, và ai đó đã gợi ý về việc sử dụng, nhưng sử dụng gói này thực sự dễ dàng. Đây là một gói đẹp giúp truyền các đối số vào dòng lệnh thực sự dễ dàng.

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

Vui lòng truy cập https://yargs.js.org/ để biết thêm thông tin.

Truyền các đối số là dễ dàng và việc nhận chúng chỉ là vấn đề đọc mảng process.argv mà Node có thể truy cập từ mọi nơi, về cơ bản. Nhưng bạn chắc chắn muốn đọc chúng dưới dạng cặp khóa / giá trị, vì vậy bạn sẽ cần một đoạn mã để diễn giải nó.

Joseph Merdrignac đã đăng một cái đẹp bằng cách sử dụng less, nhưng nó dựa vào một key=valuecú pháp thay vì -k valuevà --key value. Tôi viết lại nó xấu hơn nhiều và lâu hơn để sử dụng tiêu chuẩn thứ hai đó, và tôi sẽ đăng nó như một câu trả lời vì nó không phù hợp như một bài bình luận. Nhưng nó có được công việc được thực hiện.

   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
   },{})

Với mã này, một lệnh node script.js alpha beta -charlie delta --echo foxtrotsẽ cung cấp cho bạn đối tượng sau

args = {
 "alpha":true,
 "beta":true,
 "c":true,
 "h":true,
 "a":true,
 "r":true
 "l":true,
 "i":true,
 "e":"delta",
 "echo":"foxtrot"
}

Cách đơn giản nhất để truy xuất các đối số trong Node.js là thông qua mảng process.argv. Đây là một đối tượng toàn cầu mà bạn có thể sử dụng mà không cần nhập bất kỳ thư viện bổ sung nào để sử dụng nó. Bạn chỉ cần truyền đối số cho ứng dụng Node.js, giống như chúng tôi đã trình bày trước đó và những đối số này có thể được truy cập trong ứng dụng thông qua mảng process.argv.

Phần tử đầu tiên của mảng process.argv sẽ luôn là một đường dẫn hệ thống tệp trỏ đến nút thực thi. Phần tử thứ hai là tên của tệp JavaScript đang được thực thi. Và yếu tố thứ ba là đối số đầu tiên thực sự được người dùng thông qua.

'use strict';

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

Tất cả các tập lệnh này được lặp qua mảng process.argv và in các chỉ mục, cùng với các phần tử được lưu trữ trong các chỉ mục đó. Nó rất hữu ích để gỡ lỗi nếu bạn từng hỏi bạn đang nhận được đối số nào và theo thứ tự nào.

Bạn cũng có thể sử dụng các thư viện như yarg để làm việc với các đối số commnadline.

Giải pháp TypeScript không có thư viện:

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

Đầu vào: ts-node index.js -p param --parameter parameter

Đầu ra: { p: 'param ', parameter: 'parameter' }

process.argvlà bạn của bạn, việc nắm bắt các dòng lệnh args được hỗ trợ nguyên bản trong Node JS. Xem ví dụ dưới đây ::

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

như đã nêu trong các tài liệu nút Thuộc tính process.argv trả về một mảng chứa các đối số dòng lệnh được truyền khi tiến trình Node.js được khởi chạy.

Ví dụ: giả sử tập lệnh sau cho process-args.js:

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

Khởi chạy quy trình Node.js dưới dạng:

 $ node process-args.js one two=three four

Sẽ tạo đầu ra:

0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: four

Hầu hết mọi người đã đưa ra câu trả lời tốt. Tôi cũng muốn đóng góp một cái gì đó ở đây. Tôi đang cung cấp câu trả lời bằng lodashthư viện để lặp qua tất cả các đối số dòng lệnh chúng ta vượt qua trong khi khởi động ứng dụng:

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

Để chạy mã trên, chỉ cần chạy các lệnh sau:

npm install
node index.js xyz abc 123 456

Kết quả sẽ là:

xyz 
abc 
123
456

Cách tốt nhất để truyền các đối số dòng lệnh cho chương trình Node.js là sử dụng Giao diện dòng lệnh (CLI)

Có một mô-đun npm tiện lợi được gọi là nodejs-cli mà bạn có thể sử dụng.

Nếu bạn muốn tạo một cái không có phụ thuộc tôi đã có một cái trên Github của tôi nếu bạn muốn kiểm tra, nó thực sự khá đơn giản và dễ sử dụng, nhấp vào đây .

Giải pháp không phụ thuộc kiểu 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());