Dans mon package.jsonj'ai ces deux scripts:

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

Je dois exécuter ces 2 scripts en parallèle chaque fois que je commence à développer dans Node.js. La première chose à laquelle j'ai pensé était d'ajouter un troisième script comme celui-ci:

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

... mais il faudra attendre pour start-watchterminer avant de courir wp-server.

Comment puis-je les exécuter en parallèle? Veuillez garder à l'esprit que j'ai besoin de voir la outputde ces commandes. De plus, si votre solution implique un outil de construction, je préfère utiliser gulpplutôt que gruntparce que je l'utilise déjà dans un autre projet.

Utilisez un package appelé simultanément .

npm i concurrently --save-dev

Ensuite, configurez votre npm run devtâche comme suit:

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

Si vous utilisez un environnement de type UNIX, utilisez-le simplement &comme séparateur:

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

Sinon, si vous êtes intéressé par une solution multiplateforme, vous pouvez utiliser le module npm-run-all :

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

Depuis Windows cmd, vous pouvez utiliser start:

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

Chaque commande lancée de cette façon démarre dans sa propre fenêtre.

Vous devez utiliser npm-run-all (ou concurrently, parallelshell), car il a plus de contrôle sur le démarrage et la suppression des commandes. Les opérateurs &,| sont de mauvaises idées parce que vous aurez besoin d'arrêter manuellement après tous les tests sont terminés.

Voici un exemple de test de rapporteur via 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 = Exécuter des commandes en parallèle.

-r = Tuez toutes les commandes lorsque l'une d'elles se termine par un code de sortie nul.

L'exécution npm run testdémarrera le pilote Selenium, démarrera le serveur http (pour vous servir des fichiers) et exécutera des tests de rapporteur. Une fois tous les tests terminés, il fermera le serveur http et le pilote sélénium.

Vous pouvez en utiliser un &pour le script d'exécution parallèle

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

Lien de référence

Une meilleure solution consiste à utiliser &

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

J'ai vérifié presque toutes les solutions ci-dessus et seulement avec npm-run-all j'ai pu résoudre tous les problèmes. Le principal avantage sur toutes les autres solutions est la possibilité d' exécuter un script avec des arguments .

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

La note run-pest un raccourci pournpm-run-all --parallel

Cela me permet d'exécuter la commande avec des arguments comme npm run test:watch -- Something.

ÉDITER:

Il y en a un de plus utile option pour 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.

Ajoutez -rà votre npm-run-allscript pour tuer tous les processus lorsque l'un a terminé avec le code 0. Cela est particulièrement utile lorsque vous exécutez un serveur HTTP et un autre script utilisant le serveur.

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

J'ai une solution multiplateforme sans modules supplémentaires . Je cherchais quelque chose comme un bloc try catch que je pourrais utiliser à la fois dans le cmd.exe et dans le bash.

La solution est celle command1 || command2qui semble fonctionner de la même manière dans les deux environnements. La solution pour l'OP est donc:

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

Alors simple npm start(et npm run dev) fonctionnera sur toutes les plateformes!

Si vous remplacez la double esperluette par une seule esperluette, les scripts s'exécuteront simultanément.

Solution rapide

Dans ce cas, je dirais que le meilleur pari Si ce script est pour un module privé destiné à fonctionner uniquement sur des machines basées sur * nix , vous pouvez utiliser l'opérateur de contrôle pour les processus de forking, qui ressemble à ceci:&

Un exemple de cette opération dans un fichier package.json partiel:

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

Vous les exécuteriez ensuite tous les deux en parallèle via npm run serve-bundle. Vous pouvez améliorer les scripts pour sortir les pids du processus forké dans un fichier comme ceci:

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

Google quelque chose comme opérateur de contrôle bash pour la fourche pour en savoir plus sur son fonctionnement. J'ai également fourni un contexte supplémentaire concernant l'utilisation des techniques Unix dans les projets Node ci-dessous:

Contexte supplémentaire RE: Unix Tools & Node.js

Si vous n'êtes pas sous Windows, les outils / techniques Unix fonctionnent souvent bien pour réaliser quelque chose avec les scripts Node car:

1. Une grande partie de Node.js imite avec amour les principes Unix
2. Vous êtes sur * nix (incl. OS X) et NPM utilise quand même un shell

Les modules pour les tâches système dans Nodeland sont également souvent des abstractions ou des approximations des outils Unix, de fsà streams.

npm-run-all --parallel task1 task2

Éditer:

Vous devez avoir préalablement installé npm-run-all . Consultez également cette page pour d'autres scénarios d'utilisation.

Que diriez-vous de bifurquer

Une autre option pour exécuter plusieurs scripts Node consiste à utiliser un seul script Node, qui peut en générer de nombreux autres. Le fork est pris en charge nativement dans Node, il n'ajoute donc aucune dépendance et est multiplateforme.

Exemple minimal

Cela exécuterait simplement les scripts tels quels et supposerait qu'ils se trouvent dans le répertoire du script parent.

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

Exemple détaillé

Cela exécuterait les scripts avec des arguments et configurés par les nombreuses options disponibles.

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

Communiquer avec des scripts fourchus

Forking a également l'avantage supplémentaire que le script parent peut recevoir des événements des processus enfants forkés ainsi que les renvoyer. Un exemple courant est que le script parent tue ses enfants fourchus.

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

Pour plus d'événements et de méthodes disponibles, consultez la ChildProcessdocumentation

J'ai rencontré des problèmes avec &et| , quels états de sortie et lancement d'erreur, respectivement.

D'autres solutions veulent exécuter n'importe quelle tâche avec un nom donné, comme npm-run-all, ce qui n'était pas mon cas d'utilisation.

J'ai donc créé npm-run-parallel qui exécute les scripts npm de manière asynchrone et rend compte quand ils ont terminé.

Donc, pour vos scripts, ce serait:

npm-run-parallel wp-server start-watch

Dans mon cas, j'ai deux projets, l'un était l' interface utilisateur et l'autre API , et les deux ont leur propre script dans leurs package.jsonfichiers respectifs .

Alors, voici ce que j'ai fait.

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

Plus d'informations: https://github.com/mysticatea/npm-run-all/blob/master/docs/npm-run-all.md

J'utilise npm-run-all depuis un certain temps, mais je ne m'en suis jamais entendu, car la sortie de la commande en mode veille ne fonctionne pas bien ensemble. Par exemple, si je commence create-react-appetjest en mode veille, je ne pourrai voir que la sortie de la dernière commande que j'ai exécutée. Donc la plupart du temps, j'exécutais toutes mes commandes manuellement ...

C'est pourquoi, j'implémente ma propre lib, run-screen . C'est encore un projet très jeune (d'hier: p) mais ça vaut peut-être le coup d'oeil, dans votre cas ce serait:

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

Ensuite, vous appuyez sur la touche numérique 1pour voir la sortie de wp-serveret appuyez sur 0pour voir la sortie de start-watch.

Ma solution est similaire à celle de Piittis, mais j'ai eu quelques problèmes avec Windows. J'ai donc dû valider pour 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 de nœud simple pour vous permettre de démarrer sans trop de tracas. Utiliser readline pour combiner les sorties afin que les lignes ne soient pas altérées.

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

ce travail dans les fenêtres