gulp.run पदावनत है। मैं कार्यों की रचना कैसे करूँ?

Question

यहाँ एक कार्य है जो मुझे नहीं पता कि इसे कार्य निर्भरता के साथ कैसे प्रतिस्थापित किया जाए।

...
gulp.task('watch', function () {
 var server = function(){
  gulp.run('jasmine');
  gulp.run('embed');
 };
 var client = function(){
  gulp.run('scripts');
  gulp.run('styles');
  gulp.run('copy');
  gulp.run('lint');
 };
 gulp.watch('app/*.js', server);
 gulp.watch('spec/nodejs/*.js', server);
 gulp.watch('app/backend/*.js', server);
 gulp.watch('src/admin/*.js', client);
 gulp.watch('src/admin/*.css', client);
 gulp.watch('src/geojson-index.json', function(){
  gulp.run('copygeojson');
 });
});

इसी चेंजलॉग https://github.com/gulpjs/gulp/blob/master/CHANGELOG.md#35 [चित्रण gulp.run]

Answer 1

gulp.task('watch', function () {
  var server = ['jasmine', 'embed'];
  var client = ['scripts', 'styles', 'copy', 'lint'];
  gulp.watch('app/*.js', server);
  gulp.watch('spec/nodejs/*.js', server);
  gulp.watch('app/backend/*.js', server);
  gulp.watch('src/admin/*.js', client);
  gulp.watch('src/admin/*.css', client);
  gulp.watch('src/geojson-index.json', ['copygeojson']);
});

अब आपको फ़ंक्शन चलाने के लिए फ़ंक्शन (हालांकि आप अभी भी कर सकते हैं) पास करने की आवश्यकता नहीं है। आप कार्य नामों की एक सरणी दे सकते हैं और यह आपके लिए ऐसा करेगा।

Comments

क्या होगा अगर मैं देखना शुरू करने से पहले कुछ कार्य चलाना चाहता हूं? उदाहरण के लिए, मैं देखना चाहता हूं scripts, लेकिन यह इस कार्य को तुरंत चलाने के लिए समझ में आता है (बिना कुछ स्क्रिप्ट फ़ाइल परिवर्तन तक प्रतीक्षा किए)।

— मोनसिग्नोर

और क्या उन कार्यों के लिए तर्कों को पारित करने का कोई तरीका है?

— डॉ। एर्नी

@ मॉन्शिंगर ने जो सवाल पूछा, वह अप्रासंगिक था।

— मार्क अमेरी

@Monsingor इसे प्राप्त करने के लिए, आप एक नए कार्य को परिभाषित कर सकते हैं जो कार्यों की एक सूची निष्पादित करता है। उदाहरण के लिए, मैं आमतौर पर निम्नलिखित डिफ़ॉल्ट कार्य को परिभाषित करता हूं gulp.task('default', ['build', 'watch']);, जो पहले बनाता है और फिर देखना शुरू करता है।

— बस्तियान वैन डेन बर्ग

@BastiaanvandenBerg मैंने सोचा कि गोल कार्यों को समानांतर में चलाने के लिए डिज़ाइन किया गया था? इसलिए भले ही आप पहले बिल्ड का सूचीबद्ध कर रहे हों, लेकिन वॉच टास्क में आग लगने से पहले इसे खत्म नहीं करना है। मुझे ओपी से मिल रहा है कि वे सुनिश्चित करना चाहते हैं कि घड़ी शुरू होने से पहले निर्माण समाप्त हो गया है।

— सीन रियान

Answer 2

या आप इस तरह कर सकते हैं:

gulp.start('task1', 'task2');

Comments

क्या यह उपयोग करने के लिए सुरक्षित है? मैं एपीआई डॉक्स (लिंक) में इसका उल्लेख नहीं देखता हूं ।

— फेलिक्स राबे

