W moim package.jsonmam te dwa skrypty:

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

Te 2 skrypty muszę uruchamiać równolegle za każdym razem, gdy zaczynam programować w Node.js. Pierwszą rzeczą, o której myślałem, było dodanie trzeciego skryptu takiego:

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

... ale będzie czekać na start-watchzakończenie przed uruchomieniem wp-server.

Jak mogę je uruchomić równolegle? Pamiętaj, że muszę zobaczyć outputte polecenia. Ponadto, jeśli twoje rozwiązanie wymaga narzędzia do kompilacji, wolę użyć gulpzamiast tego, gruntponieważ używam go już w innym projekcie.

Użyj pakietu o nazwie współbieżnej .

npm i concurrently --save-dev

Następnie skonfiguruj swoje npm run devzadanie w następujący sposób:

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

Jeśli używasz środowiska podobnego do UNIX, po prostu użyj &jako separatora:

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

W przeciwnym razie, jeśli jesteś zainteresowany rozwiązaniem wieloplatformowym, możesz użyć npm-run-all module:

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

Z Windows cmd możesz użyć start:

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

Każde polecenie uruchomione w ten sposób rozpoczyna się we własnym oknie.

Powinieneś użyć npm-run-all (lub concurrently, parallelshell), ponieważ ma on większą kontrolę nad poleceniami uruchamiania i zabijania. Operatorzy &,| są złe pomysły, ponieważ trzeba ręcznie zatrzymać go po zakończeniu wszystkich testów.

To jest przykład testowania kątomierza za pomocą 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 = Uruchom polecenia równolegle.

-r = Zabij wszystkie polecenia, gdy jedno z nich zakończy się kodem wyjścia równym zero.

Uruchomienie npm run testuruchomi sterownik Selenium, serwer HTTP (do obsługi plików) i uruchomi testy kątomierza. Po zakończeniu wszystkich testów zamknie serwer http i sterownik selenu.

Możesz użyć jednego &do skryptu równoległego

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

Link referencyjny

Lepszym rozwiązaniem jest użycie &

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

Sprawdziłem prawie wszystkie rozwiązania z góry i tylko z npm-run-all udało mi się rozwiązać wszystkie problemy. Główną przewagą nad wszystkimi innymi rozwiązaniami jest możliwość uruchamiania skryptu z argumentami .

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

Uwaga run-pjest skrótem donpm-run-all --parallel

To pozwala mi uruchamiać polecenie z argumentami takimi jak npm run test:watch -- Something.

EDYTOWAĆ:

Jest jeszcze jedna przydatna opcja dla 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.

Dodaj -rdo npm-run-allskryptu, aby zabić wszystkie procesy, gdy skończysz z kodem 0. Jest to szczególnie przydatne, gdy uruchamiasz serwer HTTP i inny skrypt korzystający z serwera.

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

Mam rozwiązanie typu crosssplatform bez żadnych dodatkowych modułów . Szukałem czegoś w rodzaju bloku catch catch, którego mógłbym użyć zarówno w cmd.exe, jak i w bashu.

command1 || command2Wydaje się, że rozwiązanie działa tak samo w obu środowiskach. Tak więc rozwiązaniem dla PO jest:

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

Wtedy prosty npm start(i npm run dev) będzie działał na wszystkich platformach!

Jeśli zastąpisz podwójny znak ampersand pojedynczym znakiem ampersand, skrypty będą działać jednocześnie.

Szybkie rozwiązanie

W takim przypadku powiedziałbym, że najlepszy wybór Jeśli ten skrypt jest przeznaczony dla modułu prywatnego przeznaczonego do uruchamiania tylko na komputerach z * nix , możesz użyć operatora sterującego do rozwidlania procesów, który wygląda następująco:&

Przykład wykonania tego w częściowym pliku package.json:

{
  "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 &"
  }

Następnie wykonałeś je oba równolegle przez npm run serve-bundle. Możesz ulepszyć skrypty, aby wypisywać pid z rozwidlonego procesu do pliku takiego jak:

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

