前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >co yield避免嵌套详细代码示例。

co yield避免嵌套详细代码示例。

作者头像
申君健
发布2018-09-21 15:31:45
1.2K0
发布2018-09-21 15:31:45
举报
文章被收录于专栏:前端侠2.0
代码语言:javascript
复制
/**
 * co & yield 培训例程. TJ's co test, 参考和下载: https://github.com/visionmedia/co
 * 运行环境: 安装 nodejs v0.11.2以上版本, 推荐IDE: Jetbrains WebStorm 8.0
 * 依赖的包: 请先 npm install -g co thunkify request //全局化安装,
 * 再到本js所在目录下 npm link co thunkify request 引用这些全局安装模块
 * 执行: node --harmony co.js ,必须带上--harmony参数才支持 ES6特性
 * WebStorm 调试: 在Run/Debug Configuration -> Node parameters 中添加 --harmony
 * 学习方法: 在WebStorm的Debugger中, 设置断点, 单步执行. 这样就能清楚看到yield执行顺序
 * Created with WebStorm.
 * User: JimmyCHEN(290958374@qq.com)
 * Created: 2014/1/24 8:17
 * Modified: 2014/2/2 11:20
 * 中文说明编写: 2014/7/7 13:40
 */
var assert = require('assert');
var co = require('co');
var fs = require('fs');
// co 是利用Generator和yield原理编写的一个包, 具有运行类似于“协程”的功能。利用co 和 yield 编写和执行异步操作, 可以完全摆脱nodejs的回调深坑,
// 大幅提高代码舒适度和团队生产力. 因此,co是深受回调深坑困然的nodejs码农们的不二选择!
// 对于现有的传统回调式的异步函数(如fs.readFile, http.request等),需要将其封装(转换)成为可以yield的函数(该函数称为“转换器”), 供yield调用
// 一个转换器的格式一般是这样的:
function read(file, encoding) { //这个转换器只返回一个调用fs.readFile的符合yield要求的函数, 而不是执行fs.readFile
    encoding = encoding || 'utf-8';
    return function(callback) { //转换器返回的是一个函数, 其参数必须是被异步函数(fs.readFile)回调的callback. 转换器本身不执行fs.readFile
        fs.readFile(file, encoding, callback);//callback的参数是 (err, result), 这里的 `result` 最终将被作为yield read()的返回值.
    }
}
//*上述 function 等价于 var read = thunkify(fs.readFile); //如果采用现成的thunkify模块的话, 就不用自己写上面那样的转换器函数了, 省事! (留作后文介绍)
//API-1: co(fn)
//异步函数经过上述转换以后, 就可以在co里用yield去执行. 执行yield化的异步函数, 就如执行同步函数一样简单舒适, 再也没有回调深坑的烦恼. 我和我的小伙伴都惊呆了! 请看大屏幕:
co(function* () { //被 co 的函数必须是个生成器(generator), 用 function* 定义
    var a = yield read('.dbshell'); //异步读文件1, 内容返回给 a. 在内容没读到前, yield将退出函数的执行, 下一句(var b =...)不会被执行.
    // 直到 a 得到返回内容, 才接着执行下一句. 实际上, 返回值是被fs.readFile中的callback返回, 然后触发(唤醒)yield 并赋值给a
    //  *请根据实际目录内容修改文件名称, 下同
    var b = yield read('config.json');  //异步读文件2, 内容返回给 b
    var c = yield read('note.txt');     //异步读文件3, 内容返回给 c
    //三个 read 被顺序依次执行, 最后得到三个值 a,b,c
    console.log([a, b, c]);   // => [5171, 2090, 1477]
})();