.startएक आर्केस्ट्रा विधि है। चूंकि गुल्प से विरासत में मिला है, यह काम करना चाहिए। मैं एक गैर- gulp फ़ंक्शन (घड़ी) से एक gulp कार्य को ट्रिगर कर रहा हूं और यह काम करता हुआ प्रतीत होता है।

— joemaller

gulp.startअगली रिलीज में हटाया जाएगा: github.com/gulpjs/gulp/issues/505#issuecomment-45379280

— yckart

@yckart तो हम किसी कार्य को निष्पादित करने के लिए क्या उपयोग करते हैं?

— चॉवी

इसे पुनर्जीवित करते हुए, अधिकांश उपयोगों को npmjs.com/package/run-fterencegulp-startrun-sequence

— joemaller

Answer 3

स्रोत: https://github.com/gulpjs/gulp/issues/755

gulp.start()कभी भी सार्वजनिक रूप से एपी का इस्तेमाल नहीं किया गया और न ही इसका इस्तेमाल किया गया। और जैसा कि ऊपर टिप्पणी में कहा गया है, कार्य प्रबंधन को अगली रिलीज में बदल दिया जा रहा है .... इसलिए gulp.start()ब्रेकिंग होगी।

गल्प डिजाइन का असली उद्देश्य नियमित रूप से जावास्क्रिप्ट कार्य करना है, और केवल उन्हें कॉल करने के लिए कार्य करना है।

उदाहरण:

function getJsFiles() {
    var sourcePaths = [
        './app/scripts/**/*.js',
        '!./app/scripts/**/*.spec.js',
        '!./app/scripts/app.js'
    ];

    var sources = gulp.src(sourcePaths, { read: false }).pipe(angularFilesort());

    return gulp.src('./app/index.html')
        .pipe(injector(sources, { ignorePath: 'app', addRootSlash: false }))
        .pipe(gulp.dest('./app'));
}  

---

gulp.task('js', function () {
    jsStream = getJsFiles();
});

Answer 4

एक पुराने प्रश्न को फिर से जीवित करने के लिए मुझे क्षमा करें। स्वीकृत उत्तर घड़ियों को सेट करने से पहले चल रहे कार्यों के मुद्दे को संबोधित नहीं करता है। अगले उत्तर में gulp.start का उपयोग किया गया है जो दूर जा रहा है। तीसरा उत्तर बताता है कि नियमित कार्यों का उपयोग किया जाना चाहिए लेकिन उदाहरण अजीब लगता है। मैंने कुछ खोज की लेकिन एक सरल उदाहरण नहीं मिला।

यहाँ मेरा समाधान है। यह विचार है कि नियमित js फ़ंक्शंस को परिभाषित करें और फिर उन्हें कार्यों के रूप में पंजीकृत करें। जरूरत पड़ने पर या घड़ी के भीतर से कार्य को सीधे बुलाया जा सकता है।

var 
  gulp     = require('gulp'),
  concat   = require('gulp-concat'),
  markdown = require('gulp-showdown')
;
var scriptFiles   = [ 'ang/app.js' ];
var markdownFiles = [ 'content/articles/*.md'];

var watchTask = function() 
{
  buildTask();

  gulp.watch(scriptFiles,  ['scripts' ]);
  gulp.watch(markdownFiles,['markdown']);
};
gulp.task('watch',watchTask);

var buildTask = function()
{
  scriptsTask();
  markdownTask();
};
gulp.task('build',buildTask);

var markdownTask = function() 
{
  gulp.src(markdownFiles)
    .pipe(markdown())
    .pipe(gulp.dest('web/articles'));
};
gulp.task('markdown',markdownTask);

var scriptsTask = function() 
{
  gulp.src(scriptFiles)
    .pipe(concat('app.js'))
    .pipe(gulp.dest('web/js'));

  gulp.src(
    [
      'bower_components/angular/angular.min.js',
      'bower_components/angular-route/angular-route.min.js'
    ])
    .pipe(concat('vendor.js'))
    .pipe(gulp.dest('web/js'));

  gulp.src(
    [
      'bower_components/angular/angular.min.js.map',
      'bower_components/angular-route/angular-route.min.js.map'
    ])
    .pipe(gulp.dest('web/js'));
};
gulp.task('scripts', scriptsTask);

