Question

我知道能够声明将在任务之前运行的依赖项，例如

gulp.task('a', () => {});
gulp.task('b', () => {});
gulp.task('c', ['a', 'c'], () => {});

任务＆＃39; a＆＃39;和＆＃39; b＆＃39;每次执行任务后都会运行＆＃39; c＆＃39;被称为并且在任务之前＆＃39; c＆＃39;被执行。

但是，如何以编程方式从gulp.task中调用任意任务？

Answer 1

我是用gulp.start（）做的;像这样：

gulp.task('test1', function(){
  gulp.start('test2');
})

gulp.task('test2', function(){
  // do something
})

如果重要的话，我正在使用gulp 3.9.1。可能会删除或弃用gulp.start()的内容;但它还没有发生。

<强>更新如果我将事情分解为单独的函数，正如Novellizator建议的那样，它将是这样的：

function doSomething(){
  // do something
}

gulp.task('test1', function(){
  doSomething();
})

gulp.task('test2', function(){
  doSomething();
})

这很简单，避免使用gulp.start（）。

Answer 2

关于＆＃34;不要＆＃34;的主题从其他答案来看，这取决于你正在做什么。

如果你在想：

gulp.task("a", () => {
    doSomethingInstant()
    return doTaskB()
})

你想：

gulp.task("meta-a", () => {
    doSomethingInstant()
})
gulp.task("a", ["meta-a", "b"])

这是有效的，因为所有任务都是按顺序启动的，所以如果你在＆＃34; meta-a＆＃34;中没有做任何异步，它将在＆＃34; b＆＃34;之前完成。开始。如果它是异步的，那么你需要更加明确：

gulp.task("meta-a", () => {
    return doSomethingAsync()
})
function taskB() {
    // Original task B code...
}
gulp.task("b", taskB)
gulp.task("a", ["meta-a"], taskB)

Answer 3

在Gulp 4+中，我发现它可以很好地替代gulp.start：

const task1 = () => { /*do stuff*/ };
const task2 = () => { /*do stuff*/ };

// Register the tasks with gulp. They will be named the same as their function
gulp.task(task1);
gulp.task(task2);

...

// Elsewhere in your gulfile you can run these tasks immediately by calling them like this
(gulp.series("task1", "task2")());
// OR
(gulp.parallel("task1", "task2")());

Answer 4

在相关说明中，您可以使用gulp v4中的gulp.series或gulp.parallel来启动任务。尽管它不能直接替代gulp.start，但可以达到相同的目的。

示例：

在v4之前

gulp.task('protractor', ['protractor:src']);

v4之后

gulp.task('protractor', gulp.series('protractor:src'));

Answer 5

正如JeffryHouser所述，使用以下方法可以正常工作，但已弃用，将在以后的版本中删除。我刚刚在3.9.1上尝试了以下内容，它运行正常。

代码：

// Variables
var gulp = require('gulp');
var less = require('gulp-less');
var watch = require('gulp-watch');


// Task to compile less -> css: Method 1- The bad way
gulp.task('default', function(){
    gulp.src('src/*.less')
    gulp.start('lessToCss');
});

gulp.task('lessToCss', function() {
    gulp.src('src/*.less')
    .pipe(less())
    .pipe(gulp.dest('src/main.css'));
});

Novellizator评论中提到的第二种方式是：

“将任务分解为函数，然后在需要”上述问题的建议时将其重用于其他任务

我是通过使用lazypipe（）https://www.npmjs.com/package/lazypipe

来完成的

代码：

// Variables
var gulp = require('gulp');
var less = require('gulp-less');
var watch = require('gulp-watch');

var lazypipe = require('lazypipe');
var fixMyCSS = lazypipe()
     .pipe(less); // Be CAREFUL here do not use less() it will give you an errror



// Task to compile less -> css: Method 2 - The nice way
gulp.task('default', function(){
    //gulp.start('lessToCss');
    gulp.src('src/*.less')
    .pipe(fixMyCSS())
    .pipe(gulp.dest('src/main.css'));
});

简短比较

方法1产生以下内容：

开始'默认'...
[22:59:12]开始'lessToCss'......
[22:59:12] 13 ms后完成'lessToCss'
[22:59:12] 48 ms后完成'默认'

总计 61 ms 完成

方法2？ - [23:03:24]开始'默认'...... - [23:03:24] 38 ms后完成'默认'

实际上只有 38 ms

的一半

总差异 23 ms

现在为什么会这样？老实说我还不太了解gulp，但是让我们说方法2显然更具可读性，可维护性，甚至是更快的选择。

只要您了解不直接在lazypipe()内调用流，它们都易于编写。

Answer 6

形成我的最好方式是：

task('task1', () => {
  // Buy potatoes
});

task('task2', ['task1'], () => {
  // Cut potatoes
});

任务2 的结果将是：买土豆和切土豆

Answer 7

有几种方法可以做到这一点：第一个：只为另一个调用新的任务调用：

gulp.task('foo', function() {
  gulp.task('caller', ['bar']); // <- this calls the other existing task!
}
gulp.task('bar', function() {
  //do something
}

第二个，更不干净的一个：Gulp是Javascript，所以你只需将一些指令设置为随机函数并调用它！

gulp.task('task', function() {
  recurrent_task();
}
gulp.task('task2', function() {
  recurrent_task();
}
function recurrent_task() {
  //do something
}

如何从另一个任务运行gulp任务？

7 个答案: