In meinem habe package.jsonich diese beiden Skripte:

  "scripts": {
    "start-watch": "nodemon run-babel index.js",
    "wp-server": "webpack-dev-server",
  }

Ich muss diese beiden Skripte jedes Mal parallel ausführen, wenn ich mit der Entwicklung in Node.js beginne. Das erste, woran ich dachte, war das Hinzufügen eines dritten Skripts wie dieses:

"dev": "npm run start-watch && npm run wp-server"

... aber das wird warten, start-watchbis es fertig ist, bevor es läuft wp-server.

Wie kann ich diese parallel ausführen? Bitte denken Sie daran, dass ich die outputdieser Befehle sehen muss. Wenn Ihre Lösung ein Build-Tool enthält, würde ich es lieber verwenden, gulpanstatt gruntes bereits in einem anderen Projekt zu verwenden.

Verwenden Sie ein Paket, das gleichzeitig aufgerufen wird .

npm i concurrently --save-dev

Richten Sie dann Ihre npm run devAufgabe folgendermaßen ein:

"dev": "concurrently --kill-others \"npm run start-watch\" \"npm run wp-server\""

Wenn Sie eine UNIX-ähnliche Umgebung verwenden, verwenden Sie einfach &als Trennzeichen:

"dev": "npm run start-watch & npm run wp-server"

Wenn Sie an einer plattformübergreifenden Lösung interessiert sind, können Sie das Modul npm-run-all verwenden :

"dev": "npm-run-all --parallel start-watch wp-server"

Unter Windows Cmd können Sie Folgendes verwenden start:

"dev": "start npm run start-watch && start npm run wp-server"

Jeder auf diese Weise gestartete Befehl startet in einem eigenen Fenster.

Sie sollten npm-run-all (oder concurrently, parallelshell) verwenden, da es mehr Kontrolle über das Starten und Beenden von Befehlen hat. Die Betreiber &, |sind schlechte Ideen , weil Sie manuell brauchen, um es zu stoppen , nachdem alle Tests abgeschlossen sind.

Dies ist ein Beispiel für Winkelmessertests bis npm:

scripts: {
  "webdriver-start": "./node_modules/protractor/bin/webdriver-manager update && ./node_modules/protractor/bin/webdriver-manager start",
  "protractor": "./node_modules/protractor/bin/protractor ./tests/protractor.conf.js",
  "http-server": "./node_modules/http-server/bin/http-server -a localhost -p 8000",
  "test": "npm-run-all -p -r webdriver-start http-server protractor"
}

-p = Befehle parallel ausführen.

-r = Töte alle Befehle, wenn einer von ihnen mit einem Exit-Code von Null endet.

Durch Ausführen npm run testwird der Selenium-Treiber gestartet, der http-Server gestartet (um Ihnen Dateien bereitzustellen) und Winkelmessertests ausgeführt. Sobald alle Tests abgeschlossen sind, werden der http-Server und der Selentreiber geschlossen.

Sie können eines &für parallel ausgeführtes Skript verwenden

"dev": "npm run start-watch & npm run wp-server"

Referenzlink

Eine bessere Lösung ist zu verwenden &

"dev": "npm run start-watch & npm run wp-server"

Ich habe fast alle Lösungen von oben überprüft und nur mit npm-run-all konnte ich alle Probleme lösen. Der Hauptvorteil gegenüber allen anderen Lösungen ist die Möglichkeit, Skripte mit Argumenten auszuführen .

{
  "test:static-server": "cross-env NODE_ENV=test node server/testsServer.js",
  "test:jest": "cross-env NODE_ENV=test jest",
  "test": "run-p test:static-server \"test:jest -- {*}\" --",
  "test:coverage": "npm run test -- --coverage",
  "test:watch": "npm run test -- --watchAll",
}

Hinweis run-pist Abkürzung fürnpm-run-all --parallel

Dadurch kann ich einen Befehl mit Argumenten wie ausführen npm run test:watch -- Something.

BEARBEITEN:

Es gibt noch eine nützliche Option für npm-run-all:

 -r, --race   - - - - - - - Set the flag to kill all tasks when a task
                            finished with zero. This option is valid only
                            with 'parallel' option.

