Normalerweise können wir die Schluckaufgabe von der Konsole über so etwas ausführen gulp mytask. Gibt es überhaupt eine Möglichkeit, Parameter an die Schluckaufgabe zu übergeben? Wenn möglich, zeigen Sie bitte beispielhaft, wie es gemacht werden kann.

Es ist ein Feature, auf das Programme nicht verzichten können. Sie können Yargs versuchen .

npm install --save-dev yargs

Sie können es so verwenden:

gulp mytask --production --test 1234

Im Code zum Beispiel:

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

Für dein Verständnis:

> 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

Hoffe du kannst es von hier nehmen.

Es gibt ein anderes Plugin, das Sie verwenden können, Minimist. Es gibt einen weiteren Beitrag, in dem es gute Beispiele für Yargs und Minimisten gibt: ( Ist es möglich, Gulp eine Flagge zu übergeben, damit es Aufgaben auf unterschiedliche Weise ausführt ? )

Wenn Sie vermeiden möchten, zusätzliche Abhängigkeiten hinzuzufügen, habe ich Knoten process.argvals nützlich empfunden:

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

Also folgendes:

gulp mytask --option 123

sollte anzeigen:

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

Wenn Sie sicher sind, dass sich der gewünschte Parameter an der richtigen Position befindet, werden die Flags nicht benötigt. ** Verwenden Sie einfach (in diesem Fall):

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

ABER: Da die Option möglicherweise nicht festgelegt ist oder sich in einer anderen Position befindet, denke ich, dass eine bessere Idee so etwas wie:

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

Auf diese Weise können Sie Variationen in mehreren Optionen verarbeiten, z.

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

** Bearbeiten: true für Knotenskripte, aber gulp interpretiert alles ohne ein führendes "-" als einen anderen Aufgabennamen. Die Verwendung gulp mytask 123schlägt also fehl, da gulp keine Aufgabe namens '123' finden kann.

Das Übergeben eines Parameters an gulp kann einige Dinge bedeuten:

• Von der Kommandozeile bis zur Gulpfile (hier bereits beispielhaft dargestellt).
• Vom Hauptteil des Skripts gulpfile.js bis zum Schlucken von Aufgaben.
• Von einer Schluckaufgabe zu einer anderen Schluckaufgabe.

Hier ist ein Ansatz zum Übergeben von Parametern von der Haupt-Gulpfile an eine Gulp-Aufgabe. Indem Sie die Aufgabe, die den Parameter benötigt, in ein eigenes Modul verschieben und in eine Funktion einschließen (damit ein Parameter übergeben werden kann):

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

Dies kann nützlich sein, wenn Sie viele Schluckaufgaben haben und ihnen einige praktische Umgebungskonfigurationen übergeben möchten. Ich bin nicht sicher, ob es zwischen einer Aufgabe und einer anderen funktionieren kann.

Es gibt ein offizielles Schluckrezept dafür mit Minimist .

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

Die Grundlagen verwenden Minimist, um die cli-Argumente zu trennen und mit bekannten Optionen zu kombinieren:

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

Welches würde so etwas analysieren

$ gulp scripts --env development

Weitere Informationen finden Sie im Rezept.

Wenn Sie Umgebungsparameter und andere Dienstprogramme sowie log verwenden möchten , können Sie gulp-util verwenden

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

Aktualisieren

gulp-util ist jetzt veraltet. Sie können stattdessen Minimist verwenden.

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

@ Ethans Antwort würde komplett funktionieren. Nach meiner Erfahrung besteht der Knotenpunkt darin, Umgebungsvariablen zu verwenden. Dies ist eine Standardmethode zum Konfigurieren von Programmen, die auf Hosting-Plattformen (z. B. Heroku oder Dokku) bereitgestellt werden.

Gehen Sie folgendermaßen vor, um den Parameter über die Befehlszeile zu übergeben:

Entwicklung: gulp dev

Produktion: NODE_ENV=production gulp dev

Die Syntax ist unterschiedlich, aber sehr Unix und kompatibel mit Heroku, Dokku usw.

Sie können auf die Variable in Ihrem Code unter zugreifen process.env.NODE_ENV

MYAPP=something_else gulp dev

würde setzen

process.env.MYAPP === 'something_else'

Diese Antwort könnte Ihnen einige andere Ideen geben.

Hier ist mein Beispiel, wie ich es benutze. Für die CSS / Less-Aufgabe. Kann für alle angewendet werden.

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

Hier ist ein anderer Weg ohne zusätzliche Module:

Ich musste die Umgebung anhand des Aufgabennamens erraten. Ich habe eine 'dev'-Aufgabe und eine' prod'-Aufgabe.

Wenn ich starte gulp prod, sollte es auf Prod-Umgebung eingestellt sein. Wenn ich laufe gulp devoder irgendetwas anderes, sollte es auf Entwicklungsumgebung eingestellt sein.

Dazu überprüfe ich einfach den Namen der laufenden Aufgabe:

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

Wenn Sie Schluck mit Garnen verwenden, beachten Sie Folgendes:

Wenn Sie eine Aufgabe 'Kunde' haben und keine Yargs verwenden möchten, bauen Sie die Parameterprüfung auf erforderliche Befehle ein:

.command("customer <place> [language]","Create a customer directory") Nennen Sie es mit:

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

yargs wird immer einen Fehler auslösen, dass dem Aufruf nicht genügend Befehle zugewiesen wurden, auch wenn Sie !! - -

Probieren Sie es aus und fügen Sie dem Befehl nur eine Ziffer hinzu (damit er nicht dem Namen der Schluckaufgabe entspricht) ... und es funktioniert:

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

Dies ist die Ursache dafür, dass Schlucken die Aufgabe auslöst, bevor yargs nach diesem erforderlichen Parameter suchen kann. Es hat mich mehrere Stunden gekostet, das herauszufinden.

Hoffe das hilft dir ..

Ich weiß, dass ich zu spät komme, um diese Frage zu beantworten, aber ich möchte etwas hinzufügen, um @Ethan zu beantworten, die am höchsten bewertete und akzeptierte Antwort.

Wir können verwenden yargs, um den Befehlszeilenparameter abzurufen, und damit können wir auch unseren eigenen Alias ​​für einige Parameter wie follow hinzufügen.

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

Bitte beziehen Sie sich auf diesen Link für weitere Details. https://github.com/yargs/yargs/blob/HEAD/docs/api.md

Es folgt die Verwendung eines Alias ​​gemäß der Dokumentation von yargs. Wir können dort auch mehr yargsFunktionen finden und die Erfahrung beim Übergeben von Befehlszeilen noch verbessern.

.alias (Schlüssel, Alias)

Legen Sie Schlüsselnamen als äquivalent fest, sodass Aktualisierungen eines Schlüssels an Aliase weitergegeben werden und umgekehrt.

Optional kann .alias () ein Objekt übernehmen, das Schlüssel Aliasnamen zuordnet. Jeder Schlüssel dieses Objekts sollte die kanonische Version der Option sein, und jeder Wert sollte eine Zeichenfolge oder ein Array von Zeichenfolgen sein.

Laden Sie es einfach in ein neues Objekt während des Prozesses. process.gulp = {}Lassen Sie die Aufgabe dort suchen.