Promise的串行，并行，并发

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>promise test</title>
</head>
<body>
    <script>
         Promise.serial = function(promiseGens,allowFail){
            let seq = Promise.resolve();
            promiseGens.forEach(function(item){
                seq = allowFail ? seq.then(item).catch(err => err) : seq.then(item);
            });

            return seq;
        }

        //单个promise reject后，继续执行
        Promise.parallel = function(promiseGens){
            let allPromise = new Promise(function(resolve,reject){
                let results = [];
                promiseGens.forEach(function(item){
                    item()
                    .then(data => results.push(data))
                    .catch(err => results.push(err))
                    .finally(function(){
                        if(results.length == promiseGens.length){
                            resolve(results);
                        }
                    })
                });
            });

            return allPromise;
        }

        Promise.concurrency = function(promiseGens,concurrency,allowFail){
            let promiseGenCopys = [].concat(promiseGens);
            let concurrencyPromises = [];
            let res = [];
            while(concurrency--){
                concurrencyPromises.push(recur(promiseGenCopys));
            }
            
            return Promise.all(concurrencyPromises).then(_ => res);

            // return Promise.parallel(concurrencyPromises);

            function recur(promiseGens){
                if(!promiseGens.length) return Promise.resolve();

                let first = promiseGens.shift();
                return first().then(function(data){
                    res.push(data);
                    return recur(promiseGens);
                }).catch(function(err){
                    res.push(err);
                    return allowFail ? recur(promiseGens) : err; 
                })
            }
        }
    </script>
    <script>
        // 异步函数a
        var a = function () {
            return new Promise(function (resolve, reject) {
                setTimeout(function () {
                    console.log('resolve a');
                    resolve('a');
                }, 500)
            })
        }

        // 异步函数b
        var b = function (data) {
            return new Promise(function (resolve, reject) {
                setTimeout(() => {  
                    console.log('reject b',data);
                    reject(data||'reject'+ 'b');
                },500)
            })
        }

        // 异步函数c
        var c = function (data) {
            return new Promise(function (resolve, reject) {
                setTimeout(function () {
                    console.log('resolve c',data);
                    resolve(data||'reject' + 'c');
                }, 500)
            })
        }

        // 异步函数c
        var d = function (data) {
            return new Promise(function (resolve, reject) {
                setTimeout(function () {
                    console.log('resolve d',data);
                    resolve(data||'reject' + 'd');
                }, 500)
            })
        }

        // 异步函数c
        var e = function (data) {
            return new Promise(function (resolve, reject) {
                setTimeout(function () {
                    console.log('reject e',data);
                    reject(data||'reject' + 'e');
                }, 500)
            })
        }

        // 异步函数c
        var f = function (data) {
            return new Promise(function (resolve, reject) {
                setTimeout(function () {
                    console.log('reject f',data);
                    reject(data||'reject' + 'f');
                }, 500)
            })
        }

        //串行测试
        // Promise.serial([a,b,c,d,e,f],true).then(function(data){
        //     console.log(data);
        // }).catch(function(err){
        //     console.log('catch',err);
        // });

        //并行测试
        // Promise.parallel([a,b,c,d,e,f]).then(function(data){
        //     console.log(data);
        // }).catch(function(err){
        //     console.log(err);
        // });

        //并发测试
        Promise.concurrency([a,b,c,d,e,f],2,true).then(function(data){
            console.log(data);
        }).catch(function(err){
            console.log(err);
        })
    </script>
</body>
</html>
posted @ 2020-05-10 20:06 全玉阅读(1672) 评论(0) 编辑收藏举报
刷新页面返回顶部
登录后才能查看或发表评论，立即登录或者逛逛博客园首页
公告

昵称：全玉
园龄： 10年9个月
粉丝： 54
关注： 21
+加关注
2025年3月
日
一
二
三
四
五
六
全玉金生

Promise的串行，并行，并发

公告

搜索

常用链接

我的标签

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论