Fügen Sie -rIhrem npm-run-allSkript hinzu, um alle Prozesse zu beenden, wenn Sie mit Code fertig sind 0. Dies ist besonders nützlich, wenn Sie einen HTTP-Server und ein anderes Skript ausführen, das den Server verwendet.

  "test": "run-p -r test:static-server \"test:jest -- {*}\" --",

Ich habe eine plattformübergreifende Lösung ohne zusätzliche Module . Ich suchte nach so etwas wie einem Try-Catch-Block, den ich sowohl in der cmd.exe als auch in der Bash verwenden konnte.

Die Lösung command1 || command2scheint in beiden Umgebungen gleich zu funktionieren. Die Lösung für das OP lautet also:

"scripts": {
  "start-watch": "nodemon run-babel index.js",
  "wp-server": "webpack-dev-server",
  // first command is for the cmd.exe, second one is for the bash
  "dev": "(start npm run start-watch && start npm run wp-server) || (npm run start-watch & npm run wp-server)",
  "start": "npm run dev"
}

Dann funktioniert einfach npm start(und npm run dev) auf allen Plattformen!

Wenn Sie das doppelte kaufmännische Und durch ein einzelnes kaufmännisches Und ersetzen, werden die Skripts gleichzeitig ausgeführt.

Schnelle Lösung

In diesem Fall würde ich die beste Wahl sagen. Wenn dieses Skript für ein privates Modul vorgesehen ist, das nur auf * nix-basierten Computern ausgeführt werden soll , können Sie den Steuerungsoperator zum Verzweigen von Prozessen verwenden. Dies sieht folgendermaßen aus:&

Ein Beispiel hierfür in einer partiellen package.json-Datei:

