gulp創(chuàng)建任務（task）

每個 gulp 任務（task）都是一個異步的 JavaScript 函數，此函數是一個可以接收 callback 作為參數的函數，或者是一個返回 stream、promise、event emitter、child process 或 observable (后面會詳細講解) 類型值的函數。由于某些平臺的限制而不支持異步任務，因此 gulp 還提供了一個漂亮 替代品。

gulp導出任務

任務（tasks）可以是 public（公開） 或 private（私有） 類型的。

• 公開任務（Public tasks） 從 gulpfile 中被導出（export），可以通過 gulp 命令直接調用。
• 私有任務（Private tasks） 被設計為在內部使用，通常作為 series() 或 parallel() 組合的組成部分。

一個私有（private）類型的任務（task）在外觀和行為上和其他任務（task）是一樣的，但是不能夠被用戶直接調用。如需將一個任務（task）注冊為公開（public）類型的，只需從 gulpfile 中導出（export）即可。

const { series } = require('gulp');

// `clean` 函數并未被導出（export），因此被認為是私有任務（private task）。
// 它仍然可以被用在 `series()` 組合中。
function clean(cb) {
  // body omitted
  cb();
}

// `build` 函數被導出（export）了，因此它是一個公開任務（public task），并且可以被 `gulp` 命令直接調用。
// 它也仍然可以被用在 `series()` 組合中。
function build(cb) {
  // body omitted
  cb();
}

exports.build = build;
exports.default = series(clean, build);

在以前的 gulp 版本中，task() 方法用來將函數注冊為任務（task）。雖然這個 API 依舊是可以使用的，但是 導出（export）將會是主要的注冊機制，除非遇到 export 不起作用的情況。

gulp組合任務

Gulp 提供了兩個強大的組合方法： series() 和 parallel()，允許將多個獨立的任務組合為一個更大的操作。這兩個方法都可以接受任意數目的任務（task）函數或已經組合的操作。series() 和 parallel() 可以互相嵌套至任意深度。

如果需要讓任務（task）按順序執(zhí)行，請使用 series() 方法。

const { series } = require('gulp');

function transpile(cb) {
  // body omitted
  cb();
}

function bundle(cb) {
  // body omitted
  cb();
}

exports.build = series(transpile, bundle);

對于希望以最大并發(fā)來運行的任務（tasks），可以使用 parallel() 方法將它們組合起來。

const { parallel } = require('gulp');

function javascript(cb) {
  // body omitted
  cb();
}

function css(cb) {
  // body omitted
  cb();
}

exports.build = parallel(javascript, css);

當 series() 或 parallel() 被調用時，任務（tasks）被立即組合在一起。這就允許在組合中進行改變，而不需要在單個任務（task）中進行條件判斷。

const { series } = require('gulp');

function minify(cb) {
  // body omitted
  cb();
}


function transpile(cb) {
  // body omitted
  cb();
}

function livereload(cb) {
  // body omitted
  cb();
}

if (process.env.NODE_ENV === 'production') {
  exports.build = series(transpile, minify);
} else {
  exports.build = series(transpile, livereload);
}

series() 和 parallel() 可以被嵌套到任意深度。

const { series, parallel } = require('gulp');

function clean(cb) {
  // body omitted
  cb();
}

function cssTranspile(cb) {
  // body omitted
  cb();
}

function cssMinify(cb) {
  // body omitted
  cb();
}

function jsTranspile(cb) {
  // body omitted
  cb();
}

function jsBundle(cb) {
  // body omitted
  cb();
}

function jsMinify(cb) {
  // body omitted
  cb();
}

function publish(cb) {
  // body omitted
  cb();
}

exports.build = series(
  clean,
  parallel(
    cssTranspile,
    series(jsTranspile, jsBundle)
  ),
  parallel(cssMinify, jsMinify),
  publish
);

當一個組合操作執(zhí)行時，這個組合中的每一個任務每次被調用時都會被執(zhí)行。例如，在兩個不同的任務（task）之間調用的 clean 任務（task）將被執(zhí)行兩次，并且將導致不可預期的結果。因此，最好重構組合中的 clean 任務（task）。

如果你有如下代碼：

// This is INCORRECT
const { series, parallel } = require('gulp');

const clean = function(cb) {
  // body omitted
  cb();
};

const css = series(clean, function(cb) {
  // body omitted
  cb();
});

const javascript = series(clean, function(cb) {
  // body omitted
  cb();
});

exports.build = parallel(css, javascript);

重構為：

const { series, parallel } = require('gulp');

function clean(cb) {
  // body omitted
  cb();
}

function css(cb) {
  // body omitted
  cb();
}

function javascript(cb) {
  // body omitted
  cb();
}

exports.build = series(clean, parallel(css, javascript));