web-dev-qa-db-de.com

Ist es möglich, eine Flagge an Gulp zu übergeben, damit dieser Aufgaben auf verschiedene Arten ausführt?

Normalerweise sehen Aufgaben in Gulp so aus:

gulp.task('my-task', function() {
    return gulp.src(options.SCSS_SOURCE)
        .pipe(sass({style:'nested'}))
        .pipe(autoprefixer('last 10 version'))
        .pipe(concat('style.css'))
        .pipe(gulp.dest(options.SCSS_DEST));
});

Ist es möglich, ein Kommandozeilen-Flag an gulp zu übergeben (das ist keine Aufgabe) und Tasks darauf basierend bedingt auszuführen? Zum Beispiel

$ gulp my-task -a 1

Und dann in meiner gulpfile.js:

gulp.task('my-task', function() {
        if (a == 1) {
            var source = options.SCSS_SOURCE;
        } else {
            var source = options.OTHER_SOURCE;
        }
        return gulp.src(source)
            .pipe(sass({style:'nested'}))
            .pipe(autoprefixer('last 10 version'))
            .pipe(concat('style.css'))
            .pipe(gulp.dest(options.SCSS_DEST));
});
362
asolberg

Gulp bietet dafür keine Verwendung, aber Sie können einen der vielen Befehlsargument-Parser verwenden. Ich mag yargs . Sollte sein:

_var argv = require('yargs').argv;

gulp.task('my-task', function() {
    return gulp.src(argv.a == 1 ? options.SCSS_SOURCE : options.OTHER_SOURCE)
        .pipe(sass({style:'nested'}))
        .pipe(autoprefixer('last 10 version'))
        .pipe(concat('style.css'))
        .pipe(gulp.dest(options.SCSS_DEST));
});
_

Sie können es auch mit gulp-if kombinieren, um den Stream bedingt weiterzuleiten.

_var argv = require('yargs').argv,
    gulpif = require('gulp-if'),
    rename = require('gulp-rename'),
    uglify = require('gulp-uglify');

gulp.task('my-js-task', function() {
  gulp.src('src/**/*.js')
    .pipe(concat('out.js'))
    .pipe(gulpif(argv.production, uglify()))
    .pipe(gulpif(argv.production, rename({suffix: '.min'})))
    .pipe(gulp.dest('dist/'));
});
_

Und mit _gulp my-js-task_ oder _gulp my-js-task --production_ anrufen.

522
Caio Cunha

Bearbeiten

gulp-util ist veraltet und sollte vermieden werden, daher wird empfohlen, stattdessen minimist zu verwenden, welches gulp-util bereits verwendet wird.

Also habe ich einige Zeilen in meinem Gulpfile geändert, um gulp-util zu entfernen:

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

gulp.task('styles', function() {
  return gulp.src(['src/styles/' + (argv.theme || 'main') + '.scss'])
    …
});

Original

In meinem Projekt verwende ich das folgende Flag:

gulp styles --theme literature

Gulp bietet dafür ein Objekt gulp.env an. In neueren Versionen ist es veraltet, daher müssen Sie dafür gulp-util verwenden. Die Aufgaben sehen so aus:

var util = require('gulp-util');

gulp.task('styles', function() {
  return gulp.src(['src/styles/' + (util.env.theme ? util.env.theme : 'main') + '.scss'])
    .pipe(compass({
        config_file: './config.rb',
        sass   : 'src/styles',
        css    : 'dist/styles',
        style  : 'expanded'

    }))
    .pipe(autoprefixer('last 2 version', 'safari 5', 'ie 8', 'ie 9', 'ff 17', 'opera 12.1', 'ios 6', 'Android 4'))
    .pipe(livereload(server))
    .pipe(gulp.dest('dist/styles'))
    .pipe(notify({ message: 'Styles task complete' }));
});

Die Umgebungseinstellung ist während aller Unteraufgaben verfügbar. So kann ich dieses Flag auch für die Überwachungsaufgabe verwenden:

gulp watch --theme literature