//=========================================================================================================//
//co & yield化后的错误处理: 用try..catch
co(function* () { //被 co 的函数必须是个生成器(generator), 用 function* 定义
    var a = yield read('.dbshell'); //异步读文件1, 内容返回给 a
    var b = yield read('config.json');  //异步读文件2, 内容返回给 b
    var c = yield read('note.txt');  //异步读文件2, 内容返回给 c
    //上面三个 read 被顺序依次执行, 最后得到三个值 a,b,c
    //错误处理
    try {
        var d = yield read('not exists.txt');     //文件不存在, 用于产生错误
    } catch (e) {
        console.log(e); // => 输出: 文件不存在的错误
    }

    console.log([a, b, c]);   // => [5171, 2090, 1477]
})();
//=========================================================================================================//
//你也可以 yield 执行一个 generator 对象, 以支持嵌套:
//用于读取文件大小的转换器
function size(file) {
    return function(callback){
        fs.stat(file,function(err, result){
            if(err) return callback(err);
            callback(null, result.size);    //异步执行结束后将返回result.size给yield
        });
    }
}
function* foo(){
    var a = yield size('.dbshell');
    var b = yield size('config.json');
    var c = yield size('note.txt');
    //debugger;
    return [a, b, c]; // => [ 994, 187, 16212 ]
}
function* bar(){
    var a = yield size('test/co.js');
    var b = yield size('test/test.js');
    var c = yield size('test/class.js');
    //debugger;
    return [a, b, c]; // => [ 9023, 2090, 1477 ]
}
co(function*(){
    var results = yield [foo(), bar()];//yield 一个数组对象. //也可以按下面的例子写成 [foo, bar]
    //debugger;
    console.log(results);// => [ [ 994, 187, 16212 ], [ 9023, 2090, 1477 ] ]
})();

//=========================================================================================================//
//对于那么多传统回调式异步函数, 都去手工编写一个转换函数是不是太麻烦了? 别担心, 我们有tunkify. 顾名思义, 它就是现成的转换器函数:
var thunkify = require('thunkify');
var request = require('request');   //用于http.request的包

//转换器:thunkify, 将传统的回调式的函数,转换成可yield的函数
//转换request.get函数
var get = thunkify(request.get); //request.get = function (uri, options, callback), where callback = function (err, response, body)

function* results(){
    var a = get('http://www.baidu.com');//这里只是得到函数,不会发起请求
    var b = get('http://www.163.com');  //用yield 执行 get才会返回http.get的callback里的返回内容
    var c = get('http://www.126.com');
    return yield [a, b, c];//这里才真正发起http.get请求, 而且是同时发起3次并发请求. 用yield [数组], 将“并发执行”数组中的所有操作
}
co(function*(){//再次强调, co里的函数必须是生成器!
    var a = yield results; // 每条yield []将发起3次并发执行
    var b = yield results; //两条 yield 则是顺序执行
    console.log(a, b); // => [三个网页内容] , [三个网页内容]
    var c = yield [results, results];//这里将产生6个并发http操作!
    console.log(c);// => 输出: [[三个网页内容],[三个网页内容]]
})();

//=========================================================================================================//
//并发 yield: 逗号表达式中的所有yield将被并发执行.
co(function*(){
    var a = size('test/test.js');
    var b = size('test/class.js');
    var c = size('test/class2.js');
    //debugger;
    return [yield a, yield b, yield c];
})();