मैं नया हूं। कृपया मुझे बताएं कि क्या मैंने कुछ स्पष्ट अनदेखी की है।

Comments

इससे "निर्माण" कार्यों और "पुनर्निर्माण" कार्यों को बनाना भी आसान हो जाता है, जहां दोनों फ़ंक्शन को कहते हैं जो काम करता है लेकिन बाद वाला "स्वच्छ" कार्य पर भी निर्भर करता है।

— सेठ

क्या यह भी सामान्य gulp कार्य के समान समस्या नहीं है, जिसमें JS पूर्ण होने की पुष्टि होने से पहले gulp.watchपरिभाषित किए गए कार्यों पर आगे बढ़ जाएगा ? मुझे लगता है कि यह अभी भी एक दौड़ की स्थिति है, और घड़ी से पहले निर्माण की गारंटी नहीं देता है। watchTask()buildTask()

— शॉन रयान

Answer 5

गुलाल ४

gulp.parallel('taskName1', 'taskName2')()
gulp.series('taskName1', 'taskName2')()

मुझे पसंद है gulp4!

Comments

बहुत खोजने के बाद सबसे अच्छा जवाब। धन्यवाद।

— अमीनफराजजादेह

Answer 6

जैसा कि @dman का उल्लेख है कि, gulp.startअगले संस्करण में छोड़ दिया जाएगा। साथ ही यह गल्प के इस अंक में देखा जा सकता है ।

और @Pavel Evstigneev के उत्तर की टिप्पणियों में, @joemaller का उल्लेख है कि हम इस परिदृश्य में रन-अनुक्रम का उपयोग कर सकते हैं ।

लेकिन कृपया ध्यान दें कि, रन-सीक्वेंस के लेखक का कहना है:

यह gulp 4.0 की रिलीज़ तक एक अस्थायी समाधान होने का इरादा है, जिसमें श्रृंखला या समानांतर में कार्य निर्भरताओं को परिभाषित करने के लिए समर्थन है।

विदित हो कि यह समाधान हैक है, और भविष्य के अपडेट के साथ काम करना बंद कर सकता है।

तो, gulp 4.0 से पहले, हम रन-अनुक्रम का उपयोग कर सकते हैं , 4.0 के बाद, हम gulp का उपयोग कर सकते हैं।

Answer 7

यदि आपको चल रहे कार्यों के क्रम को बनाए रखने की आवश्यकता है, तो आप यहां बताई गई निर्भरता को परिभाषित कर सकते हैं - आपको केवल निर्भरता से स्ट्रीम वापस करने की आवश्यकता है:

gulp.task('dependency', function () {
  return gulp.src('glob')
    .pipe(plumber())
    .pipe(otherPlugin())
    .pipe(gulp.dest('destination'));
});

उस कार्य को परिभाषित करें जो उस पर निर्भर करता है:

gulp.task('depends', [ 'dependency' ], function () {
  // do work
});

और इसे घड़ी से उपयोग करें:

gulp.task('watch', function () {
  watch('glob', [ 'depends' ]);
});

अब dependecyकार्य dependsरन से पहले पूरा हो जाएगा (उदाहरण के लिए आपके 'चमेली' और 'एम्बेड' कार्य निर्भरता होंगे और आपके पास एक और कार्य 'सर्वर' होगा जो उन पर निर्भर करेगा)। इसके लिए किसी हैक्स की जरूरत नहीं है।

Comments

मुझे यकीन नहीं है कि अगर यह ऑफ-टॉपिक नहीं है, क्योंकि यह केवल टिप्पणियों के सवालों का जवाब देता है जो अलग-अलग प्रश्न होने चाहिए

