Saya memiliki server web yang ditulis dalam Node.js dan saya ingin memulai dengan folder tertentu. Saya tidak yakin cara mengakses argumen dalam JavaScript. Saya menjalankan simpul seperti ini:

$ node server.js folder

di sini server.jsadalah kode server saya. Bantuan Node.js mengatakan ini mungkin:

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

Bagaimana saya mengakses argumen itu dalam JavaScript? Entah bagaimana saya tidak dapat menemukan informasi ini di web.

Metode Standar (tidak ada perpustakaan)

Argumen disimpan di process.argv

Berikut adalah simpul dokumen tentang penanganan args baris perintah:

process.argvadalah array yang berisi argumen baris perintah. Elemen pertama adalah 'simpul', elemen kedua adalah nama dari file JavaScript. Elemen berikutnya adalah argumen baris perintah tambahan.

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

Ini akan menghasilkan:

$ 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

Untuk menormalkan argumen seperti yang akan diterima fungsi javascript, saya melakukan ini di skrip shell node.js saya:

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

Perhatikan bahwa arg pertama biasanya path ke nodejs, dan arg kedua adalah lokasi skrip yang Anda jalankan.

Jawaban tepat yang terkini untuk ini adalah menggunakan perpustakaan minimalis . Kami dulu menggunakan optimis-simpul tetapi sejak itu sudah usang.

Berikut adalah contoh cara menggunakannya diambil langsung dari dokumentasi minimalis:

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 menjawab berdasarkan tren saat ini di alam:

Argumen javascript vanilla:

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

Ini mengembalikan:

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

Dokumen resmi

Paket NPM yang paling banyak digunakan untuk penguraian argumen:

Minimist : Untuk parsing argumen minimal.

Commander.js : Modul yang paling banyak diadopsi untuk parsing argumen.

Meow : Alternatif yang lebih ringan untuk Commander.js

Yargs : Argumen yang lebih canggih (berat).

Vorpal.js : Aplikasi baris perintah yang matang / interaktif dengan penguraian argumen.

Optimis (optimis-simpul)

Lihat pustaka optimis , itu jauh lebih baik daripada parsing opsi baris perintah dengan tangan.

Memperbarui

Optimis sudah usang. Coba yarg yang merupakan garpu optimis aktif.

Beberapa jawaban bagus di sini, tetapi semuanya tampak sangat kompleks. Ini sangat mirip dengan bagaimana nilai skrip bash mengakses nilai argumen dan sudah disediakan standar dengan node.js seperti yang ditunjukkan MooGoo. (Hanya untuk membuatnya dimengerti oleh seseorang yang baru ke node.js)

Contoh:

$ 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

Sangat bagus untuk menentukan opsi, tindakan, dan argumen Anda. Ini juga menghasilkan halaman bantuan untuk Anda.

Tepat

Berfungsi bagus untuk mendapatkan input dari pengguna, jika Anda menyukai pendekatan panggilan balik.

Prompt

Berfungsi bagus untuk mendapatkan input dari pengguna, jika Anda suka pendekatan generator.

Tidak Ada Lib dengan Bendera yang Diformat menjadi Objek Sederhana

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

Contohnya

Sederhana

memasukkan

node test.js -D --name=Hello

keluaran

{ D: true, name: 'Hello' }

Dunia nyata

memasukkan

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

keluaran

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

Perpustakaan Stdio

Cara termudah untuk mem-parsing argumen baris perintah di NodeJS adalah menggunakan modul stdio . Terinspirasi oleh getoptutilitas UNIX , itu sepele seperti berikut:

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

Jika Anda menjalankan kode sebelumnya dengan perintah ini:

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

Maka opsobjeknya adalah sebagai berikut:

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

Jadi Anda bisa menggunakannya sesuka Anda. Contohnya:

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

Opsi yang dikelompokkan juga didukung, sehingga Anda dapat menulis -omalih-alih -o -m.

Selanjutnya, stdiodapat menghasilkan output bantuan / penggunaan secara otomatis. Jika Anda menelepon, ops.printHelp()Anda akan mendapatkan yang berikut ini:

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

Pesan sebelumnya ditampilkan juga jika opsi wajib tidak diberikan (didahului oleh pesan kesalahan) atau jika salah tentukan (misalnya, jika Anda menentukan satu argumen untuk opsi dan perlu 2).

Anda dapat menginstal modul stdio menggunakan NPM :

npm install stdio

