Mengirim argumen baris perintah ke skrip npm

The scriptsporsi saya package.jsonsaat ini terlihat seperti ini:

"scripts": {
    "start": "node ./script.js server"
}

... yang berarti saya dapat menjalankan npm startuntuk memulai server. Sejauh ini bagus.

Namun, saya ingin dapat menjalankan sesuatu seperti npm start 8080dan meneruskan argumen script.js(misalnya npm start 8080=> node ./script.js server 8080). Apakah ini mungkin?

Sunting 2014.10.30: Dimungkinkan untuk meneruskan argumen hingga npm runpada npm 2.0.0

Sintaksnya adalah sebagai berikut:

npm run <command> [-- <args>]

Perhatikan yang perlu --. Diperlukan untuk memisahkan params yang diteruskan ke npmperintah itu sendiri dan params diteruskan ke skrip Anda.

Jadi, jika Anda memiliki package.json

"scripts": {
    "grunt": "grunt",
    "server": "node server.js"
}

Maka perintah berikut akan setara:

grunt task:target => npm run grunt -- task:target

node server.js --port=1337 => npm run server -- --port=1337

Untuk mendapatkan nilai parameter, lihat pertanyaan ini . Untuk membaca parameter bernama, mungkin lebih baik menggunakan parsing library seperti yargs atau minimalis ; nodejs mengekspos process.argvsecara global, berisi nilai-nilai parameter baris perintah, tetapi ini adalah API tingkat rendah (array string yang dipisahkan spasi, seperti yang disediakan oleh sistem operasi ke node yang dapat dieksekusi).

Sunting 2013.10.03: Saat ini tidak mungkin secara langsung. Tapi ada masalah GitHubnpm terkait yang dibuka untuk menerapkan perilaku yang Anda minta. Tampaknya konsensus adalah untuk menerapkan ini, tetapi itu tergantung pada masalah lain yang dipecahkan sebelumnya.

Jawaban asli: Sebagai semacam solusi (meskipun tidak terlalu praktis), Anda dapat melakukan hal berikut:

Ucapkan nama paket Anda dari package.jsonis myPackagedan Anda juga

"scripts": {
    "start": "node ./script.js server"
}

Kemudian tambahkan package.json:

"config": {
    "myPort": "8080"
}

Dan di dalam kamu script.js:

// defaulting to 8080 in case if script invoked not via "npm run-script" but directly
var port = process.env.npm_package_config_myPort || 8080

Dengan begitu, secara default npm startakan menggunakan 8080. Namun Anda dapat mengkonfigurasinya (nilainya akan disimpan npmdi penyimpanan internal):

npm config set myPackage:myPort 9090

Kemudian, ketika menjalankan npm start, 9090 akan digunakan (default dari package.jsonakan ditimpa).

Anda diminta untuk dapat menjalankan sesuatu seperti npm start 8080 . Ini dimungkinkan tanpa perlu memodifikasi script.jsatau mengkonfigurasi file sebagai berikut.

Misalnya, dalam "scripts"nilai JSON Anda , include--

"start": "node ./script.js server $PORT"

Dan kemudian dari baris perintah:

$ PORT=8080 npm start

Saya telah mengkonfirmasi bahwa ini berfungsi menggunakan bash dan npm 1.4.23. Perhatikan bahwa penyelesaian ini tidak memerlukan masalah GitHub npm # 3494 untuk diselesaikan.

Anda juga dapat melakukannya:

Dalam package.json:

"scripts": {
    "cool": "./cool.js"
}

Dalam cool.js:

 console.log({ myVar: process.env.npm_config_myVar });

Di CLI:

npm --myVar=something run-script cool

Haruskah output:

{ myVar: 'something' }

Pembaruan: Menggunakan npm 3.10.3, tampaknya ini menurunkan process.env.npm_config_variabel? Saya juga menggunakan better-npm-run, jadi saya tidak yakin apakah ini perilaku standar vanilla atau tidak, tetapi jawaban ini berfungsi. Alih-alih process.env.npm_config_myVar, cobaprocess.env.npm_config_myvar

Jawaban jakub.g benar, namun contoh menggunakan grunt tampaknya agak rumit.

Jadi jawaban saya yang lebih sederhana:

- Mengirim argumen baris perintah ke skrip npm

Sintaks untuk mengirim argumen baris perintah ke skrip npm:

npm run [command] [-- <args>]

Bayangkan kita memiliki tugas awal npm di package.json kita untuk memulai server dev webpack:

"scripts": {
  "start": "webpack-dev-server --port 5000"
},

Kami menjalankan ini dari baris perintah dengan npm start

Sekarang jika kita ingin mengirimkan port ke skrip npm:

"scripts": {
  "start": "webpack-dev-server --port process.env.port || 8080"
},

