Benim package.jsonbu iki senaryom var:

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

Node.js'de geliştirmeye her başladığımda bu 2 komut dosyasını paralel olarak çalıştırmam gerekiyor. Düşündüğüm ilk şey böyle üçüncü bir komut dosyası eklemekti:

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

... ama start-watchkoşmadan önce bitmesini bekleyecek wp-server.

Bunları paralel olarak nasıl çalıştırabilirim? Lütfen outputbu komutları görmem gerektiğini unutmayın . Ayrıca, çözümünüz bir oluşturma aracı içeriyorsa, gulpbunun yerine gruntzaten başka bir projede kullandığım için kullanmayı tercih ederim.

Eşzamanlı olarak adlandırılan bir paket kullanın .

npm i concurrently --save-dev

Ardından npm run devgörevinizi şu şekilde ayarlayın:

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

UNIX benzeri bir ortam kullanıyorsanız &, ayırıcı olarak kullanmanız yeterlidir:

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

Aksi takdirde, platformlar arası bir çözümle ilgileniyorsanız, npm-run-all modülünü kullanabilirsiniz:

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

Windows cmd'den şunları kullanabilirsiniz start:

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

Bu şekilde başlatılan her komut kendi penceresinde başlar.

Sen kullanmalıdır npm işletilen-bütün (veya concurrently, parallelshellbu başlangıç ve komutları öldürme üzerinde daha fazla kontrole sahip olduğu için). Operatörler &,| bütün testler bittikten sonra manuel olarak durdurmak gerekir çünkü kötü fikirler.

Bu, npm üzerinden iletki testi için bir örnektir:

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 = Komutları paralel olarak çalıştır.

-r = Bunlardan biri sıfır çıkış koduyla bittiğinde tüm komutları öldür.

Çalıştırılması npm run testSelenium sürücüsünü başlatır, http sunucusunu başlatır (size dosya sunmak için) ve iletki testlerini çalıştırır. Tüm testler tamamlandığında, http sunucusunu ve selenyum sürücüsünü kapatır.

&Paralel çalıştırma komut dosyası için birini kullanabilirsiniz

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

Referans bağlantısı

Daha iyi bir çözüm kullanmak &

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

Yukarıdan neredeyse tüm çözümleri kontrol ettim ve sadece npm-run-all ile tüm sorunları çözmeyi başardım. Diğer tüm çözümlere göre en büyük avantajı komut dosyasını argümanlarla çalıştırma yeteneğidir .

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

Not run-p, kısayoludurnpm-run-all --parallel

Bu benim gibi argümanlarla komut çalıştırmamı sağlar npm run test:watch -- Something.

DÜZENLE:

Bir daha kullanışlı olduğunu seçenek için 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.

Kodla işiniz bittiğinde tüm işlemleri öldürmek -riçin npm-run-allbetiğinize ekleyin 0. Bu özellikle bir HTTP sunucusu ve sunucuyu kullanan başka bir komut dosyası çalıştırdığınızda kullanışlıdır.

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

Ek modüller olmadan çapraz platform çözümüm var . Hem cmd.exe hem de bash kullanabilirsiniz try catch blok gibi bir şey arıyordu.

Çözüm, command1 || command2her iki ortamda da aynı gibi görünüyor. Yani OP'nin çözümü:

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

O zaman basit npm start(ve npm run dev) tüm platformlarda çalışacaktır!

Çift ve işareti tek bir ve işareti ile değiştirirseniz, komut dosyaları aynı anda çalışır.

Hızlı Çözüm

Bu durumda, en iyi bahsi söyleyebilirim Bu komut dosyası yalnızca * nix tabanlı makinelerde çalışması amaçlanan özel bir modül içinse, aşağıdaki gibi görünen işlemleri çatallamak için kontrol operatörünü kullanabilirsiniz:&

Bunu kısmi bir package.json dosyasında yapmaya bir örnek:

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

Daha sonra ikisini de paralel olarak yürütürdünüz npm run serve-bundle. Çatallı işlemin pids'ini aşağıdaki gibi bir dosyaya çıktılamak için komut dosyalarını geliştirebilirsiniz:

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