{
  "name": "npm-scripts-forking-example",
  "scripts": {
    "bundle": "watchify -vd -p browserify-hmr index.js -o bundle.js",
    "serve":  "http-server -c 1 -a localhost",
    "serve-bundle": "npm run bundle & npm run serve &"
  }

Sie würden dann beide parallel über ausführen npm run serve-bundle . Sie können die Skripte erweitern, um die Pids des gegabelten Prozesses in eine Datei wie folgt auszugeben:

"serve-bundle": "npm run bundle & echo \"$!\" > build/bundle.pid && npm run serve & echo \"$!\" > build/serve.pid && npm run open-browser",

Google so etwas wie Bash Control Operator zum Gabeln , um mehr darüber zu erfahren, wie es funktioniert. Im Folgenden habe ich einige weitere Informationen zur Nutzung von Unix-Techniken in Node-Projekten bereitgestellt:

Weiterer Kontext RE: Unix Tools & Node.js.

Wenn Sie nicht unter Windows arbeiten, funktionieren Unix-Tools / -Techniken häufig gut, um mit Node-Skripten etwas zu erreichen, weil:

1. Ein Großteil von Node.js ahmt liebevoll Unix-Prinzipien nach
2. Sie sind auf * nix (inkl. OS X) und NPM verwendet sowieso eine Shell

Module für Systemaufgaben in Nodeland sind häufig auch Abstraktionen oder Annäherungen von Unix-Tools von fsbis streams.

npm-run-all --parallel task1 task2

bearbeiten:

Sie müssen npm-run-all vorher installiert haben. Überprüfen Sie diese Seite auch auf andere Verwendungsszenarien.

Wie wäre es mit Gabeln

Eine weitere Möglichkeit , mehr Knoten Skripte auszuführen ist mit einem einzelnen Node - Skript, das kann gabelt viele andere. Forking wird in Node nativ unterstützt, fügt also keine Abhängigkeiten hinzu und ist plattformübergreifend.

Minimales Beispiel

Dies würde die Skripte einfach so ausführen, wie sie sind, und davon ausgehen, dass sie sich im Verzeichnis des übergeordneten Skripts befinden.

// fork-minimal.js - run with: node fork-minimal.js

const childProcess = require('child_process');

let scripts = ['some-script.js', 'some-other-script.js'];
scripts.forEach(script => childProcess.fork(script));

Ausführliches Beispiel

Dies würde die Skripte mit Argumenten ausführen und durch die vielen verfügbaren Optionen konfiguriert.

// fork-verbose.js - run with: node fork-verbose.js

const childProcess = require('child_process');

let scripts = [
    {
        path: 'some-script.js',
        args: ['-some_arg', '/some_other_arg'],
        options: {cwd: './', env: {NODE_ENV: 'development'}}
    },    
    {
        path: 'some-other-script.js',
        args: ['-another_arg', '/yet_other_arg'],
        options: {cwd: '/some/where/else', env: {NODE_ENV: 'development'}}
    }
];

let processes = [];

scripts.forEach(script => {
    let runningScript = childProcess.fork(script.path, script.args, script.options);

   // Optionally attach event listeners to the script
   runningScript.on('close', () => console.log('Time to die...'))

    runningScripts.push(runningScript); // Keep a reference to the script for later use
});

Kommunikation mit gegabelten Skripten

Forking hat außerdem den zusätzlichen Vorteil, dass das übergeordnete Skript Ereignisse von den gegabelten untergeordneten Prozessen empfangen und zurücksenden kann. Ein häufiges Beispiel ist, dass das übergeordnete Skript seine gegabelten Kinder tötet.

 runningScripts.forEach(runningScript => runningScript.kill());

Weitere verfügbare Ereignisse und Methoden finden Sie in der ChildProcessDokumentation

Ich hatte Probleme mit &und |, die den Status beenden und Fehler auslösen.

Andere Lösungen möchten jede Aufgabe mit einem bestimmten Namen ausführen, z. B. npm-run-all, was nicht mein Anwendungsfall war.

Also habe ich npm-run-parallel erstellt , das npm-Skripte asynchron ausführt und zurückmeldet, wenn sie fertig sind.

Für Ihre Skripte wäre es also:

npm-run-parallel wp-server start-watch

In meinem Fall habe ich zwei Projekte, eines war UI und das andere war API , und beide haben ein eigenes Skript in ihren jeweiligen package.jsonDateien.

Also, hier ist was ich getan habe.

npm run --prefix react start&  npm run --prefix express start&

npm install npm-run-all --save-dev

package.json:

"scripts": {
  "start-watch": "...",
  "wp-server": "...",
  "dev": "npm-run-all --parallel start-watch wp-server"
}

Weitere Informationen: https://github.com/mysticatea/npm-run-all/blob/master/docs/npm-run-all.md

Ich benutze npm-run-all seit einiger Zeit, bin aber nie damit klar gekommen, weil die Ausgabe des Befehls im Überwachungsmodus nicht gut zusammenarbeitet. Zum Beispiel, wenn ich anfange create-react-appundjest im Überwachungsmodus befinde, kann ich nur die Ausgabe des zuletzt ausgeführten Befehls sehen. Die meiste Zeit habe ich alle meine Befehle manuell ausgeführt ...

Aus diesem Grund implementiere ich meine eigene lib, run-screen . Es ist noch ein sehr junges Projekt (von gestern: p), aber es könnte sich lohnen, es sich anzusehen, in Ihrem Fall wäre es:

run-screen "npm run start-watch" "npm run wp-server"

Dann drücken Sie die Zifferntaste 1, um die Ausgabe von wp-serveranzuzeigen 0, und drücken , um die Ausgabe von anzuzeigen start-watch.

Meine Lösung ähnelt der von Piittis, obwohl ich einige Probleme mit Windows hatte. Also musste ich mich für win32 validieren.

const { spawn } = require("child_process");

function logData(data) {
    console.info(`stdout: ${data}`);
}

function runProcess(target) {
    let command = "npm";
    if (process.platform === "win32") {
        command = "npm.cmd"; // I shit you not
    }
    const myProcess = spawn(command, ["run", target]); // npm run server

    myProcess.stdout.on("data", logData);
    myProcess.stderr.on("data", logData);
}

(() => {
    runProcess("server"); // package json script
    runProcess("client");
})();

Einfaches Knotenskript, mit dem Sie ohne großen Aufwand loslegen können. Verwenden Sie readline, um Ausgaben zu kombinieren, damit die Zeilen nicht beschädigt werden.

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

[
  spawn('npm', ['run', 'start-watch']),
  spawn('npm', ['run', 'wp-server'])
].forEach(child => {
    readline.createInterface({
        input: child.stdout
    }).on('line', console.log);

    readline.createInterface({
        input: child.stderr,
    }).on('line', console.log);
});

"dev": "(cd api && start npm run start) & (cd ../client && start npm run start)"

diese Arbeit in Windows