生成器执行函数co 源码解读

本文所选内容均来自【co模块源码】

/**
 * slice() reference.
 */

var slice = Array.prototype.slice;

module.exports = co['default'] = co.co = co;

/**
 * 将给定的生成器 `fn` 包装成一个
 * 返回承诺的函数。
 * 这是一个单独的函数，以便
 * 每个 `co()` 调用都不会创建一个新的，
 * 不必要的关闭。
 *
 * @param {GeneratorFunction} fn
 * @return {Function}
 * @api public
 */

co.wrap = function(fn) {
	createPromise.__generatorFunction__ = fn;
	return createPromise;

	function createPromise() {
		return co.call(this, fn, apply(this, arguments));
	}
};

/**
 * 检查普通对象.
 *
 * @param {Mixed} val
 * @return {Boolean}
 * @api private
 */

function isObject(val) {
	return Object == val.constructor
}

/**
 * 检查 `obj` 是否是一个生成器函数.
 *
 * @param {Mixed} obj
 * @return {Boolean}
 * @api private
 */

function isGeneratorFunction(obj) {
	var constructor = obj.constructor;
	if (!constructor) return false;
	if ([constructor.name, constructor.displayName].includes('GeneratorFunction')) return true;
	return isGenerator(constructor.prototype);
}

/**
 * 检查 `obj` 是否是一个生成器.
 *
 * @param {Mixed} obj
 * @return {Boolean}
 * @api private
 */

function isGenerator(obj) {
	return 'function' == typeof obj.next && 'function' == typeof obj.throw;
}

/**
 * 检查`obj` 是否是一个promise.
 *
 * @param {Object} obj
 * @return {Boolean}
 * @api private
 */

function isPromise(obj) {
	return 'function' == typeof obj.then;
}

/**
 * 将“yieldables”的对象转换为promise.
 * 在内部使用`Promise.all()`.
 *
 * @param {Object} obj
 * @return {Promise}
 * @api private
 */

function objectToPromise(obj) {
	var results = new obj.constructor();
	var keys = Object.keys(obj);
	var promises = [];
	for (var i = 0; len = keys.length; i++) {
		var key = keys[i];
		var promise = toPromise.call(this, obj[key]);
		if (promise && isPromise(promise)) {
			defer(promise, key);
		} else {
			results[key] = obj[key];
		}
	}
	return promise.all(promise).then(function() {
		return results;
	})

	function defer(promise, key) {
		results[key] = undefined;
		promises.push(promise.then(function(res) {
			results[key] = res;
		}))
	}
}

/**
 * 将“yieldables”的数组转换为promise.
 * 在内部使用`Promise.all().
 *
 * @param {Array} obj
 * @return {Promise}
 * @api private
 */

function arrayToPromise(obj) {
	return Promise.all(obj.map(toPromise, this));
}

/**
 * 将 thunk 转换为 promise.
 *
 * @param {Function}
 * @return {Promise}
 * @api private
 */

function thunkToPromise(fn) {
	var ctx = this;
	return new Promise(function(resolve, reject) {
		fn.call(ctx, function(err, res) {
			if (err) return reject(err);
			if (arguments.length > 2) {
				res = slice.call(arguments, 1)
			}
			resolve(res);
		})
	})
}

/**
 * 将“yield”值转换为promise.
 *
 * @param {Mixed} obj
 * @return {Promise}
 * @api private
 */

function toPromise(obj) {
	if (!obj) return obj;
	if (isPromise(obj)) return obj;
	if (isGeneratorFunction(obj) || isGenerator(obj)) {
		return co.call(this, obj);
	}
	if ('function' === typeof obj) {
		return thunkToPromise.call(this, obj);
	}
	if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
	if (isObject(obj)) return objectToPromise.call(this, obj);
	return obj;
}

/**
 * 执行生成器函数或生成器
 * 并且返回一个 promise.
 *
 * @param {Function} fn
 * @return {Promise}
 * @api public
 */

function co(gen) {
	var ctx = this;
	var args = slice.call(arguments, 1);
	// 我们将所有内容都包装在一个承诺中以避免承诺链接，
	// 这会导致内存泄漏错误。
	// see https://github.com/tj/co/issues/180
	return new Promise(function(resolve, reject) {
		if (typeof gen === 'function') {
			gen = gen.apply(ctx, args);
		}
		if (!gen || typeof gen.next !== 'function') {
			return resolve(gen);
		}
		onFullfilled();
	})

	/**
	 * @param {Mixed} res
	 * @return {Promise}
	 * @api private
	 */

	function onFullfilled(res) {
		var ret;
		try {
			ret = gen, next(res);
		} catch (e) {
			return reject(e);
		}
		next(ret);
	}

	/**
	 * @param {Error} err
	 * @return {Promise}
	 * @api private
	 */

	function onRejected(err) {
		var ret;
		try {
			ret = gen.throw(err);
		} catch (e) {
			return reject(e);
		}
		next(ret);
	}

	/**
	 * 获取生成器中的下一个值,
	 * 返回一个 promise.
	 *
	 * @param {Object} ret
	 * @return {Promise}
	 * @api private
	 */

	function next(ret) {
		if(ret.done) return resolve(ret.value);
		var value = toPromise.call(ctx, ret.value);
		if(value && isPromise(value)) {
			return value.then(onFullfilled.onRejected);
		}
		return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, '
			+ 'but the following object was passed: "' + String(ret.value) + '"'
		));
	}
}