Jika skrip Anda disebut myScript.js dan Anda ingin memberikan nama depan dan belakang, 'Sean Worthington', sebagai argumen seperti di bawah ini:

node myScript.js Sean Worthington

Kemudian dalam skrip Anda, Anda menulis:

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

command-line-args layak untuk dilihat!

Anda dapat mengatur opsi menggunakan standar notasi utama ( pelajari lebih lanjut ). Semua perintah ini setara, menetapkan nilai yang sama:

$ 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

Untuk mengakses nilai, pertama buat daftar definisi opsi yang menggambarkan opsi yang diterima aplikasi Anda. The typeproperti adalah fungsi setter (nilai yang diberikan dilewatkan melalui ini), memberikan Anda kontrol penuh atas nilai yang diterima.

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

Selanjutnya, uraikan opsi menggunakan commandLineArgs () :

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

options sekarang terlihat seperti ini:

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

Penggunaan tingkat lanjut

Selain penggunaan tipikal di atas, Anda dapat mengonfigurasi baris perintah untuk menerima bentuk sintaksis yang lebih canggih.

Sintaks berbasis perintah (gaya git) dalam bentuk:

$ executable <command> [options]

Sebagai contoh.

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

Perintah dan sub-perintah sintaks (gaya buruh pelabuhan) dalam bentuk:

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

Sebagai contoh.

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

Pembuatan panduan penggunaan

Panduan penggunaan (biasanya dicetak saat --helpdisetel) dapat dibuat menggunakan penggunaan baris perintah . Lihat contoh di bawah dan baca dokumentasi untuk instruksi cara membuatnya.

Contoh panduan penggunaan khas.

The polimer-cli panduan penggunaan adalah contoh kehidupan nyata baik.

Bacaan lebih lanjut

Ada banyak lagi yang harus dipelajari, silakan lihat wiki untuk contoh dan dokumentasi.

Ada aplikasi untuk itu. Nah, modul. Ya, lebih dari satu, mungkin ratusan.

Yargs adalah salah satu yang menyenangkan, dokumennya keren untuk dibaca.

Berikut ini contoh dari halaman github / npm:

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

Output di sini (membaca opsi dengan tanda hubung dll, pendek dan panjang, numerik dll).

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

Inilah solusi 0-dep saya untuk argumen bernama:

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)

Contoh:

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

Catatan: Secara alami ini akan gagal ketika argumen berisi a =. Ini hanya untuk penggunaan yang sangat sederhana.

Mungkin ide yang baik untuk mengelola konfigurasi Anda secara terpusat menggunakan sesuatu seperti nconf https://github.com/flatiron/nconf

Ini membantu Anda bekerja dengan file konfigurasi, variabel lingkungan, argumen baris perintah.

tanpa 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

}, {})

untuk perintah ini node index.js count=2 print debug=false msg=hi

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

juga,

kita bisa berubah

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

oleh (lebih lama)

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

untuk mengurai Boolean & Nomor

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

Melewati, mengurai argumen adalah proses yang mudah. Node memberi Anda properti process.argv, yang merupakan array dari string, yang merupakan argumen yang digunakan ketika Node dipanggil. Entri pertama array adalah Node yang dapat dieksekusi, dan entri kedua adalah nama skrip Anda.

Jika Anda menjalankan skrip dengan atguments di bawah ini

$ node args.js arg1 arg2

File: args.js

console.log(process.argv)

Anda akan mendapatkan array seperti

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

npm install ps-grab

Jika Anda ingin menjalankan sesuatu seperti ini:

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

-

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

Atau sesuatu seperti:

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

Terminal:

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

Hasil:

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.

Penjelasan:

0 : Direktori node.exe di maching Anda (C: \ Program Files \ nodejs \ node.exe ')

1: Direktori file proyek Anda. (proj.js)

2 : Argumen pertama Anda ke simpul (arg1)

3 : Argumen kedua Anda ke simpul (arg2)

4 : Argumen ketiga Anda ke simpul (arg3)

argumen Anda yang sebenarnya mulai berupa 2ndindeks argvarray, yaitu process.argv[2].

Anda dapat mencapai argumen baris perintah menggunakan system.args. Dan saya menggunakan solusi di bawah ini untuk mem-parsing argumen menjadi objek, jadi saya bisa mendapatkan yang saya inginkan dengan nama.

var system = require('system');

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

sekarang Anda tidak perlu tahu indeks argumennya. gunakan sepertiargs.whatever

Catatan: Anda harus menggunakan argumen bernama ingin file.js x=1 y=2menggunakan solusi ini.

Anda dapat mem-parsing semua argumen dan memeriksa apakah ada.

file: 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;
}

