Promise的静态方法

Promise的静态方法

1.Promise.all()

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>

    <script src="QF.js"></script>
    <script>
        function sendAjax1() {
     
            return new Promise((resolve, reject) => {
     
                QF.get("./a.php", {
     }, (data) => {
     
                    if (!data.error) {
     
                        resolve(data);
                    } else {
     
                        reject("第一个请求失败了");
                    }
                });
            });
        }

        function sendAjax2() {
     
            return new Promise((resolve, reject) => {
     
                QF.get("./b.php", {
     }, (data) => {
     
                    if (!data.error) {
     
                        resolve(data);
                    } else {
     
                        reject("第二个请求失败了");
                    }
                })
            });
        }

        function sendAjax3() {
     
            return new Promise((resolve, reject) => {
     
                QF.get("./c.php", {
     }, (data) => {
     
                    if (!data.error) {
     
                        resolve(data);
                    } else {
     
                        reject("第三个请求失败了");
                    }
                })
            })
        }

        // 同时发送这三个请求  当这三个请求都回来的时候 执行代码
        let p1 = sendAjax1();
        let p2 = sendAjax2();
        let p3 = sendAjax3();

        var arr = [p2, p1, p3];
        // Promise.all是Promise提供的静态方法 它可以同时监听多个Promise的实例
        // 1 参数是一个数组 数组中的每一个成员都是Promise的实例 如果不是 那么会通过Promise.resolve转为Promise实例
        // 2 Promise.all的返回值也是一个Promise实例 它的状态取决于这个数组中的每一个成员状态的变化 
        // 变化规则: 有任何一个成员的状态为rejected 那么rejected, 如果全部都是resolved 那么 resolved
        // 成功回调函数中的参数 是一个数组 数组与all接收的那个数组一一对应 是各自传递的数据

        let p = Promise.all(arr);
        p.then(function(arr) {
     
                console.log("都成功了");
                console.log(arr)
            })
            .catch(function(data) {
     
                console.log(data, "failed")
            })

2.Promise.race()

 // Promise.race 是Promise提供的一个静态方法 用于同时监听多个Promise 
        // 1 参数是一个数组 数组中的每一个成员都是Promise实例 如果不使 那么会通过Promise.resolve转为Promise实例
        // 2 Promise.race的返回值也是一个Promise实例 它的状态取决于这个数组中的最快发生变化的那个 
        // 变化规则:跟随最快发生状态变化的实例 
        let p = Promise.race([p1, p2, p3]);
        p.then(function(data) {
     
                console.log(data, "success")
            })
            .catch(function(data) {
     
                console.log(data, "failed")
            })

3.Promise.resolve()

 // Promise.resolve 是Promise提供的一个静态方法 用于将非Promise转为Promise实例
        // let p = Promise.resolve(1);  //1
        // let p = Promise.resolve("1");  //1
        // let p = Promise.resolve(true);  //true
        // let p = Promise.resolve(function() {})  //function(){}

        // 如果参数是一个thenable对象 那么then方法等于 new Promise时传递的参数
        // let p = Promise.resolve({
     
        //     then: function(resolve, reject) {
     
        //         console.log(31);
        //         resolve("aaa")
        //     }
        // })
        // 如果监听的是Promise实例 则跟随
        // let p1 = sendAjax1();
        // let p = Promise.resolve(p1);
        // 以上两种是属于特殊情况 其它的情况都属于 参数是什么就得到一个对应传递该参数的Promise实例
        // p.then(function(data) {
     
        //     console.log(data)
        // })

你可能感兴趣的:(js,js)