Gulp.run устарел. Как составить задачи?

Ответ 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']);
});

Вам больше не нужно передавать функцию (хотя вы все еще можете) для запуска задач. Вы можете просмотреть массив имен задач, и он сделает это за вас.

Ответ 2

Или вы можете сделать вот так:

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

Ответ 3

источник: https://github.com/gulpjs/gulp/issues/755

gulp.start() никогда не предназначался для публичного api и не использовался. И, как указано выше в комментариях, управление задачами заменяется в следующей версии.... так что gulp.start() будет ломаться.

Истинное намерение дизайна gulp состоит в том, чтобы делать регулярные функции Javascript и только делать задачу для их вызова.

Пример:

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

Ответ 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);

Я новичок в gulp. Пожалуйста, дайте мне знать, если я упустил что-то очевидное.

Ответ 5

Как @dman упоминает, gulp.start будет gulp.start в следующей версии. Также это можно увидеть в этом выпуске глотка.

И в комментариях к ответу @Pavel Evstigneev @joemaller упоминает, что мы можем использовать последовательность выполнения в этом сценарии.

Но, пожалуйста, обратите внимание, что автор run-sequence говорит:

Предполагается, что это будет временное решение до выпуска gulp 4.0, который поддерживает определение зависимостей задач последовательно или параллельно.

Имейте в виду, что это решение взломано и может перестать работать с будущим обновлением gulp.

Итак, до gulp 4.0 мы могли использовать последовательность выполнения, после 4.0 мы можем просто использовать gulp.

Ответ 6

Если вам нужно поддерживать порядок выполнения задач, вы можете определить зависимости, как описано здесь - вам просто нужно вернуть поток из зависимости:

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 (например, ваши задачи "жасмин" и "встраивание" будут зависимыми, и у вас будет другой "сервер" задачи, который будет зависеть от них). Нет необходимости в каких-либо хаках.

Ответ 7

gulp 4

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

Мне нравится gulp4!

Ответ 8

Чтобы запустить задачу перед началом просмотра, вместо использования 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/'));

Или вы можете перенести этот последний код в "нормальную" функцию и называть ее всякий раз, когда захотите.

- Вдохновленный этот ответ из аналогичного потока.

Ответ 9

Я до сих пор не вижу, как это фактически решает вопрос.

Если у меня есть 4 задачи с зависимостями, определенными между ними

А, В, С, D

где A зависит от B и т.д., как определено 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(){
   ...
}

который будет выполнять A- > D, но если, например, шаг B, он никогда не войдет в задачу (подумайте об ошибке компиляции или теста)

или я могу написать 2)

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

который не запускал бы A- > D, пока что-то не изменилось.

или я могу написать 3)

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

что приведет к дублированию (и ошибкам с течением времени) иерархии зависимостей.

PS: В случае, если кто-то задается вопросом, почему я хотел бы, чтобы моя задача наблюдения выполнялась, если какая-либо из зависимых задач терпит неудачу, что обычно происходит из-за того, что я использую часы для разработки в реальном времени. например. я запускаю задачу с часами, чтобы начать работу над тестами и т.д., и может быть, что исходный код, с которого я начинаю работать, уже имеет проблемы с ошибками.

Так что я надеюсь, что gulp запустится или какое-то эквивалентное количество останется в течение некоторого времени

Ответ 10

В Gulp 4 единственное, что мне кажется, работает:

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

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