ES6__异步开发优化

一：JS事件循环

　　1：同步调用

　　　　同步调用是一种阻塞式调用，调用要等待双方执行完毕才返回，他是一种单向调用。

　　2：回调

　　　　回调是一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口。

　　3：异步调用

　　　　异步调用是一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方，比如浏览器点击事件中，用户点击后，会调用JS中的回调函数。

　　异步的实现原理：　　

　　　　

首先左上角的Call stack（调用栈）会把代码一行一行的执行，遇到addEVentListener，也就是事件，那么它不会执行，会托管在implementation-specific（可以理解为浏览器）中，右上角的implementation-specific会把这个事件记下来，当有人点击时，那么它会load成一个消息存放在右下角的message queue中，然后Event Loop(事件循环)会一直在那里循环，查看message queue中的消息，有消息，就把它扔回调用栈，然后执行call back的事件。

二：ES6

　　阮大大的《ECMAScript入门》  http://es6.ruanyifeng.com/

　　1: promise　　

    new Promise((resolve, reject) => {
        console.log('begin promise')
        setTimeout(resolve, 1000)
    }).then(() => {
        console.log('over')
    })

　　这个是非常简单的代码，先new promise传入2个参数，resolve代表成功会怎么样，reject代表失败会怎么样，上面的代码的意思是先输出'begin promise'resolve成功后1秒后输出'over'。then()的意思是resolve之后立即执行。

    new Promise((resolve,reject)=>{
        console.log('begin')
        setTimeout(function() {
            resolve();
        },1000);
    }).then(()=>{
        console.log('1')
        return new Promise((resolve,reject)=>{
            setTimeout(function() {
                resolve();
            },1000);
        });
    }).then(()=>{
        console.log('2');
        return new Promise((resolve)=>{
            setTimeout(function(){
                resolve();
            }, 1000)
        })
    }).then(()=>{
        console.log('over');
    })

　代码依次执行后会出现'begin',1,2,'over'。　

　return new Promise的意思就是返回一个new promise, 放在上一个promise对象上，形成链式调用，新的promise就代表this的上下文，与上面的promise形成相同的结果。

，我们发现整一个过程就像一个瀑布流一样，但是它都嵌套在一起了。非常的不友好。

　　2：thunk/curry化函数

　　　　thunkAsync = thunkify(async)
　　　　thunkAsync(params)(callback)

var Thunkify = function(fn){
        return function(){
            var args = Array.prototype.slice.call(arguments);
            return function(callback){
                //2000,callback
                args.push(callback);
                return fn.apply(this,args)
            }
        }
    }

    var thunkTimeout = Thunkify((time,callback)=>{
        setTimeout(callback, time)
    })

    //thunkTimeout(time)(callback)
    thunkTimeout(2000)(()=>{
        console.log('success');
    })

　　thunkify的意思：先传入一个元素setTimeout(),但是它没有被立即调用，是先放在了这里，然后有返回了一个函数，返回的这个函数是把arguments里面的东西存起来，有就是2000,然后又返回一个函数，这个返回函数传入的才是最终的callback,在这个函数中有把callback push给了args，那么args的状态就是2000，callback，然后最后一个return就是进行一开始我们保存的setTimeout的调用。

　　3：generator

function* helloGenerator(){
        console.log('generator');
        yield 'world'
        console.log('finish')
    }
    // //执行generator
    var generatorResult = helloGenerator();
    console.log(generatorResult.next().value);

    console.log(generatorResult.next());

　　generator要记住2点，next和yield,我们可以通过next()来控制yield的执行。next是继续执行，yield是暂停。

var gen = function* (){
        //把刚才的thunk函数拿过来，放在yield的后面
        //只需要接着传一个callback就可以执行了
        var r1 = yield thunkTimeout(2000);
        console.log(r1);
        //把刚才的thunk函数拿过来，放在jield的后面
        //只需要接着传一个callback就可以执行了
        var r2 = yield thunkTimeout(2000);
        console.log(r2)
    }
    //这是一个手动执行的版本
    var g = gen();
    //这个value指向的是，刚才我们已经传入的setTimeout(2000)
    g.next().value(function(){
        //这个function就是我们的callback
        //在i这里，已经完成了第一个setTimeout的过程
        var r2 = g.next('the first function complete');
        //这里的value，指向的是第二个setTimeout(2000)
        r2.value(function(){
            //完全的执行
            g.next('the second function complete');
        })
    })　　

　　

　　三：异步优化

    //像这样才能向上面那样2秒2秒的执行
    setTimeout(function(){
        console.log('the first function complete')
        setTimeout(function(){
            console.log('the second function complete')
        }, 2000)
    }, 2000)

我们要想实现上面的效果，有不想一直的嵌套。怎么办?

    //thunk/curry化函数
    var Thunkify = function(fn){
        //传入一个functuion:setTimeout
        //这个function fn，没有被立即调用，而是被放在了这里，先不管
        //返回了另一个函数
        return function(){
            //把arguments里面的东西存了起来，2000
            var args = Array.prototype.slice.call(arguments);
            //又返回了一个新的函数
            //这个函数传入的，才是最终的callback
            return function(callback){
                //完成push以后，args的状态是什么
                //2000,callback
                args.push(callback);
                //最终在进行一开始我们保存的setTimeout的调用
                return fn.apply(this,args)
            }
        }
    }

    var thunkTimeout = Thunkify((time,callback)=>{
        setTimeout(callback, time)
    })

        var gen = function* (){
        //把刚才的thunk函数拿过来，放在jield的后面
        //只需要接着传一个callback就可以执行了
        var r1 = yield thunkTimeout(1000);
        console.log('the first function1 complete');
        var r2 = yield thunkTimeout(2000);
        console.log('the first function2 complete');
        var r3 = yield thunkTimeout(3000);
        console.log('the first function3 complete');
        var r4 = yield thunkTimeout(4000);
        console.log('the first function4 complete');
        var r5 = yield thunkTimeout(5000);
        console.log('the first function5 complete');
    }

    function run(gen){
        //第一次把generator执行
        var g = gen();
        function nextRun(r){
            //在第一个行进行了一次next
            var next = g.next(r);
            if(next.done == true){
                return;
            }
            if(typeof next.value.then == 'function'){　　//promise要加一个then，才执行，所以这里加一个判断
                next.value.then(nextRun)
            }else{
                //第一次value
                next.value(nextRun)
            }
        }
        nextRun();
    }
    run(gen);

　　run函数就是用了递归，递归简单点来说，就是自己调用自己。　　

　　OK，大功告成。我好像还是第一次写这么认真的博客。