上篇文章我们分别对 gulp 的 .src 和 .dest 两个主要接口做了分析，今天打算把剩下的面纱一起揭开 —— 解析 gulp.task 的源码，了解在 gulp4.0 中是如何管理、处理任务的。
在先前的版本，gulp 使用了 orchestrator 模块来指挥、排序任务，但到了 4.0 则替换为 undertaker 来做统一管理。先前的一些 task 写法会有所改变：
///////旧版写法 gulp.task('uglify', function(){ return gulp.src(['src/*.js']) .pipe(uglify()) .pipe(gulp.dest('dist')); }); gulp.task('default', ['uglify']); ///////新版写法1 gulp.task('uglify', function(){ return gulp.src(['src/*.js']) .pipe(uglify()) .pipe(gulp.dest('dist')); }); gulp.task('default', gulp.parallel('uglify')); ///////新版写法2 function uglify(){ return gulp.src(['src/*.js']) .pipe(uglify()) .pipe(gulp.dest('dist')); } gulp.task(uglify); gulp.task('default', gulp.parallel(uglify));
更多变化点，可以参考官方 changelog，或者在后文我们也将透过源码来介绍各 task API 用法。
从 gulp 的入口文件来看，任务相关的接口都是从 undertaker 继承：
var util = require('util'); var Undertaker = require('undertaker');function Gulp() { Undertaker.call(this); this.task = this.task.bind(this); this.series = this.series.bind(this); this.parallel = this.parallel.bind(this); this.registry = this.registry.bind(this); this.tree = this.tree.bind(this); this.lastRun = this.lastRun.bind(this); } util.inherits(Gulp, Undertaker);
接着看 undertaker 的入口文件，发现其代码粒化的很好，每个接口都是单独一个模块：
'use strict'; var inherits = require('util').inherits; var EventEmitter = require('events').EventEmitter; var DefaultRegistry = require('undertaker-registry'); var tree = require('./lib/tree'); var task = require('./lib/task'); var series = require('./lib/series'); var lastRun = require('./lib/last-run'); var parallel = require('./lib/parallel'); var registry = require('./lib/registry'); var _getTask = require('./lib/get-task'); var _setTask = require('./lib/set-task'); function Undertaker(customRegistry) { EventEmitter.call(this); this._registry = new DefaultRegistry(); if (customRegistry) { this.registry(customRegistry); } this._settle = (process.env.UNDERTAKER_SETTLE === 'true'); } inherits(Undertaker, EventEmitter); Undertaker.prototype.tree = tree; Undertaker.prototype.task = task; Undertaker.prototype.series = series; Undertaker.prototype.lastRun = lastRun; Undertaker.prototype.parallel = parallel; Undertaker.prototype.registry = registry; Undertaker.prototype._getTask = _getTask; Undertaker.prototype._setTask = _setTask; module.exports = Undertaker;
我们先从构造函数入手，可以知道 undertaker 其实是作为事件触发器（EventEmitter）的子类：
function Undertaker(customRegistry) { EventEmitter.call(this); //super() this._registry = new DefaultRegistry(); if (customRegistry) { this.registry(customRegistry); } this._settle = (process.env.UNDERTAKER_SETTLE === 'true'); } inherits(Undertaker, EventEmitter); //继承 EventEmitter
这意味着你可以在它的实例上做事件绑定（.on）和事件触发（.emit）处理。
另外在构造函数中，定义了一个内部属性 _registry 作为寄存器（注册/寄存器模式的实现，提供统一接口来存储和读取 tasks）：
this._registry = new DefaultRegistry(); //undertaker-registry模块 if (customRegistry) { //支持自定义寄存器 this.registry(customRegistry); }
寄存器默认为 undertaker-registry 模块的实例，我们后续可以通过其对应接口来存储和获取任务：
// 存储任务（名称+任务方法） this._registry.set(taskName, taskFunction); // 通过任务名称获取对应任务方法 this._registry.get(taskName); // 获取存储的全部任务 this._registry.task(); // { taskA : function(){...}, taskB : function(){...} }
undertaker-registry 的源码也简略易懂：
function DefaultRegistry() { //对外免 new 处理 if (this instanceof DefaultRegistry === false) { return new DefaultRegistry(); } //初始化任务对象，用于存储任务 this._tasks = {}; } // 初始化方法（仅做占位使用） DefaultRegistry.prototype.init = function init(taker) {}; //返回指定任务方法 DefaultRegistry.prototype.get = function get(name) { return this._tasks[name]; }; //保存任务 DefaultRegistry.prototype.set = function set(name, fn) { return this._tasks[name] = fn; }; //获取任务对象 DefaultRegistry.prototype.tasks = function tasks() { var self = this; //克隆 this._tasks 对象，避免外部修改会对其有影响 return Object.keys(this._tasks).reduce(function(tasks, name) { tasks[name] = self.get(name); return tasks; }, {}); }; module.exports = DefaultRegistry;
虽然 undertaker 默认使用了 undertaker-registry 模块来做寄存器，但也允许使用自定义的接口去实现：
function Undertaker(customRegistry) { //支持传入自定义寄存器接口 EventEmitter.call(this); this._registry = new DefaultRegistry(); if (customRegistry) { //支持自定义寄存器 this.registry(customRegistry); } }
此处的 this.registry 接口提供自 lib/registry 模块:
function setTasks(inst, task, name) { inst.set(name, task); return inst; } function registry(newRegistry) { if (!newRegistry) { return this._registry; } //验证是否有效，主要判断是否带有 .get/.set/.tasks/.init 接口，若不符合则抛出错误 validateRegistry(newRegistry); var tasks = this._registry.tasks(); //将现有 tasks 拷贝到新的寄存器上 this._registry = reduce(tasks, setTasks, newRegistry); //调用初始化接口（无论是否需要，寄存器务必带有一个init接口） this._registry.init(this); } module.exports = registry;
接着看剩余的接口定义：
Undertaker.prototype.tree = tree; Undertaker.prototype.task = task; Undertaker.prototype.series = series; Undertaker.prototype.lastRun = lastRun; Undertaker.prototype.parallel = parallel; Undertaker.prototype.registry = registry; Undertaker.prototype._getTask = _getTask; Undertaker.prototype._setTask = _setTask;
其中 registry 是直接引用的 lib/registry 模块接口，在前面已经介绍过了，我们分别看看剩余的接口（它们均存放在 lib 文件夹下）。
1. this.task
为最常用的 gulp.task 接口提供功能实现，但本模块的代码量很少：
function task(name, fn) { if (typeof name === 'function') { fn = name; name = fn.displayName || fn.name; } if (!fn) { return this._getTask(name); } //存储task this._setTask(name, fn); } module.exports = task;
其中第一段 if 代码块是为了兼容如下写法：
function uglify(){ return gulp.src(['src/*.js']) .pipe(uglify()) .pipe(gulp.dest('dist')); } gulp.task(uglify); gulp.task('default', gulp.parallel(uglify));
第二段 if 是对传入的 fn 做判断，为空则直接返回 name（任务名称）对应的 taskFunction。即用户可以通过 gulp.task(taskname) 来获取任务方法。
此处的 _getTask 接口不外乎是对 this._registry.get 的简单封装。
2. this._setTask
名称加了下划线的一般都表示该接口只在内部使用，API 中不会对外暴露。而该接口虽然可以直观了解为存储 task，但它其实做了更多事情：
var assert = require('assert'); var metadata = require('./helpers/metadata'); function set(name, fn) { //参数类型判断，不合法则报错 assert(name, 'Task name must be specified'); assert(typeof name === 'string', 'Task name must be a string'); assert(typeof fn === 'function', 'Task function must be specified'); //weakmap 里要求 key 对象不能被引用过，所以有必要给 fn 多加一层简单包装 function taskWrapper() { return fn.apply(this, arguments); } //解除包装 function unwrap() { return fn; } taskWrapper.unwrap = unwrap; taskWrapper.displayName = name; // 依赖 parallel/series 的 taskFunction 会先被设置过 metadata，其 branch 属性会指向 parallel/series tasks var meta = metadata.get(fn) || {}; var nodes = []; if (meta.branch) { nodes.push(meta.tree); } // this._registry.set 接口最后会返回 taskWrapper var task = this._registry.set(name, taskWrapper) || taskWrapper; //设置任务的 metadata metadata.set(task, { name: name, orig: fn, tree: { label: name, type: 'task', nodes: nodes } }); } module.exports = set;
这里的 helpers/metadata 模块其实是借用了 WeakMap 的能力，来把一个外部无引用的 taskFunction 对象作为 map 的 key 进行存储，存储的 value 值是一个 metadata 对象。
metadata 对象是用于描述 task 的具体信息，包括名称（name）、原始方法（orig）、依赖的任务节点（tree.nodes）等，后续我们即可以通过 metadata.get(task) 来获取指定 task 的相关信息（特别是任务依赖关系）了。
3. this.parallel
并行任务接口，可以输入一个或多个 task：
var undertaker = require('undertaker'); ut = new undertaker(); ut.task('taskA', function(){/*略*/}); ut.task('taskB', function(){/*略*/}); ut.task('taskC', function(){/*略*/}); ut.task('taskD', function(){/*略*/}); // taskD 需要在 'taskA', 'taskB', 'taskC' 执行完毕后才开始执行， // 其中 'taskA', 'taskB', 'taskC' 的执行是异步的 ut.task('taskD', ut.parallel('taskA', 'taskB', 'taskC'));
该接口会返回一个带有依赖关系 metadata 的 parallelFunction 供外层 task 接口注册任务：
var bach = require('bach'); var metadata = require('./helpers/metadata'); var buildTree = require('./helpers/buildTree'); var normalizeArgs = require('./helpers/normalizeArgs'); var createExtensions = require('./helpers/createExtensions'); //并行任务接口 function parallel() { var create = this._settle ? bach.settleParallel : bach.parallel; //通过参数获取存在寄存器（registry）中的 taskFunctions（数组形式） var args = normalizeArgs(this._registry, arguments); //新增一个扩展对象，用于后续给 taskFunction 加上生命周期 var extensions = createExtensions(this); //将 taskFunctions 里的每一个 taskFunction 加上生命周期，且异步化 var fn = create(args, extensions); fn.displayName = ''; //设置初步 metadata，方便外层 this.task 接口获取依赖关系 metadata.set(fn, { name: fn.displayName, branch: true, //表示当前 task 是被依赖的（parallel）任务 tree: { label: fn.displayName, type: 'function', branch: true, nodes: buildTree(args) //返回每个 task metadata.tree 的集合（数组） } }); //返回 parallel taskFunction 供外层 this.task 接口注册任务 return fn; } module.exports = parallel;
这里有两个最重要的地方需要具体分析下：
//新增一个扩展对象，用于后续给 taskFunction 加上生命周期回调 var extensions = createExtensions(this); //将 taskFunctions 里的每一个 taskFunction 加上生命周期回调，且异步化taskFunction，安排它们并发执行（调用fn的时候） var fn = create(args, extensions);
我们先看下 createExtensions 接口：
var uid = 0; function Storage(fn) { var meta = metadata.get(fn); this.fn = meta.orig || fn; this.uid = uid++; this.name = meta.name; this.branch = meta.branch || false; this.captureTime = Date.now(); this.startHr = []; } Storage.prototype.capture = function() { //新建一个名为runtimes的WeakMap，执行 runtimes.set(fn, captureTime); captureLastRun(this.fn, this.captureTime); }; Storage.prototype.release = function() { //从WM中释放，即执行 runtimes.delete(fn); releaseLastRun(this.fn); }; function createExtensions(ee) { return { create: function(fn) { //创建 //返回一个 Storage 实例 return new Storage(fn); }, before: function(storage) { //执行前 storage.startHr = process.hrtime(); //别忘了 undertaker 实例是一个 EventEmitter ee.emit('start', { uid: storage.uid, name: storage.name, branch: storage.branch, time: Date.now(), }); }, after: function(result, storage) { //执行后 if (result && result.state === 'error') { return this.error(result.value, storage); } storage.capture(); ee.emit('stop', { uid: storage.uid, name: storage.name, branch: storage.branch, duration: process.hrtime(storage.startHr), time: Date.now(), }); }, error: function(error, storage) { //出错 if (Array.isArray(error)) { error = error[0]; } storage.release(); ee.emit('error', { uid: storage.uid, name: storage.name, branch: storage.branch, error: error, duration: process.hrtime(storage.startHr), time: Date.now(), }); }, }; } module.exports = createExtensions;
故 extensions 变量获得了这样的一个对象：
{ create: function (fn) { //创建 return new Storage(fn); }, before: function (storage) { //执行前 storage.startHr = process.hrtime(); ee.emit('start', metadata); }, after: function (result, storage) { //执行后 if (result && result.state === 'error') { return this.error(result.value, storage); } storage.capture(); ee.emit('stop', metadata); }, error: function (error, storage) { //出错 if (Array.isArray(error)) { error = error[0]; } storage.release(); ee.emit('error', metadata); } }
如果我们能把它们跟每个任务的创建、执行、错误处理过程关联起来，例如在任务执行之前就调用 extensions.after(curTaskStorage)，那么就可以把扩展对象 extensions 的属性方法作为任务各生命周期环节对应的回调了。
做这一步关联处理的，是这一行代码：
var fn = create(args, extensions);
其中“create”引用自 bach/lib/parallel 模块，除了将扩展对象和任务关联之外，它还利用 async-done 模块将每个 taskFunction 异步化，且安排它们并行执行：
'use strict'; //获取数组除最后一个元素之外的所有元素，这里用来获取第一个参数（tasks数组） var initial = require('lodash.initial'); //获取数组的最后一个元素，这里用来获取最后一个参数（extension对象） var last = require('lodash.last'); //将引入的函数异步化 var asyncDone = require('async-done'); var nowAndLater = require('now-and-later'); var helpers = require('./helpers'); function buildParallel() { var args = helpers.verifyArguments(arguments); //验证传入参数合法性 var extensions = helpers.getExtensions(last(args)); //extension对象 if (extensions) { args = initial(args); //tasks数组 } function parallel(done) { //遍历tasks数组，将其生命周期和extensions属性关联起来,且将每个task异步化，且并发执行 nowAndLater.map(args, asyncDone, extensions, done); } return parallel; } module.exports = buildParallel;
首先介绍下 async-done 模块，它可以把一个普通函数（传入的第一个参数）异步化：
//demo1 var ad = require('async-done'); ad(function(cb){ console.log('first task starts!'); cb(null, 'first task done!') }, function(err, data){ console.log(data) }); ad(function(cb){ console.log('second task starts!'); setTimeout( cb.bind(this, null, 'second task done!'), 1000 ) }, function(err, data){ console.log(data) }); ad(function(cb){ console.log('third task starts!'); cb(null, 'third task done!') }, function(err, data){ console.log(data) });
执行结果：
那么很明显，undertaker（或 bach） 最终是利用 async-done 来让传入 this.parallel 接口的任务能够异步去执行（互不影响、互不依赖）：
我们接着回过头看下 bach/lib/parallel 里最重要的部分：
function buildParallel() { //略 function parallel(done) { //遍历tasks数组，将其生命周期和extensions属性关联起来,且将每个task异步化，且并发执行 nowAndLater.map(args, asyncDone, extensions, done); } return parallel; } module.exports = buildParallel;
nowAndLater 即 now-and-later 模块，其 .map 接口如下：
var once = require('once'); var helpers = require('./helpers'); function map(values, iterator, extensions, done) { if (typeof extensions === 'function') { done = extensions; extensions = {}; } if (typeof done !== 'function') { done = helpers.noop; //没有传入done则赋予一个空函数 } //让 done 函数只执行一次 done = once(done); var keys = Object.keys(values); var length = keys.length; var count = length; var idx = 0; // 初始化一个空的、和values等长的数组 var results = helpers.initializeResults(values); /** * helpers.defaultExtensions(extensions) 返回如下对象： * { create: extensions.create || defaultExts.create, before: extensions.before || defaultExts.before, after: extensions.after || defaultExts.after, error: extensions.error || defaultExts.error, } */ var exts = helpers.defaultExtensions(extensions); for (idx = 0; idx < length; idx++) { var key = keys[idx]; next(key); } function next(key) { var value = values[key]; //创建一个 Storage 实例 var storage = exts.create(value, key) || {}; //触发'start'事件 exts.before(storage); //利用 async-done 将 taskFunction 转为异步方法并执行 iterator(value, once(handler)); function handler(err, result) { if (err) { //触发'error'事件 exts.error(err, storage); return done(err, results); } //触发'stop'事件 exts.after(result, storage); results[key] = result; if (--count === 0) { done(err, results); } } } } module.exports = map;
在这段代码的 map 方法中，通过 for 循环遍历了每个传入 parallel 接口的 taskFunction，然后使用 iterator（async-done）将 taskFunction 异步化并执行（执行完毕会触发 hadler），并将 extensions 的各方法和 task 的生命周期关联起来（比如在任务开始时执行“start”事件、任务出错时执行“error”事件）。
这里还需留意一个点。我们回头看 async-done 的示例代码：
ad(function(cb){ //留意这里的cb console.log('first task starts!'); cb(null, 'first task done!') //执行cb表示当前方法已结束，可以执行回调了 }, function(err, data){ console.log(data) });
async-done 支持要异步化的函数，通过执行传入的回调来通知 async-done 当前方法可以结束并执行回调了：
gulp.task('TaskAfter', function(){
//略
});
gulp.task('uglify', function(){
return gulp.src(['src/*.js'])
.pipe(uglify())
.pipe(gulp.dest('dist'));
});
gulp.task('doSth', function(cb){
setTimeout(() => {
console.log('最快也得5秒左右才给执行任务TaskAfter');
cb(); //表示任务 doSth 执行完毕，任务 TaskAfter 可以不用等它了
}, 5000)
});
gulp.task('TaskAfter', gulp.parallel('uglify', 'doSth'));
所以问题来了 —— 每次定义任务时，都需要传入这个回调参数吗？即使传入了，要在哪里调用呢？
其实大部分情况，都是无须传入回调参数的。因为咱们常规定义的 gulp 任务都是基于流，而在 async-done 中有对流（或者Promise对象等）的消耗做了监听（消耗完毕时自动触发回调）：
function asyncDone(fn, cb) { cb = once(cb); var d = domain.create(); d.once('error', onError); var domainBoundFn = d.bind(fn); function done() { d.removeListener('error', onError); d.exit(); //执行 cb return cb.apply(null, arguments); } function onSuccess(result) { return done(null, result); } function onError(error) { return done(error); } function asyncRunner() { var result = domainBoundFn(done); function onNext(state) { onNext.state = state; } function onCompleted() { return onSuccess(onNext.state); } if (result && typeof result.on === 'function') { // result 为 Stream 时 d.add(result); //消耗完毕了自动触发 done eos(exhaust(result), eosConfig, done); return; } if (result && typeof result.subscribe === 'function') { // result 为 RxJS observable 时的处理 result.subscribe(onNext, onError, onCompleted); return; } if (result && typeof result.then === 'function') { // result 为 Promise 对象时的处理 result.then(onSuccess, onError); return; } } tick(asyncRunner); }
这也是为何我们在定义任务的时候，都会建议在 gulp.src 前面加上一个“return”的原因：
gulp.task('uglify', function(){
return gulp.src(['src/*.js']) //留意这里的return
.pipe(uglify())
.pipe(gulp.dest('dist'));
});
另外还有一个遗留问题 —— bach/parallel 模块中返回函数里的“done”参数是做啥的呢：
function parallel(done) { //留意这里的 done 参数 nowAndLater.map(args, asyncDone, extensions, done); }
我们先看 now-and-later.map 里是怎么处理 done 的：
iterator(value, once(handler)); function handler(err, result) { if (err) { //触发'error'事件 exts.error(err, storage); return done(err, results); //有任务出错，故所有任务应停止调用 } //触发'stop'事件 exts.after(result, storage); results[key] = result; if (--count === 0) { done(err, results); //所有任务已经调用完毕 } }
可以看出这个 done 不外乎是所有传入任务执行完毕以后会被调用的方法，那么它自然可以适应下面的场景了：
gulp.task('taskA', function(){/*略*/});
gulp.task('taskB', function(){/*略*/});
gulp.task('taskC', gulp.parallel('taskA', 'taskB'));
gulp.task('taskD', function(){/*略*/});
gulp.task('taskE', gulp.parallel('taskC', 'taskD')); //留意'taskC'本身也是一个parallelTask
即 taskC 里的“done”将在定义 taskE 的时候，作为通知 async-done 自身已经执行完毕了的回调方法。
4. this.series
串行任务接口，可以输入一个或多个 task：
ut.task('taskA', function(){/*略*/});
ut.task('taskB', function(){/*略*/});
ut.task('taskC', function(){/*略*/});
ut.task('taskD', function(){/*略*/});
// taskD 需要在 'taskA', 'taskB', 'taskC' 执行完毕后才开始执行，
// 其中 'taskA', 'taskB', 'taskC' 的执行必须是按顺序一个接一个的
ut.task('taskD', ut.series('taskA', 'taskB', 'taskC'));
series 接口的实现和 parallel 接口的基本是一致的，不一样的地方只是在执行顺序上的调整。
在 parallel 的代码中，是使用了 now-and-later 的 map 接口来处理传入的任务执行顺序；而在 series 中，使用的则是 now-and-later 的 mapSeries 接口：
next(key); function next(key) { var value = values[key]; var storage = exts.create(value, key) || {}; exts.before(storage); iterator(value, once(handler)); function handler(err, result) { if (err) { exts.error(err, storage); return done(err, results); //有任务出错，故所有任务应停止调用 } exts.after(result, storage); results[key] = result; if (++idx >= length) { done(err, results); //全部任务已经结束了 } else { next(keys[idx]); //next不在是放在外面的循环里，而是在任务的回调里 } } }
通过改动 next 的位置，可以很好地要求传入的任务必须一个接一个去执行（后一个任务在前一个任务执行完毕的回调里才会开始执行）。
5. this.lastRun
这是一个工具方法（有点鸡肋），用来记录和获取针对某个方法的执行前/后时间（如“1426000001111”）：
var lastRun = require('last-run'); function myFunc(){} myFunc(); // 记录函数执行的时间点（当然你也可以放到“myFunc();”前面去） lastRun.capture(myFunc); // 获取记录的时间点 lastRun(myFunc);
底层所使用的是 last-run 模块，代码太简单，就不赘述了：
var assert = require('assert'); var WM = require('es6-weak-map'); var hasNativeWeakMap = require('es6-weak-map/is-native-implemented'); var defaultResolution = require('default-resolution'); var runtimes = new WM(); function isFunction(fn) { return (typeof fn === 'function'); } function isExtensible(fn) { if (hasNativeWeakMap) { // 支持原生 weakmap 直接返回 return true; } //平台不支持 weakmap 的话则要求 fn 是可扩展属性的对象，以确保还是能支持 es6-weak-map return Object.isExtensible(fn); } //timeResolution参数用于决定返回的时间戳后几位数字要置0 function lastRun(fn, timeResolution) { assert(isFunction(fn), 'Only functions can check lastRun'); assert(isExtensible(fn), 'Only extensible functions can check lastRun'); //先获取捕获时间 var time = runtimes.get(fn); if (time == null) { return; } //defaultResolution接口 - timeResolution格式处理（转十进制整数） var resolution = defaultResolution(timeResolution); //减去(time % resolution)的作用是将后n位置0 return time - (time % resolution); } function capture(fn, timestamp) { assert(isFunction(fn), 'Only functions can be captured'); assert(isExtensible(fn), 'Only extensible functions can be captured'); timestamp = timestamp || Date.now(); //（在任务执行的时候）存储捕获时间信息 runtimes.set(fn, timestamp); } function release(fn) { assert(isFunction(fn), 'Only functions can be captured'); assert(isExtensible(fn), 'Only extensible functions can be captured'); runtimes.delete(fn); } //绑定静态方法 lastRun.capture = capture; lastRun.release = release; module.exports = lastRun;
6. this.tree
这是看起来不起眼（我们常规不需要手动调用到），但是又非常重要的一个接口 —— 它可以获取当前注册过的所有的任务的 metadata：
var undertaker = require('undertaker'); ut = new undertaker(); ut.task('taskA', function(cb){console.log('A'); cb()}); ut.task('taskB', function(cb){console.log('B'); cb()}); ut.task('taskC', function(cb){console.log('C'); cb()}); ut.task('taskD', function(cb){console.log('D'); cb()}); ut.task('taskE', function(cb){console.log('E'); cb()}); ut.task('taskC', ut.series('taskA', 'taskB')); ut.task('taskE', ut.parallel('taskC', 'taskD')); var tree = ut.tree(); console.log(tree);
执行结果：
那么通过这个接口，gulp-cli 就很容易知道我们都定义了哪些任务、任务对应的方法是什么、任务之间的依赖关系是什么（因为 metadata 里的“nodes”属性表示了关系链）。。。从而合理地为我们安排任务的执行顺序。
其实现也的确很简单，我们看下 lib/tree 的源码：
var defaults = require('lodash.defaults'); var map = require('lodash.map'); var metadata = require('./helpers/metadata'); function tree(opts) { opts = defaults(opts || {}, { deep: false, }); var tasks = this._registry.tasks(); //获取所有存储的任务 var nodes = map(tasks, function(task) { //遍历并返回metadata数组 var meta = metadata.get(task); if (opts.deep) { //如果传入了 {deep: true}，则从 meta.tree 开始返回 return meta.tree; } return meta.tree.label; //从 meta.tree.label 开始返回 }); return { //返回Tasks对象 label: 'Tasks', nodes: nodes }; } module.exports = tree;
不外乎是遍历寄存器里的任务，然后取它们的 metadata 数据来返回，简单粗暴~
自此我们便对 gulp 是如何组织任务执行的原理有了一番了解，不得不说其核心模块 undertaker 还是有些复杂（或者说有点绕）的。
本文的注释和示例代码可以从我的仓库上获取，读者可自行下载调试。共勉~