//=========================================================================================================//
//下面演示如何取得多个返回值(只要将第2个值附加到第1值上即可) , 例: callback(err, response, body) 中的body值
var get2 = function(uri) {
    return function(callback){
        request.get(uri, function(err, response, body) {
            if(err) return callback(err);
            if(typeof body == 'object') {//若是json,则附加到response上用于yield返回值
                response.bodyObject = body;//*这里只是为了演示需要! 实际上若request.get参数里指定json:true,则response.body 本身就是json了,不必另行附加body
            }
            callback(null, response); //返回response
        });
    }
}
function* results2(){
    var a = get2({url:'http://market.huobi.com/staticmarket/ticker_ltc_json.js',json:false});//这里只得到函数,不会发起请求
    var b = get2({url:'http://market.huobi.com/staticmarket/ticker_btc_json.js',json:true});//yield get才会返回callback里的response
    var c = get2({url:'http://market.huobi.com/staticmarket/depth_ltc_json.js',json:true});//callback(err, response,body)中的body将作为response.bodyObject返回
    return yield [a, b, c];//这里才发起请求, 而且是3次并发请求(yield数组对象)
}
co(function*(){
    // 3 concurrent requests at a time
    var a = yield results2; //3个并发get
    var b = yield results2; //3个并发get
    console.log(a, b);      //输出:[三个网页内容], [三个网页内容]
    assert.equal(typeof a[0].body, 'string', 'Error: a[0].body is not a string');//equal:(value, expected, errorMessage)
    assert.equal(typeof a[0].bodyObject, 'undefined', 'Error: a[0].bodyObject is not undefined');
    assert.equal(typeof b[1].bodyObject, 'object', 'Error: b[1].bodyObject is not an Object');
    var c = yield [results2, results2];//6 个并发get!
    console.log(c);//输出:[[三个网页内容], [三个网页内容]]
})();

//=========================================================================================================//
//数组: yield 数组
//yield执行数组, 数组里的所有步骤都是并发操作. 最后所有返回值组成一个数组.
co(function* yieldArray(){  //!再次强调: co里必须是个generator, 用 function* 定义
    var a = size('test/co.js');
    var b = size('test/test.js');
    var c = size('test/class.js');
    //debugger;
    var res = yield[a, b, c];
    console.log(res);    // => [5171, 2090, 1477]
})();

//嵌套数组: 数组里面还可以嵌套数组. 下面代码, 执行时相当于并发执行6个操作:
co(function *() {
    var a = [
        get('http://sina.com'),
        get('http://baidu.com'),
        get('http://163.com')
    ];
    var b = [
        get('http://sina.com'),
        get('http://yahoo.com'),
        get('http://ign.com')
    ];
    console.log(yield [a, b]);  // 数组里嵌套数组, 将并发执行6个http.get!
})();

//对象: yield object, 类似数组, 不过还支持递归
co(function* yieldObject(){
    var user = yield { //yield在 object 外面, 则 object 内部的转换器将并发执行
        name: {
            first: get('http://www.iciba.com/first'),   //这里 object 里层只是转换器, 没有yield
            last: get('http://www.iciba.com/last')      // 因此这两个get也是并发执行
        }
    };  //最终合成 user object = {name: {first: "网页内容1", last: "网页内容2"}}
    console.log(user); // => {"name": {"first": "网页内容1", "last": "网页内容2"}}
})();
//如果对象内属性值里用yield, 则每个yield是顺序执行(非并发):
co(function *(){
    var user = {
        name: {
            first: yield  get('http://www.iciba.com/first'), //这里 object 里的属性值通过 yield 获取
            last: yield get('http://www.iciba.com/last')     // 因此这两个get 是顺序执行(非并发)
        }
    };
    console.log(user); // => {"name": {"first": "网页内容1", "last": "网页内容2"}}
})();

//性能: TJ的测试结果
//在我本机上顺序执行 30,000 次 stat() 操作平均耗时 570ms, 而用 co() 执行同样次数的 stat() 平均耗时 610ms,
//也就是说, yield 带来的损耗几乎可以忽略不计.

//类(Class)里的 generator & yield
//定义类的构造函数
function Class () {
    this.name = 'Class';
}
//定义类的类的成员函数 generator
Class.prototype.generator = function*(){
    var user = yield {  //yield 一个对象
        name: {
            first: get('http://www.iciba.com/first'),
            last: get('http://www.iciba.com/last')
        }
    };
    console.log(user);  // => {"name": {"first": "网页内容1", "last": "网页内容2"}}
    console.log('Class.run() end.')
};

//定义一个函数用于执行
Class.prototype.run = function() {
    co(this.generator)();   //用 co() 去执行
}
//创建类的实例
var obj = new Class();
//运行
obj.run();  // => {"name": {"first": "网页内容1", "last": "网页内容2"}}
本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2014/07/16 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档