Google coś jak operator kontroli bash za rozwidlanie aby dowiedzieć się więcej o tym, jak to działa. Przedstawiłem również trochę dalszego kontekstu dotyczącego wykorzystania technik uniksowych w projektach Node:

Dalszy kontekst RE: Unix Tools & Node.js

Jeśli nie korzystasz z systemu Windows, narzędzia / techniki uniksowe często działają dobrze, aby osiągnąć coś za pomocą skryptów Node, ponieważ:

1. Znaczna część Node.js naśladuje zasady uniksowe
2. Jesteś na * nix (włącznie z OS X), a NPM i tak używa powłoki

Moduły do ​​zadań systemowych w Nodeland są często abstrakcjami lub aproksymacjami narzędzi uniksowych od fsdo streams.

npm-run-all --parallel task1 task2

edytować:

Musisz wcześniej zainstalować npm-run-all . Sprawdź również tę stronę pod kątem innych scenariuszy użytkowania.

Co powiesz na rozwidlenie

Inną opcją uruchamiania wielu skryptów Node jest jeden skrypt Node, który może rozwidlać wiele innych. Rozwidlenie jest obsługiwane natywnie w Węźle, więc nie dodaje żadnych zależności i jest wieloplatformowe.

Minimalny przykład

Spowodowałoby to po prostu uruchomienie skryptów bez zmian i przyjęcie, że znajdują się one w katalogu skryptu nadrzędnego.

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

Pełen przykład

Spowodowałoby to uruchomienie skryptów z argumentami i skonfigurowanych według wielu dostępnych opcji.

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

Komunikacja za pomocą rozwidlonych skryptów

Forking ma również tę dodatkową zaletę, że skrypt nadrzędny może odbierać zdarzenia z rozwidlonych procesów potomnych, a także odsyłać. Typowym przykładem jest skrypt nadrzędny, który zabija rozwidlone dzieci.

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

Więcej dostępnych zdarzeń i metod znajduje się w ChildProcessdokumentacji

Wystąpiły problemy z &i |, które odpowiednio wychodzą ze stanu i zgłaszają błędy.

Inne rozwiązania chcą uruchomić dowolne zadanie o podanej nazwie, np. Npm-run-all, co nie było moim przypadkiem użycia.

Więc stworzyłem npm-run-parallel, który uruchamia skrypty npm asynchronicznie i raportuje, kiedy są gotowe.

W przypadku twoich skryptów byłoby to:

npm-run-parallel wp-server start-watch

W moim przypadku mam dwa projekty, jeden to interfejs użytkownika, a drugi to interfejs API , a oba mają własny skrypt w odpowiednimpackage.json plikach.

Oto co zrobiłem.

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

Więcej informacji: https://github.com/mysticatea/npm-run-all/blob/master/docs/npm-run-all.md

Używam npm-run-all od jakiegoś czasu, ale nigdy się z tym nie zgadzałem, ponieważ dane wyjściowe polecenia w trybie oglądania nie działają dobrze razem. Na przykład, jeśli zacznę create-react-appijest w trybie zegarka, będę mógł zobaczyć dane wyjściowe z ostatniego uruchomionego polecenia. Przez większość czasu wszystkie moje polecenia były uruchamiane ręcznie ...

Dlatego implementuję własną bibliotekę lib, run-screen . To wciąż bardzo młody projekt (od wczoraj: p), ale warto na niego spojrzeć, w twoim przypadku byłoby to:

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

Następnie naciskasz klawisz numeryczny, 1aby zobaczyć dane wyjściowe, wp-serveri naciśnij, 0aby zobaczyć dane wyjściowe start-watch.

Moje rozwiązanie jest podobne do rozwiązania Piittis, chociaż miałem problemy z używaniem systemu Windows. Musiałem więc zweryfikować pod kątem win32.

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");
})();

Prosty skrypt węzła, abyś mógł zacząć bez większych problemów. Używanie readline do łączenia wyników, aby linie nie były zniekształcone.

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

ta praca w systemie Windows