javascript npm-run-all' - Comment puis-je exécuter plusieurs scripts NPM en parallèle?





nodemon concurrently (13)


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 faire cela 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 devez ensuite les exécuter 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 l' opérateur de contrôle bash pour forking pour en savoir plus sur comment cela fonctionne. J'ai également fourni un contexte supplémentaire concernant l'utilisation des techniques Unix dans les projets de nœuds ci-dessous:

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

Si vous n'êtes pas sur 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 (y compris OS X) et NPM utilise un shell de toute façon

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

Dans mon package.json j'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 cela attendra que start-watch se termine avant de start-watch wp-server .

Comment puis-je les exécuter en parallèle? S'il vous plaît gardez à l'esprit que j'ai besoin de voir la output de ces commandes. Aussi, si votre solution implique un outil de construction, je préfère utiliser gulp au lieu de grunt parce que je l'utilise déjà dans un autre projet.




Dans mon cas, j'ai deux projets l'un était l'interface utilisateur, l'autre était l'API, et la peine d'avoir son propre script là-dedans package.json respectif.

alors voici ce que j'ai fait.

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



Vous devriez utiliser npm-run-all (ou concurrently , parallelshell ), car il a plus de contrôle sur le démarrage et la destruction des commandes. Les opérateurs & , `| sont de mauvaises idées, car vous devrez l'arrêter manuellement une fois tous les tests terminés.

Voici un exemple de test de protractor à travers 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 les commandes en parallèle.

-r = Tuer toutes les commandes quand l'une d'entre elles se termine par zéro.

L' npm run test exécution npm run test démarre le pilote Selenium, démarre le serveur http (pour vous servir de fichiers) et exécute des tests de rapporteur. Une fois tous les tests terminés, le serveur http et le pilote sélénium seront fermés.




npm-run-all --parallel task1 task2

modifier:

Vous devez avoir préalablement installé npm-run-all . Vérifiez également option pour d'autres scénarios d'utilisation.




Utilisez un package appelé concurrently .

npm i concurrently --save-dev

Ensuite, configurez votre tâche de développement npm run dev comme suit:

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



Que diriez-vous de forking

Une autre option pour exécuter plusieurs scripts Node est avec un seul script Node, qui peut en fork plusieurs autres. Forking est supporté nativement dans Node, donc il n'ajoute aucune dépendance et est multi-plateforme.

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 de verbosité

Cela exécuterait les scripts avec des arguments et configuré 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 provenant des processus fils forked et 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 documentation de ChildProcess




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 command1 || command2 command1 || command2 qui semble fonctionner dans les deux environnements même. Donc, la solution pour l'OP est:

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

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




L'utilisation du package Concurrently fonctionne, mais vous n'en avez pas besoin pour accomplir cela. Vous pouvez simplement utiliser un canal sur des machines UNIX exécutant des tâches simultanées. Je suggère cette méthode plutôt que l'autre car cela vous évite d'avoir à ajouter une dépendance supplémentaire.

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



J'ai rencontré des problèmes avec & et | , qui sort des statuts et le 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 façon asynchrone et rend compte quand ils sont terminés.

Donc, pour vos scripts, ce serait:

npm-run-parallel wp-server start-watch




J'ai vérifié presque toutes les solutions d'en haut et seulement avec npm-run-all j'ai pu résoudre tous les problèmes. Le principal avantage par rapport à 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",
}

Remarque: run-p est un raccourci pour npm-run-all --paraller

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

MODIFIER:

Il y a une option plus utile 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 script npm-run-all pour tuer tous les processus quand on a fini avec le code 0 . Ceci est particulièrement utile lorsque vous exécutez un serveur HTTP et un autre script qui utilise le serveur.

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



Une meilleure solution consiste à utiliser &

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



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




une autre solution. jsFiddle

var toBoolean = function(value) {
    var strValue = String(value).toLowerCase();
    strValue = ((!isNaN(strValue) && strValue !== '0') &&
        strValue !== '' &&
        strValue !== 'null' &&
        strValue !== 'undefined') ? '1' : strValue;
    return strValue === 'true' || strValue === '1' ? true : false
};

les cas de test s'exécutent dans le noeud

> toBoolean(true)
true
> toBoolean(false)
false
> toBoolean(undefined)
false
> toBoolean(null)
false
> toBoolean('true')
true
> toBoolean('True')
true
> toBoolean('False')
false
> toBoolean('false')
false
> toBoolean('0')
false
> toBoolean('1')
true
> toBoolean('100')
true
> 






javascript node.js build