menjalankan ini dan melewati port eg 5000 melalui command line adalah sebagai berikut:

npm start --port:5000

- Menggunakan package.json config:

Seperti yang disebutkan oleh jakub.g , Anda dapat mengatur params di konfigurasi package.json Anda

"config": {
  "myPort": "5000"
}

"scripts": {
  "start": "webpack-dev-server --port process.env.npm_package_config_myPort || 8080"
},

npm start akan menggunakan port yang ditentukan dalam konfigurasi Anda, atau Anda dapat menimpanya

npm config set myPackage:myPort 3000

- Mengatur param di skrip npm Anda

Contoh membaca set variabel dalam skrip npm Anda. Dalam contoh iniNODE_ENV

"scripts": {
  "start:prod": "NODE_ENV=prod node server.js",
  "start:dev": "NODE_ENV=dev node server.js"
},

baca NODE_ENV di server.js baik prod atau dev

var env = process.env.NODE_ENV || 'prod'

if(env === 'dev'){
    var app = require("./serverDev.js");
} else {
    var app = require("./serverProd.js");
}

npm 2.x mendukung cli args

Perintah

npm run-script start -- --foo=3

Package.json

"start": "node ./index.js"

Index.js

console.log('process.argv', process.argv);

Gunakan process.argvdalam kode Anda lalu berikan jejak $*untuk entri nilai skrip Anda.

Sebagai contoh, cobalah dengan skrip sederhana yang hanya mencatat argumen yang disediakan ke standar echoargs.js:

console.log('arguments: ' + process.argv.slice(2));

package.json:

"scripts": {
    "start": "node echoargs.js $*"
}

Contoh:

> npm start 1 2 3
arguments: 1,2,3

process.argv[0]adalah executable (node), process.argv[1]adalah skrip Anda.

Diuji dengan npm v5.3.0 dan node v8.4.0

Jika Anda ingin meneruskan argumen ke tengah skrip npm, bukan hanya menambahkannya ke akhir, maka variabel lingkungan inline tampaknya berfungsi dengan baik:

"scripts": {
  "dev": "BABEL_ARGS=-w npm run build && cd lib/server && nodemon index.js",
  "start": "npm run build && node lib/server/index.js",
  "build": "mkdir -p lib && babel $BABEL_ARGS -s inline --stage 0 src -d lib",
},

Di sini, npm run devmelewati -wbendera arloji ke babel, tetapi npm run starthanya menjalankan bangunan biasa sekali.

Saya telah menggunakan one-liner ini di masa lalu, dan setelah sedikit waktu dari Node.js harus mencoba dan menemukan kembali baru-baru ini. Mirip dengan solusi yang disebutkan oleh @francoisrv, ia menggunakan node_config_*variabel.

Buat package.jsonfile minimal berikut :

{
  "name": "argument",
  "version": "1.0.0",
  "scripts": {
    "argument": "echo \"The value of --foo is '${npm_config_foo}'\""
  }
}

Jalankan perintah berikut:

npm run argument --foo=bar

Perhatikan output berikut:

Nilai --foo adalah 'bar'

Semua ini didokumentasikan dengan baik dalam dokumentasi resmi npm:

• https://docs.npmjs.com/using-npm/config

Catatan: Judul Variabel Lingkungan menjelaskan bahwa variabel di dalam skrip berperilaku berbeda dengan apa yang didefinisikan dalam dokumentasi. Ini benar ketika datang ke sensitivitas kasus , serta apakah argumen didefinisikan dengan spasi atau sama dengan tanda .

Catatan: Jika Anda menggunakan argumen dengan tanda hubung, ini akan diganti dengan garis bawah pada variabel lingkungan yang sesuai. Misalnya, npm run example --foo-bar=bazakan sesuai dengan ${npm_config_foo_bar}.

Catatan: Untuk pengguna Windows non-WSL, lihat komentar @ Doctor Blue di bawah ini ... TL; DR ganti ${npm_config_foo}dengan %npm_config_foo%.

Ini tidak benar-benar menjawab pertanyaan Anda tetapi Anda selalu dapat menggunakan variabel lingkungan sebagai gantinya:

"scripts": {
    "start": "PORT=3000 node server.js"
}

Kemudian di file server.js Anda:

var port = process.env.PORT || 3000;

Sebagian besar jawaban di atas mencakup hanya meneruskan argumen ke skrip NodeJS Anda, yang dipanggil oleh npm. Solusi saya adalah untuk penggunaan umum.

Hanya membungkus skrip npm dengan interpreter shell (mis. sh) Panggilan dan meneruskan argumen seperti biasa. Satu-satunya pengecualian adalah nomor argumen pertama adalah0 .