Und meine Style-Aufgabe funktioniert auch.

Ciao Ralf

101
RWAM

Hier ist ein schnelles Rezept, das ich gefunden habe:

gulpfile.js

var gulp   = require('gulp');

// npm install gulp yargs gulp-if gulp-uglify
var args   = require('yargs').argv;
var gulpif = require('gulp-if');
var uglify = require('gulp-uglify');

var isProduction = args.env === 'production';

gulp.task('scripts', function() {
  return gulp.src('**/*.js')
    .pipe(gulpif(isProduction, uglify())) // only minify if production
    .pipe(gulp.dest('dist'));
});

CLI

gulp scripts --env production

Originalreferenz (nicht mehr verfügbar): https://github.com/gulpjs/gulp/blob/master/docs/recipes/pass-params-from-cli.md

Alternative mit Minimist

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

gulpfile.js

// npm install --save-dev gulp gulp-if gulp-uglify minimist

var gulp = require('gulp');
var gulpif = require('gulp-if');
var uglify = require('gulp-uglify');

var minimist = require('minimist');

var knownOptions = {
  string: 'env',
  default: { env: process.env.NODE_ENV || 'production' }
};

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

gulp.task('scripts', function() {
  return gulp.src('**/*.js')
    .pipe(gulpif(options.env === 'production', uglify())) // only minify if production
    .pipe(gulp.dest('dist'));
});

CLI

gulp scripts --env production
57
AEQ

Es gibt eine sehr einfache Möglichkeit, on/off Flags zu erstellen, ohne die Argumente zu analysieren. gulpfile.js ist nur eine Datei, die wie jede andere ausgeführt wird. Sie können also Folgendes tun:

var flags = {
  production: false
};

gulp.task('production', function () {
  flags.production = true;
});

Und verwenden Sie so etwas wie gulp-if, um einen Schritt bedingt auszuführen

gulp.task('build', function () {
  gulp.src('*.html')
    .pipe(gulp_if(flags.production, minify_html()))
    .pipe(gulp.dest('build/'));
});

Wenn Sie gulp build ausführen, wird ein Nice-HTML-Code erstellt, während gulp production build diesen minimiert.

39
Emil Ivanov

Wenn Sie strenge (geordnete!) Argumente haben, können Sie diese einfach durch Aktivieren von _process.argv_ erhalten.

_var args = process.argv.slice(2);

if (args[0] === "--env" && args[1] === "production");
_

Führe es aus: _gulp --env production_

... allerdings halte ich das für zu streng und nicht kugelsicher! Also habe ich ein bisschen rumgespielt ... und am Ende diese Utility-Funktion erhalten:

_function getArg(key) {
  var index = process.argv.indexOf(key);
  var next = process.argv[index + 1];
  return (index < 0) ? null : (!next || next[0] === "-") ? true : next;
}
_

Es frisst einen Argumentnamen und sucht danach in _process.argv_. Wenn nichts gefunden wurde, spuckt es null aus. Ist dies nicht der Fall, wird true zurückgegeben. (Das liegt daran, dass der Schlüssel existiert, aber es gibt einfach keinen Wert). Wenn alle vorhergehenden Fälle fehlschlagen, erhalten wir den nächsten Argumentwert.

> gulp watch --foo --bar 1337 -boom "Foo isn't equal to bar."

_getArg("--foo") // => true
getArg("--bar") // => "1337"
getArg("-boom") // => "Foo isn't equal to bar."
getArg("--404") // => null
_

Ok, genug fürs Erste ... Hier ist ein einfaches Beispiel mit gulp :

_var gulp = require("gulp");
var sass = require("gulp-sass");
var rename = require("gulp-rename");

var env = getArg("--env");

gulp.task("styles", function () {
  return gulp.src("./index.scss")
  .pipe(sass({
    style: env === "production" ? "compressed" : "nested"
  }))
  .pipe(rename({
    extname: env === "production" ? ".min.css" : ".css"
  }))
  .pipe(gulp.dest("./build"));
});
_

Führe es aus _gulp --env production_

32
yckart

