Promise的并行和串行

Promise 并行

这个功能Promise自身已经提供，不是本文的重点。主要是依赖Promise.all和Promise.race。
Promise.all是所有的Promise执行完毕后（reject|resolve）返回一个Promise对象。
Promise.race是任意一个Promise对象执行完毕后返回一个Promise对象。
有人可能会说，不是Promise对象reject的时候要catch么，这个嘛，.catch只是.then的一种变体。
详情可以参考Promise.all和Promise.race

Promise 串行

这个Promise对象本身没有提供，也是本文的重点。
Promise一单开始执行，执行上是不存在串行执行的，你想想，比如典型的计时的Promise。

const p1 =new Promise((resolve, reject) => {
        setTimeout(function () {
            resolve(1)
        }, 1000)
    })
const p2 =new Promise((resolve, reject) => {
        setTimeout(function () {
            resolve(2)
        }, 2000)
    })

像上面这种，你怎么去串行，当然是不行的。所以，思路得改变。把上面的Promise修改为如下

const p1 = function () {
        return new Promise((resolve, reject) => {
            setTimeout(function () {
                resolve(1)
            }, 1000)
        })
    },
    p2 = function () {
        return new Promise((resolve, reject) => {
            setTimeout(function () {
                resolve(2)
            }, 2000)
        })
    },

哦，不是直接的Promise对象，再利用Promise.then时执行该p1(),使得Promise链条得以继续。

/**
 * 顺序执行Promise，并返回结果
 * @param {返回promise的函数集合} promises 
 * @param {每一步的回调函数，非异步,可以考虑后期支持} cb 
 * @param {附加参数} args 
 */
function sequence(promises, cb, ...args) {
    const p = Promise.resolve(),
        len = promises.length
    if (len <= 0) {
        return p
    }
    let i = 0
    //如果cb不是函数
    if (typeof cb !== 'function') {
        cb = null
        args = [cb, ...args]
    }

    function callBack(...params) {
        return p.then(r => {
            return promises[i](r, ...params)
        }).then(r => {
            ++i
            cb && cb(r, i, ...params)
            return i > len - 1 ? Promise.resolve(r) : callBack(...params)
        })
    }

    return callBack(...args)
}

先解释一些一下参数

promises: 返回Promise对象的集合
cb 执行完每个Promise的回调，传入的参数有
- r: 上一次Promise执行完毕的返回结果
- i: 当前Promise的索引值
- params：其他的传入参数
args 其他的传入参数

返回来看，核心就是callback函数，他会顺序执行promises的函数返回Promise，然后取检查是否执行到最后，如果还有Promise等待执行，就调用callback，继续执行下一个，反之，结束。

我们来看一个简单的例子

const p1 = function () {
        return new Promise((resolve, reject) => {
            setTimeout(function () {
                resolve(1)
            }, 1000)
        })
    },
    p2 = function () {
        return new Promise((resolve, reject) => {
            setTimeout(function () {
                resolve(2)
            }, 2000)
        })
    },
    p3 = function () {
        return new Promise((resolve, reject) => {
            setTimeout(function () {
                resolve(3)
            }, 3000)
        })
    }

function printTime() {
    console.log(new Date().toLocaleString(), ...arguments)
}

const promises = [p1, p2, p3]

sequence(promises, function (r, i, ...args) {
    console.log('result:' + r, 'index:' + i, 'args:' + args)
}, {
    a: 1,
    b: 2
},3).then(r => printTime('result:', r))

// 输出结果
result:1 index:1 args:[object Object],3
result:2 index:2 args:[object Object],3
result:3 index:3 args:[object Object],3
2018-3-9 16:43:44 result: 3

可以看到

callback 函数，拿到的参数是，上次的执行结果，索引值，传入的其他参数
三个返回Promise的函数是依次执行的
执行完毕后，我们输出了最后的时间和最后的执行结果
那么，就达到了Promise的顺序执行
最后奉上完整代码和下载地址

/**
 * 转换为Promise集合
 * @param {Promise的集合或者之后后返回promise的函数集合} promises 
 * @param {附加参数} args 
 */
function toPromise(promises, ...args) {
    return promises.map(p => typeof p === 'function' ? p(...args) : p)
}

/**
 * 返回Promise.all
 * @param {Promise的集合或者之后后返回promise的函数集合} promises 
 * @param {附加参数} args 
 */
function all(promises, ...args) {
    return Promise.all(toPromise(promises, ...args))
}

/**
 * 返回Promise.race
 * @param {Promise的集合或者之后后返回promise的函数集合} promises 
 * @param {附加参数} args 
 */
function race(promises, ...args) {
    return Promise.race(toPromise(promises, ...args))
}

/**
 * 顺序执行Promise，并返回结果
 * @param {返回promise的函数集合} promises 
 * @param {每一步的回调函数，非异步,可以考虑后期支持} cb 
 * @param {附加参数} args 
 */
function sequence(promises, cb, ...args) {
    const p = Promise.resolve(),
        len = promises.length
    if (len <= 0) {
        return p
    }
    let i = 0
    //如果cb不是函数
    if (typeof cb !== 'function') {
        cb = null
        args = [cb, ...args]
    }

    function callBack(...params) {
        return p.then(r => {
            return promises[i](r, ...params)
        }).then(r => {
            ++i
            cb && cb(r, i, ...params)
            return i > len - 1 ? Promise.resolve(r) : callBack(...params)
        })
    }

    return callBack(...args)
}

/**
 * 顺序执行Promise，并返回结果, 需要主动执行sequence(promises)(6)
 * @param {返回promise的函数集合} promises 
 * @param {附加参数} args 
 */
function delaySequence(promises, cb, ...args) {
    return function (..._args) {
        return sequence(promises, cb, ...[...args, ..._args])
    }
}

const plus = {
    race,
    all,
    sequence,
    delaySequence
}

module.exports = plus

这里我应用到了自己编写的 Flow的MongoActivity.js，用来顺序执行mongo的操作命令.

这里再贴一份 30-seconds-of-code 里面的runPromisesInSeries

const runPromisesInSeries = ps => ps.reduce((p, next) => p.then(next), Promise.resolve());