Misalnya, Anda ingin menambahkan skrip npm someprogram --env=<argument_1>, di mana someprogramhanya mencetak nilai envargumen:

package.json

"scripts": {
  "command": "sh -c 'someprogram --env=$0'"
}

Ketika Anda menjalankannya:

% npm run -s command my-environment
my-environment

Dari apa yang saya lihat, orang menggunakan skrip package.json ketika mereka ingin menjalankan skrip dengan cara yang lebih sederhana. Sebagai contoh, untuk menggunakan nodemonyang diinstal pada node_modules lokal, kita tidak dapat memanggil nodemonlangsung dari cli, tetapi kita dapat menyebutnya dengan menggunakan ./node_modules/nodemon/nodemon.js. Jadi, untuk menyederhanakan mengetik panjang ini, kita dapat menempatkan ini ...

    ...

    skrip: {
      'start': 'nodemon app.js'
    }

    ...

... lalu panggil npm startuntuk menggunakan 'nodemon' yang memiliki app.js sebagai argumen pertama.

Apa yang saya coba katakan, jika Anda hanya ingin memulai server Anda dengan nodeperintah, saya tidak berpikir Anda perlu menggunakan scripts. Mengetik npm startatau node app.jsmemiliki usaha yang sama.

Tetapi jika Anda ingin menggunakan nodemon, dan ingin memberikan argumen yang dinamis, jangan gunakan scriptkeduanya. Coba gunakan symlink saja.

Misalnya menggunakan migrasi dengan sequelize. Saya membuat symlink ...

ln -s node_modules/sequelize/bin/sequelize sequelize

... Dan saya bisa memberikan argumen ketika saya menyebutnya ...

./sequlize -h /* show help */

./sequelize -m /* upgrade migration */

./sequelize -m -u /* downgrade migration */

dll ...

Pada titik ini, menggunakan symlink adalah cara terbaik yang bisa saya pikirkan, tetapi saya tidak benar-benar berpikir itu adalah praktik terbaik.

Saya juga berharap pendapat Anda untuk jawaban saya.

Catatan: Pendekatan ini mengubah Anda package.jsondengan cepat, gunakan jika Anda tidak memiliki alternatif.

Saya harus meneruskan argumen baris perintah ke skrip saya yang kira-kira seperti:

"scripts": {
    "start": "npm run build && npm run watch",
    "watch": "concurrently  \"npm run watch-ts\" \"npm run watch-node\"",
    ...
}

Jadi, ini berarti saya memulai aplikasi saya dengan npm run start.

Sekarang jika saya ingin memberikan beberapa argumen, saya akan mulai dengan mungkin:

npm run start -- --config=someConfig

Apa yang dilakukan adalah: npm run build && npm run watch -- --config=someConfig. Masalah dengan ini adalah, selalu menambahkan argumen di akhir skrip. Ini berarti semua skrip dirantai tidak mendapatkan argumen ini (Args mungkin atau mungkin tidak diperlukan oleh semua, tapi itu cerita yang berbeda.). Lebih jauh ketika skrip yang terhubung dipanggil maka skrip tersebut tidak akan mendapatkan argumen yang diteruskan. yaitu watchskrip tidak akan mendapatkan argumen yang lulus.

Penggunaan produksi aplikasi saya adalah sebagai .exe, jadi melewati argumen di exe berfungsi dengan baik tetapi jika ingin melakukan ini selama pengembangan, itu akan bermasalah.

Saya tidak dapat menemukan cara yang tepat untuk mencapai ini, jadi inilah yang saya coba.

Saya telah membuat file javascript: start-script.jspada tingkat induk aplikasi, saya memiliki "default.package.json" dan alih-alih mempertahankan "package.json", saya memelihara "default.package.json". Tujuannya start-script.jsonadalah membaca default.package.json, mengekstrak, scriptsdan mencari npm run scriptnamelalu menambahkan argumen yang lolos ke skrip ini. Setelah ini, itu akan membuat yang baru package.jsondan menyalin data dari default.package.json dengan skrip yang dimodifikasi dan kemudian memanggil npm run start.

const fs = require('fs');
const { spawn } = require('child_process');

