क्या विभिन्न तरीकों से कार्यों को चलाने के लिए एक झंडे को गुलेल से गुजारना संभव है?

Question

आम तौर पर गुलप कार्यों में ऐसा दिखता है:

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

क्या यह संभव है कि कमांड लाइन के झंडे को गुलेल से गुज़ारा जाए (जो कि एक कार्य नहीं है) और क्या यह सशर्त रूप से उस पर आधारित कार्य चला रहा है? उदाहरण के लिए

$ gulp my-task -a 1

और फिर मेरे 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));
});

Comments

जैसा कि यह नोड में चल रहा है, आप संभवतः process.argvकमांड लाइन के तर्कों को एक्सेस करने के लिए उपयोग कर सकते हैं।

— zzzzBov

Answer 1

इसके लिए गुलप किसी भी तरह के उपयोग की पेशकश नहीं करता है, लेकिन आप कई कमांड आर्ग पार्सर में से एक का उपयोग कर सकते हैं। मुझे पसंद है yargs। होना चाहिए:

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

आप इसे gulp-ifसशर्त रूप से धारा के साथ जोड़ सकते हैं , देव बनाम ठेस इमारत के लिए बहुत उपयोगी है:

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

और gulp my-js-taskया के साथ बुलाओ gulp my-js-task --production।

Comments

यह किसी भी तरह @ आधिकारिक gulp github, आवश्यक सामान का उल्लेख किया जाना चाहिए!

— मैक्स

यह, वीडियो बताता है कि यारों के बिना इसे कैसे प्राप्त किया जाए: youtube.com/watch?v=gRzCAyNrPV8

— plankguy

हाय @plankguy, वीडियो बहुत अच्छा है। धन्यवाद। यह दिखाता है कि पर्यावरण चर को हाथ से कैसे पार किया जाए, बिना किसी परिवाद के। एक छोटा अंतर यह है कि वीडियो पर्यावरण चर के बारे में है , जबकि ऊपर का उदाहरण कमांड लाइन तर्कों के बारे में है , जहां यार्ग अभी तक एक और उपकरण है जो चर पार्सिंग को सार करके खपत को आसान बनाने में मदद करता है।

— 21-14 को काओ कुन्हा

यदि आप उपयोग करते हैं npm run gulpतो आपको इसका उपयोग करना चाहिए npm run gulp -- --production।

— ivkremer

यह @ gulp github का शाब्दिक उल्लेख है (शाब्दिक रूप से)।

— fracz

Answer 2

संपादित करें

gulp-utilहै पदावनत और, से बचने होना चाहिए तो यह उपयोग करने के लिए अनुशंसा की जाती है minimist बजाय, जो gulp-utilपहले से ही इस्तेमाल किया।

इसलिए मैंने हटाने के लिए अपने gulpfile में कुछ लाइनें बदल दी हैं gulp-util:

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

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

मूल

मेरी परियोजना में मैं निम्नलिखित ध्वज का उपयोग करता हूं:

gulp styles --theme literature

उसके लिए गुल एक वस्तु प्रदान करता gulp.envहै। यह नए संस्करणों में पदावनत है, इसलिए आपको इसके लिए गुल-उपयोग का उपयोग करना चाहिए। कार्य इस तरह दिखते हैं:

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

सभी उपस्करों के दौरान पर्यावरण सेटिंग उपलब्ध है। तो मैं इस ध्वज का उपयोग घड़ी के कार्य पर भी कर सकता हूं:

gulp watch --theme literature

और मेरा स्टाइल टास्क भी काम करता है।

सियाओ राल्फ़

Comments

gulp.envचलाया जा रहा है , जैसा कि आप कंसोल लॉग संदेश द्वारा इसे चलाते समय देख सकते हैं। वे आपको अपने स्वयं के पार्सर का उपयोग करने के लिए कहते हैं और सुझाव देते हैं yargsया minimist।

— कैयो कुन्हा

धन्यवाद @CaioToOn आपके संकेत के लिए। मैंने अपना उत्तर और अपनी परियोजना भी अपडेट कर दी है;)

— RWAM

आप छोटा कर सकते हैं util.env.theme ? util.env.theme : 'main'करने के लिए util.env.theme || 'main'। वैसे भी +1।

— रेनन

gulp-utilminimistकमांड लाइन तर्क पार्सिंग के लिए पुस्तकालय का उपयोग करता है । इसलिए यदि आप उपयोग कर रहे हैंgulp-util , तो आपको उस उद्देश्य के लिए अतिरिक्त पुस्तकालय की आवश्यकता नहीं है। दस्तावेज़: github.com/substack/minimist

— Rockallite

Answer 3

यहाँ एक त्वरित नुस्खा है जो मैंने पाया:

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

मूल रेफरी (अब उपलब्ध नहीं): https://github.com/gulpjs/gulp/blob/master/docs/recipes/pass-params-from-cli.md

न्यूनतम के साथ वैकल्पिक

अपडेटेड रेफरी से: 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

Comments

यह नुस्खा लिंक अब चला गया लगता है। एक और एक है जो न्यूनतम पैकेज का उपयोग करता है: पास- rarguments-from-cli.md । इससे समझ में आता है कि गुलप खुद मिनिमिस्ट का इस्तेमाल करता है ।

— युवीलियो

Answer 4

on/offतर्कों को पार्स किए बिना झंडे करने का एक बहुत ही सरल तरीका है । gulpfile.jsकेवल एक फ़ाइल है जिसे किसी अन्य की तरह निष्पादित किया जाता है, ताकि आप कर सकें:

var flags = {
  production: false
};

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

और gulp-ifसशर्त रूप से निष्पादित करने के लिए कुछ का उपयोग करें

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

