Gulp n'offre aucun utilitaire pour cela, mais vous pouvez utiliser l'un des nombreux analyseurs de commandes args. J'aime les yargs . Devrait être:

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

Vous pouvez également le combiner avec gulp-if pour condénérer le flux, très utile pour dev vs. prod building:

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

Et appelez avec gulp my-js-task ou gulp my-js-task --production .

Dans mon projet, j'utilise le drapeau suivant:

 gulp styles --theme literature 

Gulp offre un objet gulp.env pour cela. Il est obsolète dans les versions plus récentes, donc vous devez utiliser gulp-util pour cela. Les tâches se présentent comme suit:

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

Le paramètre environnement est disponible pendant toutes les sous-tâches. Je peux donc utiliser ce drapeau sur la tâche de surveillance aussi:

 gulp watch --theme literature 

Et ma tâche de styles fonctionne également.

Ciao Ralf

Voici une recette rapide que j'ai trouvée:

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 

Original Ref (plus disponible): https://github.com/gulpjs/gulp/blob/master/docs/recipes/pass-params-from-cli.md

Alternative avec minimist

À partir de la mise à jour Ref: 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 

Il existe un moyen très simple de faire on/off indicateurs de on/off sans analyser les arguments. gulpfile.js est juste un fichier qui est exécuté comme n'importe quel autre, afin que vous puissiez:

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

Et utiliser quelque chose comme gulp-if pour conditionnellement exécuter une étape

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

L'exécution de la gulp build produira un bon html, alors que gulp production build gulp le minifiera.

Si vous avez des arguments stricts (commandés!), Vous pouvez les obtenir simplement en vérifiant process.argv .

 var args = process.argv.slice(2); if (args[0] === "--env" && args[1] === "production"); 

Exécutez-le: gulp --env production

… cependant, je pense que c'est trop strict et pas anti-balles! Alors, j'ai fait un peu de goulou … et j'ai fini avec cette fonction d'utilité:

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

Il mange un argument-nom et va chercher cela dans process.argv . Si rien n'a été trouvé, il craque null . Sinon, si ce n'est pas un argument suivant ou si l'argument suivant est une commande et non une valeur (nous différons avec un tiret) true est renvoyé. (C'est parce que la clé existe, mais il n'y a plus aucune valeur). Si tous les cas précédents échouent, la prochaine valeur d'argument est ce que nous obtenons.

> 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, assez pour l'instant … Voici un exemple simple en utilisant 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")); }); 

Run it gulp --env production

J'ai construit un plugin pour injecter des paramètres de la ligne de commande dans le rappel de la tâche.

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

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

Si quelqu'un trouve un bug ou a une amélioration, je suis heureux de fusionner les PR.

Et si vous utilisez le gulpfile.ts dactylographié ( gulpfile.ts ), procédez comme yargs pour les yargs (en utilisant l'excellente réponse de @Caio Cunha https://stackoverflow.com/a/23038290/1019307 et d'autres commentaires ci-dessus):

Installer

 npm install --save-dev yargs typings install dt~yargs --global --save 

.ts fichiers

Ajoutez ceci aux fichiers .ts:

 import { argv } from 'yargs'; ... let debug: boolean = argv.debug; 

Cela doit être fait dans chaque fichier .ts individuellement (même les tools/tasks/project fichiers de tools/tasks/project importés dans gulpfile.ts/js ).

Courir

 gulp build.dev --debug 

Ou sous npm passent l'arg à traverser:

 npm run build.dev -- --debug 

Passer des arguments à partir de la ligne de commande

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

Ensuite, exécutez gulp avec:

 $ gulp scripts --env development 

La source

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

La gulp production CLI appelle ma tâche de production et définit un drapeau pour tous les conditionnels.

Nous voulions passer un fichier de configuration différent pour différents environnements – un pour la production, le développement et les tests. C'est le code dans le fichier gulp:

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