Senden von Befehlszeilenargumenten an das npm-Skript

Der scriptsTeil von mir package.jsonsieht derzeit so aus:

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

... was bedeutet, dass ich laufen kann npm start, um den Server zu starten. So weit, ist es gut.

Ich möchte jedoch in der Lage sein, so etwas wie auszuführen npm start 8080und die Argumente an script.js(z . B. npm start 8080=> node ./script.js server 8080) übergeben zu lassen. Ist das möglich?

Edit 2014.10.30: Es ist möglich, Argumente ab npm 2.0.0 zu übergebennpm run

Die Syntax lautet wie folgt:

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

Beachten Sie die notwendigen --. Es ist erforderlich, die an den npmBefehl selbst übergebenen Parameter und die an Ihr Skript übergebenen Parameter zu trennen .

Also, wenn Sie in haben package.json

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

Dann wären die folgenden Befehle äquivalent:

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

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

Informationen zum Abrufen des Parameterwerts finden Sie in dieser Frage . Zum Lesen benannter Parameter ist es wahrscheinlich am besten, eine Analysebibliothek wie yargs oder minimist zu verwenden . nodejs macht process.argvglobal verfügbar und enthält Befehlszeilenparameterwerte. Dies ist jedoch eine API auf niedriger Ebene (durch Leerzeichen getrenntes Array von Zeichenfolgen, wie vom Betriebssystem für die ausführbare Datei des Knotens bereitgestellt).

Edit 2013.10.03: Es ist derzeit nicht direkt möglich. Es wurde jedoch ein verwandtes GitHub-Problem geöffnetnpm , um das gewünschte Verhalten zu implementieren. Es scheint, dass der Konsens darin besteht, dies umzusetzen, aber es hängt davon ab, ob ein anderes Problem zuvor gelöst wurde.

Ursprüngliche Antwort: Als eine Art Problemumgehung (obwohl nicht sehr praktisch) können Sie Folgendes tun:

Sagen Sie Ihren Paketnamen von package.jsonist myPackageund Sie haben auch

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

Dann fügen Sie hinzu package.json:

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

Und in deinem 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

Auf diese Weise wird standardmäßig npm start8080 verwendet. Sie können es jedoch konfigurieren (der Wert wird von npmin seinem internen Speicher gespeichert ):

npm config set myPackage:myPort 9090

Beim Aufrufen npm startwird dann 9090 verwendet (der Standardwert von package.jsonwird überschrieben).

Sie werden gefragt, um etwas laufen wie npm start 8080 . Dies ist möglich, ohne dass script.jsDateien wie folgt geändert oder konfiguriert werden müssen.

"scripts"Schließen Sie beispielsweise in Ihrem JSON-Wert Folgendes ein:

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

Und dann von der Kommandozeile:

$ PORT=8080 npm start

Ich habe bestätigt, dass dies mit bash und npm 1.4.23 funktioniert. Beachten Sie, dass für diese Problemumgehung das GitHub npm- Problem Nr. 3494 nicht behoben werden muss.

Sie könnten das auch tun:

In package.json:

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

In cool.js:

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

In der CLI:

npm --myVar=something run-script cool

Sollte ausgeben:

{ myVar: 'something' }

Update: Mit npm 3.10.3 scheint es, dass die process.env.npm_config_Variablen in Kleinbuchstaben geschrieben werden? Ich bin auch mit better-npm-run, so dass ich nicht sicher bin , ob die Vanille-Standardverhalten ist oder nicht, aber diese Antwort ist zu arbeiten. process.env.npm_config_myVarVersuchen Sie es stattdessenprocess.env.npm_config_myvar

Die Antwort von jakub.g ist richtig, ein Beispiel mit Grunzen scheint jedoch etwas komplex.

Also meine einfachere Antwort:

- Senden eines Befehlszeilenarguments an ein npm-Skript

Syntax zum Senden von Befehlszeilenargumenten an ein npm-Skript:

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

Stellen Sie sich vor, wir haben eine npm-Startaufgabe in unserer package.json, um den Webpack-Entwicklungsserver zu starten:

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

Wir führen dies von der Kommandozeile aus mit npm start

Wenn wir nun einen Port an das npm-Skript übergeben möchten:

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

Dies auszuführen und den Port zB 5000 über die Befehlszeile zu übergeben, wäre wie folgt:

npm start --port:5000

- Verwenden von package.json config:

Wie von jakub.g erwähnt , können Sie alternativ Parameter in der Konfiguration Ihrer package.json festlegen

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

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

npm start verwendet den in Ihrer Konfiguration angegebenen Port, oder Sie können ihn alternativ überschreiben

npm config set myPackage:myPort 3000

- Festlegen eines Parameters in Ihrem npm-Skript

Ein Beispiel für das Lesen eines Variablensatzes in Ihrem npm-Skript. In diesem BeispielNODE_ENV

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