— किल्लाह

Answer 8

गुल्प 4 में मेरे लिए काम करने वाली एकमात्र चीज़ है:

gulp.task('watch', function() {
    gulp.watch(['my-files/**/*'], gulp.series('my-func'));
});

gulp.task('my-func', function() {
    return gulp.src('[...]').pipe(gulp.dest('...'));
});

Answer 9

घड़ी शुरू करने से पहले एक कार्य चलाने के लिए, बजाय gulp.run () या gulp.start () का उपयोग करके सीधे gulp कमांड चलाएं।

इसलिए इसके बजाय:

var compress = function () {
    return gulp.src('js/vendor/*.js')
        .pipe(concat('vendor.js'))
        .pipe(gulp.dest('./build/js/'));
};

बस करो:

gulp.src('js/vendor/*.js')
        .pipe(concat('vendor.js'))
        .pipe(gulp.dest('./build/js/'));

या आप उस बाद वाले कोड को "सामान्य" फ़ंक्शन में लपेट सकते हैं और जब चाहें तब कॉल कर सकते हैं।

- एक समान धागे से इस उत्तर से प्रेरित ।

Answer 10

मैं अभी भी नहीं देखता कि यह वास्तव में प्रश्न को कैसे हल करता है।

यदि मेरे पास उनके बीच परिभाषित निर्भरता वाले 4 कार्य हैं

ऐ बी सी डी

जहाँ A बी पर निर्भर करता है, आदि के द्वारा परिभाषित किया गया है gulp.task('A',['B'],function A(){}); और फिर मैंने gulp.watch का उपयोग करके एक नया कार्य परिभाषित किया है, जो केवल फ़ंक्शंस को दोहराएगा।

उदाहरण के लिए ये कार्य दिए गए हैं (प्रत्येक कार्य फ़ंक्शन नाम से उजागर होता है):

function A(){}
gulp.task('A',['B'],A);

function A(){}
gulp.task('A',['B'],A);

function B(){}
gulp.task('B',['C'],B);

function C(){}
gulp.task('C',['D'],C);

function D(){}
gulp.task('D',[],D);

मैं 1 लिख सकता हूं)

gulp.task('WATCHER', ['A'], function(){
   ...
}

जो ए-> डी पर अमल करेगा, लेकिन अगर स्टेप बी विफल हो जाता है तो वह कभी भी कार्य में प्रवेश नहीं करेगा (संकलन या परीक्षण त्रुटि के बारे में सोचें)

या मैं 2 लिख सकता हूं)

gulp.task('WATCHER', [], function(){
   gulp.watch(...,['A'])
}

जब तक कि A-> D तब तक नहीं चलेगा जब तक कि पहले कुछ बदल न जाए।

या मैं 3 लिख सकता हूं)

gulp.task('WATCHER', [], function(){
   D();
   C();
   B();
   A();
   gulp.watch(...,['A'])
}

जो निर्भरता पदानुक्रम के दोहराव (और समय के साथ त्रुटियों) का कारण होगा।

पुनश्च: यदि कोई व्यक्ति सोच रहा है कि मैं क्यों चाहता हूं कि मेरी घड़ी का कार्य निष्पादित हो जाए तो आश्रित कार्यों में से कोई भी विफल हो जाता है जो आमतौर पर इसलिए होता है क्योंकि मैं लाइव विकास के लिए घड़ी का उपयोग करता हूं। जैसे। मैं परीक्षण आदि पर काम करना शुरू करने के लिए अपना घड़ी का काम शुरू करता हूं और यह हो सकता है कि शुरुआती कोड मैं पहले से ही इस प्रकार की त्रुटियों के साथ शुरू कर दूं।

इसलिए मुझे उम्मीद है कि कुछ समय के लिए गल्प रन या कुछ बराबर बने रहेंगे

Comments

यह मौजूदा जवाब किस खंड के उद्देश्य से दिया गया है?

— मोगादाद