Ich habe ein Plugin erstellt, um Parameter von der Kommandozeile in den Task-Callback einzufügen.

gulp.task('mytask', function (production) {
  console.log(production); // => true
});

// gulp mytask --production

https://github.com/stoeffel/gulp-param

Wenn jemand einen Fehler findet oder eine Verbesserung daran hat, bin ich froh, PRs zusammenzuführen.

7
stoeffel

Und wenn Sie TypeScript (gulpfile.ts) verwenden, tun Sie dies für yargs (aufbauend auf @Caio Cunhas exzellenter Antwort https://stackoverflow.com/a/23038290/1019307 und andere Kommentare oben):

Installieren

npm install --save-dev yargs

typings install dt~yargs --global --save

.ts Dateien

Fügen Sie dies zu den .ts-Dateien hinzu:

import { argv } from 'yargs';

...

  let debug: boolean = argv.debug;

Dies muss in jeder .ts-Datei einzeln durchgeführt werden (sogar in den tools/tasks/project -Dateien, die in den gulpfile.ts/js importiert werden).

Lauf

gulp build.dev --debug

Oder unter npm das Argument zum Schlucken durchgeben:

npm run build.dev -- --debug
4
HankCa

Übergeben Sie Argumente über die Befehlszeile

// npm install --save-dev gulp gulp-if gulp-uglify minimist

var gulp = require('gulp');
var gulpif = require('gulp-if');
var uglify = require('gulp-uglify');

var minimist = require('minimist');

var knownOptions = {
  string: 'env',
  default: { env: process.env.NODE_ENV || 'production' }
};

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

gulp.task('scripts', function() {
  return gulp.src('**/*.js')
    .pipe(gulpif(options.env === 'production', uglify())) // only minify in production
    .pipe(gulp.dest('dist'));
});

Dann schlucken mit:

$ gulp scripts --env development

Quelle

2
HaNdTriX
var isProduction = (process.argv.indexOf("production")>-1);

CLI gulp production ruft meine Produktionsaufgabe auf und setzt ein Flag für Bedingungen.

Wir wollten eine andere Konfigurationsdatei für verschiedene Umgebungen übergeben - eine für Produktion, Entwicklung und Test. Dies ist der Code in der gulp-Datei:

//passing in flag to gulp to set environment
//var env = gutil.env.env;

if (typeof gutil.env.env === 'string') {
  process.env.NODE_ENV = gutil.env.env;
}

Dies ist der Code in der Datei app.js:

  if(env === 'testing'){
      var Config = require('./config.testing.js');
      var Api = require('./api/testing.js')(Config.web);
    }
    else if(env === 'dev'){
       Config = require('./config.dev.js');
        Api = require('./api/dev.js').Api;
    }
    else{
       Config = require('./config.production.js');
       Api = require('./api/production.js')(Config.web);
    }

Und dann, um es schlucken zu lassen --env=testing

Es ist einige Zeit her, dass diese Frage gestellt wurde, aber vielleicht hilft sie jemandem.

Ich verwende GULP CLI 2.0.1 (global installiert) und GULP 4.0.0 (lokal installiert). Ich denke, der Code ist ziemlich selbsterklärend.

var cp = require('child_process'), 
{ src, dest, series, parallel, watch } = require('gulp');

// == availableTasks: log available tasks to console
function availableTasks(done) {
  var command = 'gulp --tasks-simple';
  if (process.argv.indexOf('--verbose') > -1) {
    command = 'gulp --tasks';
  }
  cp.exec(command, function(err, stdout, stderr) {
    done(console.log('Available tasks are:\n' + stdout));
  });
}
availableTasks.displayName = 'tasks';
availableTasks.description = 'Log available tasks to console as plain text list.';
availableTasks.flags = {
  '--verbose': 'Display tasks dependency tree instead of plain text list.'
};
exports.availableTasks = availableTasks;

Und von der Konsole aus ausführen:

gulp availableTasks

Dann lauf und sieh dir die Unterschiede an:

gulp availableTasks --verbose
1
TMMC