Lesen Sie NODE_ENV in server.js entweder prod oder 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 unterstützt cli args

Befehl

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

Package.json

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

Index.js

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

Verwenden Sie es process.argvin Ihrem Code und geben Sie dann nur einen Trailing $*für die Eingabe Ihres Skriptwerts ein.

Versuchen Sie es beispielsweise mit einem einfachen Skript, das nur die angegebenen Argumente als Standard protokolliert echoargs.js:

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

package.json:

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

Beispiele:

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

process.argv[0]ist die ausführbare Datei (Knoten), process.argv[1]ist Ihr Skript.

Getestet mit npm v5.3.0 und Node v8.4.0

Wenn Sie Argumente an die Mitte eines npm-Skripts übergeben möchten, anstatt sie nur an das Ende anzuhängen, scheinen Inline-Umgebungsvariablen gut zu funktionieren:

"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",
},

Hier wird npm run devdie -wWatch-Flagge an babel übergeben, aber npm run startnur einmal ein regulärer Build ausgeführt.

Ich hatte diesen Einzeiler in der Vergangenheit verwendet und musste nach einiger Zeit von Node.js versuchen, ihn kürzlich wiederzuentdecken. Ähnlich wie bei der von @francoisrv erwähnten Lösung werden die node_config_*Variablen verwendet.

Erstellen Sie die folgende minimale package.jsonDatei:

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

Führen Sie den folgenden Befehl aus:

npm run argument --foo=bar

Beachten Sie die folgende Ausgabe:

Der Wert von --foo ist 'bar'

All dies ist in der offiziellen Dokumentation von npm gut dokumentiert:

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

Hinweis: In der Überschrift Umgebungsvariablen wird erläutert, dass sich Variablen in Skripten anders verhalten als in der Dokumentation definiert. Dies gilt auch für die Groß- und Kleinschreibung , unabhängig davon, ob das Argument mit einem Leerzeichen oder einem Gleichheitszeichen definiert ist .

Hinweis: Wenn Sie ein Argument mit Bindestrichen verwenden, werden diese in der entsprechenden Umgebungsvariablen durch Unterstriche ersetzt. Zum Beispiel npm run example --foo-bar=bazwürde entsprechen ${npm_config_foo_bar}.

Hinweis: Für Nicht-WSL Windows - Benutzer finden @Doctor Blau Kommentare unten ... TL; DR ersetzen ${npm_config_foo}mit %npm_config_foo%.

Dies beantwortet Ihre Frage nicht wirklich, aber Sie können stattdessen immer Umgebungsvariablen verwenden:

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

Dann in Ihrer server.js-Datei:

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

Die meisten der obigen Antworten beziehen sich nur auf die Übergabe der Argumente an Ihr NodeJS-Skript, das von npm aufgerufen wird. Meine Lösung ist für den allgemeinen Gebrauch.

Umschließen Sie das npm-Skript einfach mit einem Shell-Interpreter- shAufruf (z. B. ) und übergeben Sie die Argumente wie gewohnt. Die einzige Ausnahme ist, dass die erste Argumentnummer lautet 0.

Sie möchten beispielsweise das npm-Skript hinzufügen someprogram --env=<argument_1>, in dem someprogramnur der Wert des envArguments gedruckt wird :

package.json

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

Wenn Sie es ausführen:

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

Soweit ich weiß, verwenden Benutzer package.json-Skripte, wenn sie Skripte auf einfachere Weise ausführen möchten. Um beispielsweise nodemondas in lokalen node_modules installierte zu verwenden, können wir nicht nodemondirekt von der CLI aus aufrufen , aber wir können es mit verwenden ./node_modules/nodemon/nodemon.js. Um diese lange Eingabe zu vereinfachen, können wir dies ...

    ...

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

    ...

... rufen Sie dann npm startauf, um 'nodemon' zu verwenden, dessen erstes Argument app.js ist.

Was ich damit sagen möchte, wenn Sie Ihren Server nur mit dem nodeBefehl starten möchten , müssen Sie ihn meiner Meinung nach nicht verwenden scripts. Tippen npm startoder node app.jshat den gleichen Aufwand.

Wenn Sie jedoch nodemonein dynamisches Argument verwenden und übergeben möchten, verwenden Sie es auch nicht script. Versuchen Sie stattdessen, symlink zu verwenden.

Zum Beispiel mit Migration mit sequelize. Ich erstelle einen Symlink ...

ln -s node_modules/sequelize/bin/sequelize sequelize

... und ich kann jede Argumentation bestehen, wenn ich es nenne ...

./sequlize -h /* show help */

./sequelize -m /* upgrade migration */

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

usw...

An diesem Punkt ist die Verwendung von Symlink der beste Weg, den ich herausfinden könnte, aber ich denke nicht wirklich, dass dies die beste Vorgehensweise ist.

