Zwykle możemy uruchomić zadanie przełknięcia z konsoli za pomocą czegoś podobnego gulp mytask. Czy w ogóle mogę przekazać parametr do zadania przełknięcia? Jeśli to możliwe, pokaż przykład, jak to zrobić.

Jest to funkcja, bez której programy nie mogą zostać. Możesz spróbować yargs .

npm install --save-dev yargs

Możesz użyć tego w następujący sposób:

gulp mytask --production --test 1234

W kodzie na przykład:

var argv = require('yargs').argv;
var isProduction = (argv.production === undefined) ? false : true;

Dla twojego zrozumienia:

> gulp watch
console.log(argv.production === undefined);  <-- true
console.log(argv.test === undefined);        <-- true

> gulp watch --production
console.log(argv.production === undefined);  <-- false
console.log(argv.production);                <-- true
console.log(argv.test === undefined);        <-- true
console.log(argv.test);                      <-- undefined

> gulp watch --production --test 1234
console.log(argv.production === undefined);  <-- false
console.log(argv.production);                <-- true
console.log(argv.test === undefined);        <-- false
console.log(argv.test);                      <-- 1234

Mam nadzieję, że możesz wziąć to stąd.

Jest jeszcze jedna wtyczka, której możesz użyć, minimalistycznie. Jest jeszcze jeden post, w którym są dobre przykłady zarówno dla yargów, jak i dla minimalistów: ( Czy można przekazać Gulpowi flagę, aby uruchamiała zadania na różne sposoby? )

Jeśli chcesz uniknąć dodawania dodatkowych zależności, uznałem, że węzły process.argvsą przydatne:

gulp.task('mytask', function() {
    console.log(process.argv);
});

Więc następujące:

gulp mytask --option 123

powinien wyświetlać:

[ 'node', 'path/to/gulp.js', 'mytask', '--option', '123']

Jeśli masz pewność, że żądany parametr znajduje się we właściwej pozycji, to flagi nie są potrzebne. ** Wystarczy użyć (w tym przypadku):

var option = process.argv[4]; //set to '123'

ALE: ponieważ opcja może nie być ustawiona lub może znajdować się w innej pozycji, uważam, że lepszym pomysłem byłoby coś takiego:

var option, i = process.argv.indexOf("--option");
if(i>-1) {
    option = process.argv[i+1];
}

W ten sposób możesz obsługiwać odmiany wielu opcji, takich jak:

//task should still find 'option' variable in all cases
gulp mytask --newoption somestuff --option 123
gulp mytask --option 123 --newoption somestuff
gulp mytask --flag --option 123

** Edycja: prawda dla skryptów węzłów, ale gulp interpretuje wszystko bez wiodącego „-” jako kolejnej nazwy zadania. Dlatego użycie gulp mytask 123zakończy się niepowodzeniem, ponieważ łyk nie może znaleźć zadania o nazwie „123”.

Przekazanie parametru do łyka może oznaczać kilka rzeczy:

• Z wiersza poleceń do pliku gulp (już tutaj przykładowo).
• Od głównej treści skryptu gulpfile.js po zadania gulp.
• Z jednego zadania przełknięcia do innego zadania przełknięcia.

Oto podejście do przekazywania parametrów z głównego pliku gulp do zadania gulp. Przenosząc zadanie wymagające parametru do własnego modułu i zawijając go w funkcji (aby można było przekazać parametr):

// ./gulp-tasks/my-neat-task.js file
module.exports = function(opts){

  opts.gulp.task('my-neat-task', function(){
      console.log( 'the value is ' + opts.value );
  });

};

//main gulpfile.js file

//...do some work to figure out a value called val...
var val = 'some value';

//pass that value as a parameter to the 'my-neat-task' gulp task
require('./gulp-tasks/my-neat-task.js')({ gulp: gulp, value: val});

Może się to przydać, jeśli masz wiele trudnych zadań i chcesz przekazać im przydatne konfiguracje środowiskowe. Nie jestem pewien, czy może działać między jednym zadaniem a drugim.

Istnieje oficjalny przepis na łyk, używając tego minimalistycznego .

https://github.com/gulpjs/gulp/blob/master/docs/recipes/pass-arguments-from-cli.md

Podstawy używają minimist do oddzielania argumentów cli i łączenia ich ze znanymi opcjami:

var options = minimist(process.argv.slice(2), knownOptions);

Co by parsowało coś takiego

$ gulp scripts --env development

Więcej pełnych informacji w przepisie.

Jeśli chcesz używać parametrów środowiska i innych narzędzi, takich jak log, możesz użyć gulp-util

/* 
  $npm install gulp-util --save-dev
  $gulp --varName 123
*/
var util = require('gulp-util');
util.log(util.env.varName);

Aktualizacja

gulp-util jest teraz przestarzałe. Zamiast tego możesz użyć minimalistycznego .

