99

这是一个组合任务，我不知道如何用任务依赖项替换它。

...
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]

4

10 回答 10

85

或者你可以这样做：

gulp.start('task1', 'task2');
于 2014-04-25T16:48:31.633 回答
82 
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']);
});

您不再需要传递函数（尽管您仍然可以）来运行任务。您可以为 watch 提供一系列任务名称，它会为您执行此操作。

于 2014-02-20T11:28:27.193 回答
25

来源：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();
});
于 2014-11-05T22:03:17.117 回答
12

请原谅我复活了一个老问题。接受的答案没有解决在设置手表之前运行任务的问题。下一个答案使用即将消失的 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);

我是新来的。如果我忽略了一些明显的事情，请告诉我。

于 2015-03-27T16:14:14.120 回答
7

吞咽 4

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

我喜欢 gulp4 ！

于 2017-03-20T16:23:04.563 回答
5

正如@dman 提到的那样，gulp.start将在下一个版本中被丢弃。也可以在本期 gulp中看到。

在@Pavel Evstigneev 答案的评论中，@joemaller 提到我们可以在这种情况下使用运行序列。

但请注意，运行序列的作者说：

这是一个临时解决方案，直到 gulp 4.0 发布，它支持定义串行或并行任务依赖项。

请注意，此解决方案是一种 hack，并且可能会停止使用 gulp 的未来更新。

所以，在 gulp 4.0 之前，我们可以使用run-sequence，在 4.0 之后，我们可以只使用 gulp。

于 2015-12-24T14:02:00.510 回答
3

如果您需要维护运行任务的顺序，您可以定义依赖项，如下所述-您只需要从依赖项返回流：

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运行之前完成（例如，您的“茉莉花”和“嵌入”任务将是依赖项，您将拥有另一个依赖于它们的任务“服务器”）。不需要任何黑客。

于 2015-08-28T09:55:45.257 回答
2

在 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('...'));
});
于 2019-04-08T19:34:27.943 回答
1

要在开始观看之前运行任务，而不是使用 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/'));

或者，您可以将后面的代码包装在“普通”函数中，并在需要时调用它。

- 灵感来自类似线程的这个答案。

于 2015-07-05T20:38:02.440 回答
0

我仍然不明白这实际上是如何解决手头的问题的。

如果我有 4 个任务之间定义了依赖关系

A B C 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：如果有人想知道如果任何依赖任务失败，我为什么要执行我的 watch 任务，这通常是因为我使用 watch 进行实时开发。例如。我开始我的监视任务以开始进行测试等，并且可能是我开始使用的初始代码已经存在问题，因此出现了错误。

所以我希望 gulp 运行或类似的运行一段时间

于 2016-03-15T14:27:36.997 回答