Ich hoffe auch auf Ihre Meinung zu meiner Antwort.

Hinweis: Dieser Ansatz ändert Ihre Einstellungen im laufenden Betrieb. package.jsonVerwenden Sie ihn, wenn Sie keine Alternative haben.

Ich musste Befehlszeilenargumente an meine Skripte übergeben, die ungefähr so ​​aussahen:

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

Das heißt, ich starte meine App mit npm run start.

Wenn ich nun einige Argumente übergeben möchte, würde ich vielleicht mit Folgendem beginnen:

npm run start -- --config=someConfig

Dies bedeutet : npm run build && npm run watch -- --config=someConfig. Das Problem dabei ist, dass die Argumente immer an das Ende des Skripts angehängt werden. Dies bedeutet, dass alle verketteten Skripte diese Argumente nicht erhalten (Argumente werden möglicherweise von allen benötigt oder nicht, aber das ist eine andere Geschichte.). Wenn die verknüpften Skripte aufgerufen werden, erhalten diese Skripte nicht die übergebenen Argumente. dh Das watchSkript erhält die übergebenen Argumente nicht.

Die Produktionsnutzung meiner App ist wie folgt: Das .exeÜbergeben der Argumente in der Exe funktioniert also einwandfrei, aber wenn Sie dies während der Entwicklung tun möchten, wird es problematisch.

Ich konnte keinen richtigen Weg finden, um dies zu erreichen, also habe ich es versucht.

Ich habe eine Javascript-Datei erstellt: start-script.jsAuf der übergeordneten Ebene der Anwendung habe ich eine "default.package.json" und anstelle von "package.json" die Datei "default.package.json". Der Zweck von start-script.jsonbesteht darin default.package.json, die übergebenen Argumente zu lesen , zu extrahieren scriptsund zu suchen und npm run scriptnamedann an diese Skripte anzuhängen. Danach wird eine neue erstellt package.jsonund die Daten aus default.package.json mit geänderten Skripten kopiert und dann aufgerufen 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);
}

Anstatt es zu tun npm run start, tue ich es jetztnode start-script.js --c=somethis --r=somethingElse

Der erste Lauf sieht gut aus, wurde aber nicht gründlich getestet. Verwenden Sie es, wenn Sie für Ihre App-Entwicklung möchten.

Ich habe diese Frage gefunden, als ich versuchte, mein Problem mit dem Ausführen von sequelize seed zu lösen: generiere den Befehl cli:

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

Lassen Sie mich auf den Punkt kommen. Ich wollte einen kurzen Skriptbefehl in meiner Datei package.json haben und gleichzeitig das Argument --name angeben

Die Antwort kam nach einigen Experimenten. Hier ist mein Befehl in package.json

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

... und hier ist ein Beispiel für die Ausführung im Terminal, um eine Seed-Datei für einen Benutzer zu generieren

> yarn seed:generate --name=user

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

Zu Ihrer Information

yarn -v
1.6.0

npm -v
5.6.0

npm run script_target - <argument> Grundsätzlich ist dies die Art und Weise, wie die Befehlszeilenargumente übergeben werden. Dies funktioniert jedoch nur, wenn im Skript nur ein Befehl ausgeführt wird, wie ich einen Befehl ausführe, dh npm run start - 4200

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

Dies wird ausgeführt, um Befehlszeilenparameter zu übergeben, aber was ist, wenn wir mehr als einen Befehl zusammen ausführen, wie z. B. npm run build c: / workspace / file

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

Beim Ausführen von copy c: / file && ng build c: / work space / file wird es jedoch so interpretiert, und es wird erwartet, dass so etwas wie copy c: / file c: / work space / file && ng build erstellt wird

Hinweis: - Befehlszeilenparameter funktionieren also nur, wenn nur ein Befehl in einem Skript erwartet wird.

Ich habe oben einige Antworten gelesen, in denen einige schreiben, dass Sie mit dem Symbol $ auf den Befehlszeilenparameter zugreifen können, aber das wird nicht funktionieren

Ich weiß, dass es bereits eine genehmigte Antwort gibt, aber ich mag diesen JSON-Ansatz irgendwie.

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

Normalerweise habe ich 1 Var, die ich brauche, wie zum Beispiel einen Projektnamen, also finde ich das schnell und einfach.

Außerdem habe ich so etwas oft in meiner package.json

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

Und da ich gierig bin, möchte ich "alles", NODE_ENV und das CMD-Line-Arg-Zeug.

Sie greifen einfach in Ihrer Datei auf diese Dinge zu (in meinem Fall 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);

Sie müssen nur dieses Bit darüber haben (ich verwende übrigens v10.16.0)

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

Wie auch immer, Frage bereits beantwortet. Ich dachte, ich würde teilen, da ich diese Methode oft benutze.