Nel mio package.jsonho questi due script:

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

Devo eseguire questi 2 script in parallelo ogni volta che inizio a sviluppare in Node.js. La prima cosa che ho pensato è stata l'aggiunta di un terzo script come questo:

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

... ma aspetterà start-watchdi finire prima di correre wp-server.

Come posso eseguirli in parallelo? Tieni presente che ho bisogno di vedere outputquesti comandi. Inoltre, se la tua soluzione prevede uno strumento di creazione, preferirei utilizzare gulpinvece che gruntperché già lo uso in un altro progetto.

Utilizzare un pacchetto chiamato contemporaneamente .

npm i concurrently --save-dev

Quindi imposta l' npm run devattività in questo modo:

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

Se stai usando un ambiente simile a UNIX, usa solo &come separatore:

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

Altrimenti, se sei interessato a una soluzione multipiattaforma, puoi utilizzare il modulo npm-run-all :

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

Da Windows cmd è possibile utilizzare start:

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

Ogni comando lanciato in questo modo inizia nella sua finestra.

Dovresti usare npm-run-all (o concurrently, parallelshell), perché ha un maggiore controllo sull'avvio e l'uccisione dei comandi. Gli operatori &,| sono cattive idee, perché avrete bisogno di fermare manualmente dopo tutti i test sono finiti.

Questo è un esempio per il test del goniometro tramite 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 = Esegui comandi in parallelo.

-r = Uccidi tutti i comandi quando uno di essi termina con un codice di uscita pari a zero.

L'esecuzione npm run testavvierà il driver Selenium, avvierà il server http (per servire i tuoi file) ed eseguirà i test del goniometro. Una volta terminati tutti i test, chiuderà il server http e il driver selenio.

È possibile utilizzarne uno &per script di esecuzione parallela

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

Link di riferimento

Una soluzione migliore è usare &

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

Ho controllato quasi tutte le soluzioni dall'alto e solo con npm-run-all sono stato in grado di risolvere tutti i problemi. Il vantaggio principale rispetto a tutte le altre soluzioni è la possibilità di eseguire script con argomenti .

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

Nota run-pè scorciatoia pernpm-run-all --parallel

Questo mi permette di eseguire il comando con argomenti come npm run test:watch -- Something.

MODIFICARE:

C'è un'altra opzione utile per 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.

Aggiungi -ral tuo npm-run-allscript per terminare tutti i processi quando uno ha terminato con il codice 0. Ciò è particolarmente utile quando si esegue un server HTTP e un altro script che utilizzano il server.

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

Ho una soluzione multipiattaforma senza moduli aggiuntivi . Stavo cercando qualcosa come un blocco catch try che potevo usare sia nel cmd.exe che nel bash.

La soluzione è command1 || command2che sembra funzionare in entrambi gli ambienti stessi. Quindi la soluzione per l'OP è:

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

Quindi semplice npm start(e npm run dev) funzionerà su tutte le piattaforme!

Se si sostituisce la doppia e commerciale con una singola e commerciale, gli script verranno eseguiti contemporaneamente.

Soluzione rapida

In questo caso, direi la scommessa migliore se questo script è per un modulo privato destinato a funzionare solo su macchine basate su * nix , puoi usare l'operatore di controllo per i processi di fork, che assomiglia a questo:&

Un esempio di ciò in un file package.json parziale:

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

Li eseguiresti entrambi in parallelo tramite npm run serve-bundle. È possibile migliorare gli script per generare i pid del processo biforcato in un file in questo modo:

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

Google qualcosa come l' operatore di controllo bash per il fork per saperne di più su come funziona. Ho anche fornito un ulteriore contesto per sfruttare le tecniche Unix nei progetti Node di seguito:

Ulteriore contesto RE: Unix Tools & Node.js

Se non sei su Windows, gli strumenti / le tecniche Unix spesso funzionano bene per ottenere qualcosa con gli script Node perché:

1. Gran parte di Node.js imita amorevolmente i principi di Unix
2. Sei su * nix (incl. OS X) e NPM usa comunque una shell

I moduli per le attività di sistema in Nodeland sono spesso anche astrazioni o approssimazioni di strumenti Unix, da fsa streams.

npm-run-all --parallel task1 task2

modificare:

È necessario disporre di npm-run-all installato in anticipo. Controlla anche questa pagina per altri scenari di utilizzo.

Che ne dici di biforcarti

Un'altra opzione per eseguire più script Node è con un singolo script Node, che può rovesciare molti altri. Forking è supportato nativamente in Node, quindi non aggiunge dipendenze ed è multipiattaforma.

Esempio minimo

Ciò eseguirà semplicemente gli script così come sono e presupponendo che si trovino nella directory dello script principale.

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

Esempio dettagliato

Ciò eseguirà gli script con argomenti e configurati dalle molte opzioni disponibili.

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

Comunicare con script biforcuti

Forking ha anche l'ulteriore vantaggio che lo script padre può ricevere eventi dai processi figlio biforcati e rispedirli. Un esempio comune è che lo script padre uccida i suoi figli biforcuti.

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

Per altri eventi e metodi disponibili consultare la ChildProcessdocumentazione

Ho riscontrato problemi con &e |, quali stati di uscita e lancio degli errori, rispettivamente.

Altre soluzioni vogliono eseguire qualsiasi attività con un determinato nome, come npm-run-all, che non era il mio caso d'uso.

Così ho creato npm-run-parallel che esegue gli script npm in modo asincrono e riporta quando hanno finito.

Quindi, per i tuoi script, sarebbe:

npm-run-parallel wp-server start-watch

Nel mio caso ho due progetti, uno era UI e l'altro era API , ed entrambi hanno il loro script nei rispettivi package.jsonfile.

Quindi, ecco cosa ho fatto.

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

Maggiori informazioni: https://github.com/mysticatea/npm-run-all/blob/master/docs/npm-run-all.md

Uso npm-run-all da un po 'di tempo, ma non ci sono mai andato d'accordo, perché l'output del comando in modalità watch non funziona bene insieme. Ad esempio, se inizio create-react-appejest in modalità orologio, sarò in grado di vedere solo l'output dell'ultimo comando che ho eseguito. Quindi la maggior parte delle volte, stavo eseguendo tutti i miei comandi manualmente ...

Per questo motivo, implemento la mia lib, run-screen . È ancora un progetto molto giovane (da ieri: p) ma potrebbe valere la pena guardarlo, nel tuo caso sarebbe:

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

Quindi premi il tasto numerico 1per vedere l'output di wp-servere premi 0per vedere l'output di start-watch.

La mia soluzione è simile a quella di Piittis, anche se ho avuto dei problemi con Windows. Quindi ho dovuto convalidare per 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");
})();

Script di nodo semplice per iniziare senza troppe seccature. Utilizzo di readline per combinare gli output in modo che le linee non vengano alterate.

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

questo lavoro in windows