// open default.package.json
const defaultPackage = fs.readFileSync('./default.package.json');
try {
    const packageOb = JSON.parse(defaultPackage);
    // loop over the scripts present in this object, edit them with flags
    if ('scripts' in packageOb && process.argv.length > 2) {

        const passedFlags = ` -- ${process.argv.slice(2).join(' ')}`;
        // assuming the script names have words, : or -, modify the regex if required.
        const regexPattern = /(npm run [\w:-]*)/g;
        const scriptsWithFlags = Object.entries(packageOb.scripts).reduce((acc, [key, value]) => {
            const patternMatches = value.match(regexPattern);
            // loop over all the matched strings and attach the desired flags.
            if (patternMatches) {
                for (let eachMatchedPattern of patternMatches) {
                    const startIndex = value.indexOf(eachMatchedPattern);
                    const endIndex = startIndex + eachMatchedPattern.length;
                    // save the string which doen't fall in this matched pattern range.
                    value = value.slice(0, startIndex) + eachMatchedPattern + passedFlags + value.slice(endIndex);
                }
            }
            acc[key] = value;
            return acc;
        }, {});
        packageOb.scripts = scriptsWithFlags;
    }

    const modifiedJSON = JSON.stringify(packageOb, null, 4);
    fs.writeFileSync('./package.json', modifiedJSON);

    // now run your npm start script
    let cmd = 'npm';
    // check if this works in your OS
    if (process.platform === 'win32') {
        cmd = 'npm.cmd';    // https://github.com/nodejs/node/issues/3675
    }
    spawn(cmd, ['run', 'start'], { stdio: 'inherit' });

} catch(e) {
    console.log('Error while parsing default.package.json', e);
}

Sekarang, alih-alih melakukan npm run start, saya lakukannode start-script.js --c=somethis --r=somethingElse

Proses awal terlihat baik-baik saja, tetapi belum diuji secara menyeluruh. Gunakan itu, jika Anda suka untuk pengembangan aplikasi Anda.

Saya telah menemukan pertanyaan ini ketika saya mencoba untuk menyelesaikan masalah saya dengan menjalankan sequelize seed: menghasilkan perintah cli:

node_modules/.bin/sequelize seed:generate --name=user

Biarkan saya langsung ke intinya. Saya ingin memiliki perintah skrip pendek dalam file package.json saya dan untuk memberikan argumen --name pada saat yang sama

Jawabannya muncul setelah beberapa percobaan. Ini adalah perintah saya di package.json

"scripts: {
  "seed:generate":"NODE_ENV=development node_modules/.bin/sequelize seed:generate"
}

... dan di sini adalah contoh menjalankannya di terminal untuk menghasilkan file seed untuk pengguna

> yarn seed:generate --name=user

> npm run seed:generate -- --name=user

FYI

yarn -v
1.6.0

npm -v
5.6.0

npm run script_target - <argumen> Pada dasarnya ini adalah cara meneruskan argumen baris perintah tetapi itu akan bekerja hanya dalam kasus ketika skrip hanya memiliki satu perintah yang berjalan seperti saya menjalankan perintah yaitu npm run start - 4200

"script":{
       "start" : "ng serve --port="
 }

Ini akan berjalan untuk melewati parameter baris perintah tetapi bagaimana jika kita menjalankan lebih dari satu perintah bersama seperti npm run build c: / workspace / file

"script":{
       "build" : "copy c:/file <arg> && ng build"
 } 

tapi itu akan juru bahasa seperti ini saat menjalankan copy c: / file && ng build c: / ruang kerja / file dan kita diharapkan sesuatu seperti copy ini c: / file c: / ruang kerja / file && ng build

Catatan: - jadi parameter baris perintah hanya berfungsi iklan yang diharapkan jika hanya satu perintah dalam skrip.

Saya membaca beberapa jawaban di atas di mana beberapa dari mereka menulis bahwa Anda dapat mengakses parameter baris perintah menggunakan $ simbol tetapi ini tidak akan berhasil

Saya tahu sudah ada jawaban yang disetujui, tapi saya agak suka pendekatan JSON ini.

npm start '{"PROJECT_NAME_STR":"my amazing stuff", "CRAZY_ARR":[0,7,"hungry"], "MAGICAL_NUMBER_INT": 42, "THING_BOO":true}';

Biasanya saya punya 1 var yang saya butuhkan, seperti nama proyek, jadi saya menemukan ini cepat dan sederhana.

Juga saya sering memiliki sesuatu seperti ini di package.json saya

"scripts": {
    "start": "NODE_ENV=development node local.js"
}

Dan menjadi serakah saya ingin "semuanya", NODE_ENV dan hal-hal garis CMD arg.

Anda cukup mengakses hal-hal ini seperti di file Anda (dalam kasus saya local.js)

console.log(process.env.NODE_ENV, starter_obj.CRAZY_ARR, starter_obj.PROJECT_NAME_STR, starter_obj.MAGICAL_NUMBER_INT, starter_obj.THING_BOO);

Anda hanya perlu memiliki bit ini di atasnya (saya menjalankan v10.16.0 btw)

var starter_obj = JSON.parse(JSON.parse(process.env.npm_config_argv).remain[0]);

Anyhoo, pertanyaan sudah dijawab. Kupikir aku akan berbagi, karena aku banyak menggunakan metode ini.