Dari sekadar melakukan:

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

Tanpa perpustakaan

Jika Anda ingin melakukan ini di vanilla JS / ES6 Anda dapat menggunakan solusi berikut

hanya bekerja di 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;
  }, {});

Dan perintah ini

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

akan menghasilkan hasil sebagai berikut

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 Harap perbaiki kode di peta dan kurangi fungsi jika Anda menemukan solusi yang lebih elegan, terima kasih;)

Meskipun jawaban di atas sempurna, dan seseorang telah menyarankan yarg, menggunakan paket itu sangat mudah. Ini adalah paket yang bagus yang membuat argumen lewat perintah ke baris sangat mudah.

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

Silakan kunjungi https://yargs.js.org/ untuk info lebih lanjut.

Melewati argumen itu mudah, dan menerimanya hanya masalah membaca prosesnya. Array array Node dapat diakses dari mana saja, pada dasarnya. Tapi Anda pasti ingin membacanya sebagai pasangan kunci / nilai, jadi Anda perlu bagian untuk skrip untuk menafsirkannya.

Joseph Merdrignac memposting yang indah menggunakan pengurangan, tetapi itu bergantung pada key=valuesintaks, bukan -k valuedan --key value. Saya menulis ulang itu jauh lebih jelek dan lebih lama untuk menggunakan standar kedua itu, dan saya akan mempostingnya sebagai jawaban karena itu tidak cocok sebagai komentar. Tapi itu menyelesaikan pekerjaan.

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

Dengan kode ini, sebuah perintah node script.js alpha beta -charlie delta --echo foxtrotakan memberi Anda objek berikut

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

Cara paling sederhana untuk mengambil argumen di Node.js adalah melalui array process.argv. Ini adalah objek global yang dapat Anda gunakan tanpa mengimpor pustaka tambahan untuk menggunakannya. Anda hanya perlu meneruskan argumen ke aplikasi Node.js, seperti yang kami tunjukkan sebelumnya, dan argumen ini dapat diakses di dalam aplikasi melalui array process.argv.

Elemen pertama dari array process.argv akan selalu berupa jalur sistem file yang menunjuk ke node yang dapat dieksekusi. Elemen kedua adalah nama file JavaScript yang sedang dieksekusi. Dan elemen ketiga adalah argumen pertama yang sebenarnya disahkan oleh pengguna.

'use strict';

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

Semua skrip ini lakukan adalah loop melalui array process.argv dan mencetak indeks, bersama dengan elemen yang disimpan dalam indeks tersebut. Ini sangat berguna untuk debugging jika Anda pernah mempertanyakan argumen apa yang Anda terima, dan dalam urutan apa.

Anda juga dapat menggunakan pustaka seperti yarg untuk bekerja dengan argumen commnadline.

Solusi TypeScript tanpa pustaka:

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

Memasukkan: ts-node index.js -p param --parameter parameter

Keluaran: { p: 'param ', parameter: 'parameter' }

process.argvadalah teman Anda, menangkap argumen baris perintah secara asli didukung di Node JS. Lihat contoh di bawah ini ::

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

seperti yang dinyatakan dalam node docs Properti process.argv mengembalikan sebuah array yang berisi argumen baris perintah yang dilewati ketika proses Node.js diluncurkan.

Misalnya, dengan asumsi skrip berikut untuk proses-args.js:

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

Meluncurkan proses Node.js sebagai:

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

Akan menghasilkan output:

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

Sebagian besar orang sudah memberikan jawaban yang baik. Saya juga ingin berkontribusi sesuatu di sini. Saya memberikan jawaban menggunakan lodashpustaka untuk beralih melalui semua argumen baris perintah yang kami lewati saat memulai aplikasi:

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

Untuk menjalankan kode di atas cukup jalankan perintah berikut:

npm install
node index.js xyz abc 123 456

Hasilnya adalah:

xyz 
abc 
123
456

Cara terbaik untuk meneruskan argumen baris perintah ke program Node.js adalah dengan menggunakan Command Line Interface (CLI)

Ada modul npm bagus yang disebut nodejs-cli yang dapat Anda gunakan.

Jika Anda ingin membuatnya tanpa ketergantungan, saya punya satu di Github saya jika Anda ingin melihatnya, sebenarnya cukup sederhana dan mudah digunakan, klik di sini .

Solusi tanpa ketergantungan gaya 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());