निष्पादित gulp build एक अच्छा HTML उत्पन्न करेगा, जबकि gulp production buildइसे छोटा करेगा।

Comments

महान विचार, यार्गों का उपयोग करने से बचाता है, मैंने इसे 'पूर्व-उत्पादन' कार्य के द्वारा बढ़ाया है जो var सेट करता है और फिर 'उत्पादन' में ['build', 'पूर्व-उत्पादन'] की निर्भरता सरणी होती है। इस तरह आप बस 'उत्पादन' चला सकते हैं।

— कीगन 82

अच्छा! मैं स्ट्रीम सेट करने से पहले इसका उपयोग कर रहा हूं,gulp.task('mytask', function() { if (flags.myflag ) { flaggedtask } else { unflaggedask } });

— henry

मुझे लगता है कि यह इसे करने का तरीका है

— gztomas

@ कीगन की हेयरस्टाइल 82 मैंने कुछ ऐसा ही किया था, लेकिन यह सुनिश्चित करने के लिए रन-सीक्वेंस का उपयोग करना पड़ा कि संपत्तियों की स्थापना के समय कोई दौड़ की स्थिति न हो flags।

— कैलमलिनकार्स्की

इस पद्धति का नुकसान यह है कि आपको हर बार जब आप टर्मिनल में gulp कमांड को पास करने के लिए तर्क देते हैं, तो हर बार जब आप ध्वज चर बदलना चाहते हैं, तो आपको gulpfile.js को बदलना होगा।

— जॉबर्ड

Answer 5

यदि आपने कुछ सख्त (आदेशित!) तर्क दिए हैं, तो आप उन्हें बस जाँच करके प्राप्त कर सकते हैं process.argv।

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

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

इसे निष्पादित करो: gulp --env production

... फिर भी, मुझे लगता है कि यह है tooo सख्त और नहीं बुलेटप्रूफ! इसलिए, मैंने थोड़ा सा चक्कर लगाया ... और इस उपयोगिता समारोह के साथ समाप्त हुआ:

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

यह एक तर्क-नाम खाता है और इसके लिए खोज करेगा process.argv। अगर कुछ नहीं मिला तो उसे बाहर थूक दिया गया null। अन्यथा यदि उनका कोई अगला तर्क नहीं है या अगला तर्क एक आदेश है और एक मान नहीं है (हम डैश के साथ भिन्न हैं) trueवापस आ जाता है। (ऐसा इसलिए है क्योंकि कुंजी मौजूद है, लेकिन इसका कोई मूल्य नहीं है)। यदि सभी मामले पहले विफल हो जाएंगे, तो अगला तर्क-मूल्य वह है जो हमें मिलता है।

> 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

ठीक है, अभी के लिए पर्याप्त ... यहाँ एक सरल उदाहरण का उपयोग कर 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"));
});

चलाओ gulp --env production

Comments

तर्क नाम डैश के साथ उपसर्ग किया जाना चाहिए (es): if (args[0] === '--env' && args[1] === 'production');कम से कम gulp 3.8.11 में

— piotr_cz

@yckart - आपको अपने कोड उदाहरण में getArg के लिए संभवतः ('..') जोड़ना चाहिए।

— जॉबर्ड

Answer 6

मैंने कमांडलाइन से टास्क कॉलबैक में पैरामीटर इंजेक्ट करने के लिए एक प्लगइन बनाया।

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

// gulp mytask --production

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

अगर कोई बग ढूंढता है या उसमें सुधार होता है, तो मुझे पीआर को मर्ज करने में खुशी होगी।

Answer 7

और यदि आप टाइपस्क्रिप्ट ( gulpfile.ts) का उपयोग कर रहे हैं, तो इसके लिए करें yargs(@Caio Cunha के उत्कृष्ट उत्तर https://stackoverflow.com/a/23038290/1019307 पर और अन्य टिप्पणियों पर निर्माण करें ):

इंस्टॉल

npm install --save-dev yargs

typings install dt~yargs --global --save

.ts फ़ाइलें

इसे .ts फ़ाइलों में जोड़ें:

import { argv } from 'yargs';

...

  let debug: boolean = argv.debug;

यह प्रत्येक .ts फ़ाइल में व्यक्तिगत रूप से (यहां तक tools/tasks/projectकि आयात की जाने वाली फाइलें भी gulpfile.ts/js) में किया जाना है।

Daud

gulp build.dev --debug

या npmggp के माध्यम से आर्ग पास करें:

npm run build.dev -- --debug

Answer 8

कमांड लाइन से तर्क पास करें

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

इसके बाद गल्प चलाएं:

$ gulp scripts --env development

स्रोत

Answer 9

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

सीएलआई gulp productionमेरे उत्पादन कार्य को कॉल करता है और किसी भी स्थिति के लिए एक ध्वज सेट करता है।

Answer 10

हम उत्पादन , देव और परीक्षण के लिए अलग-अलग वातावरणों के लिए एक अलग विन्यास फाइल पास करना चाहते थे । यह 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;
}

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

और फिर इसे चलाने के लिए --env=testing

Answer 11

इस सवाल को पोस्ट किए कुछ समय हो गया है, लेकिन शायद यह किसी की मदद करेगा।

मैं GULP CLI 2.0.1 (विश्व स्तर पर स्थापित) और GULP 4.0.0 (स्थानीय रूप से स्थापित) का उपयोग कर रहा हूं, यहां आप इसे बिना किसी अतिरिक्त प्लगइन के कैसे कर रहे हैं। मुझे लगता है कि कोड काफी आत्म-व्याख्यात्मक है।

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;

और कंसोल से चलाएं:

gulp availableTasks

फिर दौड़ें और अंतर देखें:

gulp availableTasks --verbose