var argv = require('minimist')(process.argv.slice(2));
console.dir(argv);

Odpowiedź Ethana całkowicie zadziałałaby. Z mojego doświadczenia wynika, że ​​bardziej węzłowym sposobem jest używanie zmiennych środowiskowych. Jest to standardowy sposób konfigurowania programów wdrażanych na platformach hostingowych (np. Heroku lub Dokku).

Aby przekazać parametr z wiersza polecenia, wykonaj następujące czynności:

Rozwój: gulp dev

Produkcja: NODE_ENV=production gulp dev

Składnia jest inna, ale bardzo uniksowa i jest kompatybilna z Heroku, Dokku itp.

Możesz uzyskać dostęp do zmiennej w swoim kodzie pod adresem process.env.NODE_ENV

MYAPP=something_else gulp dev

ustawiłbym

process.env.MYAPP === 'something_else'

Ta odpowiedź może dać ci kilka innych pomysłów.

Oto moja próbka, jak go używać. Dla zadania css / less. Można zastosować dla wszystkich.

var cssTask = function (options) {
  var minifyCSS = require('gulp-minify-css'),
    less = require('gulp-less'),
    src = cssDependencies;

  src.push(codePath + '**/*.less');

  var run = function () {
    var start = Date.now();

    console.log('Start building CSS/LESS bundle');

    gulp.src(src)
      .pipe(gulpif(options.devBuild, plumber({
        errorHandler: onError
      })))
      .pipe(concat('main.css'))
      .pipe(less())
      .pipe(gulpif(options.minify, minifyCSS()))
      .pipe(gulp.dest(buildPath + 'css'))
      .pipe(gulpif(options.devBuild, browserSync.reload({stream:true})))
      .pipe(notify(function () {
        console.log('END CSS/LESS built in ' + (Date.now() - start) + 'ms');
      }));
  };

  run();

  if (options.watch) {
    gulp.watch(src, run);
  }
};

gulp.task('dev', function () {
  var options = {
    devBuild: true,
    minify: false,
    watch: false
  };

  cssTask (options);
});

Oto inny sposób bez dodatkowych modułów:

Musiałem odgadnąć środowisko na podstawie nazwy zadania, mam zadanie „dev” i „prod”.

Po uruchomieniu gulp prodpowinien być ustawiony na środowisko prod. Kiedy uruchamiam gulp devlub cokolwiek innego, powinno być ustawione na środowisko programistyczne.

W tym celu sprawdzam tylko nazwę uruchomionego zadania:

devEnv = process.argv[process.argv.length-1] !== 'prod';

Jeśli używasz łyka z yargsami, zwróć uwagę na następujące kwestie :

Jeśli masz zadanie „klient” i nie chcesz korzystać z yargs wbudowany w Sprawdzanie parametrów dla wymaganych poleceń:

.command("customer <place> [language]","Create a customer directory") nazwij to za pomocą:

gulp customer --customer Bob --place Chicago --language english

yargs zawsze zgłasza błąd, że do połączenia nie przypisano wystarczającej liczby poleceń, nawet jeśli masz !! -

Spróbuj i dodaj tylko cyfrę do polecenia (aby nie była równa nazwie zadania gulp) ... i zadziała:

.command("customer1 <place> [language]","Create a customer directory")

To dlatego łyk zdaje się wyzwalać zadanie, zanim yargs będzie mógł sprawdzić ten wymagany parametr. Rozpracowanie tego kosztowało mnie wiele godzin.

Mam nadzieję, że to ci pomoże ...

Wiem, że spóźniłem się z odpowiedzią na to pytanie, ale chciałbym dodać coś do odpowiedzi na @Ethan, najlepiej głosowaną i zaakceptowaną odpowiedź.

Możemy użyć, yargsaby uzyskać parametr wiersza poleceń, a tym samym możemy również dodać własny alias dla niektórych parametrów, takich jak follow.

var args = require('yargs')
    .alias('r', 'release')
    .alias('d', 'develop')
    .default('release', false)
    .argv;

Prosimy zapoznać się z tym linkiem, aby uzyskać więcej informacji. https://github.com/yargs/yargs/blob/HEAD/docs/api.md

Poniżej podano użycie aliasu zgodnie z dokumentacją yargs. Możemy również znaleźć yargstam więcej funkcji i sprawić, że przejście z linii poleceń będzie jeszcze lepsze.

.alias (klucz, alias)

Ustaw nazwy kluczy jako równoważne, tak aby aktualizacje klucza były propagowane do aliasów i odwrotnie.

Opcjonalnie .alias () może przyjmować obiekt, który mapuje klucze na aliasy. Każdy klucz tego obiektu powinien być kanoniczną wersją opcji, a każda wartość powinna być ciągiem lub tablicą ciągów.

Po prostu załaduj go do nowego obiektu w trakcie procesu process.gulp = {}i popatrz na zadanie.