Google çatallama için bash kontrol operatörü gibi bir şey , nasıl çalıştığı hakkında daha fazla bilgi edinmek . Ayrıca, aşağıdaki Düğüm projelerinde Unix tekniklerinden yararlanma konusunda daha fazla bağlam sağladım:

Diğer Bağlam RE: Unix Tools & Node.js

Windows'da değilseniz, Unix araçları / teknikleri genellikle Düğüm komut dosyalarıyla bir şey elde etmek için iyi çalışır, çünkü:

1. Node.js'nin çoğu Unix ilkelerini sevgiyle taklit ediyor
2. * Nix kullanıyorsunuz (OS X dahil) ve NPM yine de bir kabuk kullanıyor

Nodeland sistem görevler için modüller genellikle de soyutlamalar veya Unix araçları yaklaşıklıklar vardır fsiçin streams.

npm-run-all --parallel task1 task2

Düzenle:

Önceden npm-run-all kurulu olmalıdır. Ayrıca diğer kullanım senaryoları için bu sayfayı kontrol edin .

Çatallamaya ne dersin

Birden Düğüm komut dosyalarını çalıştırmak için bir diğer seçenek tek bir Düğüm komut ile olan çatal diğerleri. Forking, Düğümde yerel olarak desteklenir, bu nedenle bağımlılık eklemez ve çapraz platformdur.

Minimal örnek

Bu, komut dosyalarını olduğu gibi çalıştırır ve üst komut dosyasının dizininde bulunduğunu varsayar.

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

Ayrıntılı örnek

Bu, komut dosyalarını bağımsız değişkenlerle çalıştırır ve birçok seçenek tarafından yapılandırılır.

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

Çatallı komut dosyalarıyla iletişim kurma

Forking ayrıca, ana betiğin çatallı alt süreçlerden olay alabileceği ve geri gönderebileceği ek bir avantaja sahiptir. Yaygın bir örnek, ana komut dosyasının çatallı çocuklarını öldürmesidir.

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

Daha fazla kullanılabilir olay ve yöntem için belgelere bakınChildProcess

Sırasıyla durumlardan ve hata atmadan çıkan &ve ile ilgili sorunlar yaşadım |.

Diğer çözümler, benim kullanım durumum olmayan npm-run-all gibi belirli bir adla herhangi bir görevi çalıştırmak istiyor.

Bu yüzden npm komut dosyalarını eşzamansız olarak çalıştıran ve bittiğinde rapor veren npm-run-parallel oluşturdum .

Yani, senaryolarınız için şu olurdu:

npm-run-parallel wp-server start-watch

Benim durumumda, biri UI diğeri API olmak üzere iki projem var ve her ikisinin de kendi package.jsondosyalarında kendi komut dosyaları var.

İşte yaptığım şey.

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

Daha fazla bilgi: https://github.com/mysticatea/npm-run-all/blob/master/docs/npm-run-all.md

Npm-run-all'ı bir süredir kullanıyorum , ama hiç bir zaman anlaşamadım , çünkü saat modunda komutun çıktısı birlikte iyi çalışmıyor. Örneğin, ben başlarsak create-react-appvejest izleme modundayken, yalnızca çalıştırdığım son komutun çıktısını görebileceğim. Çoğu zaman tüm komutlarımı manuel olarak çalıştırıyordum ...

Bu yüzden kendi lib, çalışma ekranımı uyguluyorum . Hala çok genç bir proje (dünden: p) ama buna bakmaya değer olabilir, sizin durumunuzda:

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

Sonra 1çıktısını görmek için sayısal tuşa wp-serverbasın 0ve çıktısını görmek için tuşuna basın start-watch.

Çözümüm Piittis'e benziyor, ancak Windows kullanırken bazı sorunlar yaşadım. Bu yüzden win32 için onaylamak zorunda kaldım.

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

Çok fazla güçlük çekmeden gitmek için basit düğüm komut dosyası. Çıktıları birleştirmek için readline'ı kullanma, böylece çizgiler karışmaz.

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

bu çalışma pencerelerde