【前端】尚硅谷Promise

已于 2024-03-21 18:53:37 修改
阅读量224 收藏 2
点赞数 3
文章标签： 前端
于 2024-03-07 19:27:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26127905/article/details/136543664
版权

文章目录


【前端目录贴】

1. Promise 的理解和使用

1.1 Promise 是什么?

  • 理解
  1. 抽象表达:
    • Promise 是一门新的技术(ES6 规范)
    • Promise 是 JS 中进行异步编程的新解决方案(备注：旧方案是单纯使用回调函数)
  2. 具体表达:
    • 从语法上来说: Promise 是一个构造函数
    • 从功能上来说: promise 对象用来封装一个异步操作并可以获取其成功/失败的结果值

1.1.1 promise两个重要属性

在这里插入图片描述

  • promise 的状态改变(PromiseState (pending/resolved(fullfilled)/rejected 三种情况))
  1. pending 变为 resolved
  2. pending 变为 rejected
    说明: 只有这 2 种, 且一个 promise 对象只能改变一次,成功的结果数据一般称为 value, 失败的结果数据一般称为 reason, 结果只能从pending 变为resolves或rejected;
  • promise 的结果(PromiseResult)，保存着异步任务『成功/失败』的结果(自己测试打印为空，暂不清楚为啥)

1.1.2 promise 的基本流程

在这里插入图片描述

1.2 为什么要用 Promise?

1.2.1 指定回调函数的方式更加灵活

  1. 旧的: 必须在启动异步任务前指定
  2. promise: 启动异步任务 => 返回 promie 对象 => 给promise 对象绑定回调函数(甚至可以在异步任务结束后指定/多个)

1.2.2 支持链式调用, 可以解决回调地狱问题

在这里插入图片描述

回调地狱: 回调函数嵌套调用, 外部回调函数异步执行的结果是嵌套的回调执行的条件
回调地狱的缺点: 不便于阅读、不便于异常处理
解决方案: promise 链式调用
终极解决方案?: async/await

1.3 如何使用Promise

1.3.1 基本编码流程

  • 基本编码流程
//普通实现方式
 $('button').on('click', function () {
        setTimeout(function () {
          result= funcationRandom(1, 9);
            if (result <= 3) {
                alert('中奖了');
             } else {
                alert('没有中奖')
            }
         },1000);
        console.log('抽奖结束')
    });
    
//promise实现方式
    $('button').on('click', function () {
        // promise实现方式
        // resolve 解决  函数类型的数据
        // reject  拒绝  函数类型的数据
        //1) 创建 promise 对象(pending 状态), 指定执行器函数
        var p=new Promise((resolve,reject)=>{
            //2) 在执行器函数中启动异步任务
            setTimeout(function () {
                result= funcationRandom(1, 9);
                /**
                 * 3) 根据结果做不同处理
                 * 3.1) 如果成功了, 调用 resolve(), 指定成功的 value, 变为 resolved 状
                 * 3.2) 根据结果做不同处理:如果成功了, 调用 resolve(), 指定成功的 value, 变为 resolved 状态
                 */
                if (result <= 3) {
                    resolve();  // 将 promise 对象的状态设置为 『成功』
                } else {
                    reject(); // 将 promise 对象的状态设置为 『失败』
                }
            },1000);
        });
        //调用 then 方法
        // value 值
        // reason 理由
        p.then(() => {
            alert('中奖了');
        },()=>{
            alert('没有中奖')
        })
        console.log('抽奖结束')
    });
  • 传值
$('button').on('click', function () {
        // promise实现方式
        // resolve 解决  函数类型的数据
        // reject  拒绝  函数类型的数据
        var p=new Promise((resolve,reject)=>{
            setTimeout(function () {
                result= funcationRandom(1, 9);
                if (result <= 3) {
                    resolve(result);  // 将 promise 对象的状态设置为 『成功』
                } else {
                    reject(result); // 将 promise 对象的状态设置为 『失败』
                }
            },1000);
        });
        //调用 then 方法
        // value 值
        // reason 理由
        p.then(value => {
            alert('中奖了,value='+value);
        },reason=>{
            alert('没有中奖,reason='+reason)
        })
        console.log('抽奖结束')
    });
  • fs异步
var fs = require('fs');
//回调函数形式
// fs.readFile('./aa.txt',(err,data) => {
//     if (err) {
//         throw err
//     }
//     console.log(data.toString());
// })

//promise形式
var p = new Promise((resolve, reject) => {
    fs.readFile('./aa.txt', (err, data) => {
        if (err) {
            reject(err); // 将 promise 对象的状态设置为 『失败』
        }
        resolve(data);  // 将 promise 对象的状态设置为 『成功』
    })
});
//调用 then 方法
// value 值
// reason 理由
p.then(value => {
    console.log(value.toString())
}, reason => {
    console.log(reason)
});
  • ajax异步
var p=new Promise((resolve, reject)=>{
                //1.创建对象
                var xhr = new XMLHttpRequest();
                //2.初始化 设置请求方法和url
                xhr.open('GET', 'http://127.0.0.1:3000/home');
                //3.发送
                xhr.send();
                //4.事件绑定,处理服务端返回的结果
                /**
                 * on when 当...时候
                 * readystate 是xhr对象中的属性, 表示状态0(初始化) 1(open完毕) 2(send完毕) 3(返回部分结果) 4(返回所有结果)
                 */
                xhr.onreadystatechange = function () {
                    //共改变4次,触发4次
                    //判断(服务端返回了所有的结果)
                    if (this.readyState === 4) {
                        //判断响应状态码 200 404 403 401 500
                        //2xx成功
                        if (this.status >= 200 && this.status < 300) {
                            resolve(this.response);
                        } else {
                            reject(this.status);
                        }

                    }
                }
        })
        p.then(value => {
            console.log(value)
        }, reason => {
            console.log(reason)
        });

1.3.2 util.promisify方法

将接受这种回调函数作为参数的函数，转换为返回promise的函数

//util.promisify方法: 将接受这种回调函数作为参数的函数，转换为返回promise的函数
//引入util模块
var util = require('util');
//引入fs模块
var fs = require('fs');
//返回promise版本函数
var promisify = util.promisify(fs.readFile);
promisify('./aa.txt').then((value) => {
    console.log(value.toString())
}, (reason) => {
    console.log(reason)
});

1.3.3 手动封装ajax方法

/**
     * 封装一个函数 sendAJAX 发送 GET AJAX 请求
     * 参数   URL
     * 返回结果 Promise 对象
     */
    function sendAJAX(url) {
        return new Promise((resolve, reject) => {
            //1.创建对象
            var xhr = new XMLHttpRequest();
            //2.初始化 设置请求方法和url
            xhr.open('GET', url);
            //3.发送
            xhr.send();
            //4.事件绑定,处理服务端返回的结果
            /**
             * on when 当...时候
             * readystate 是xhr对象中的属性, 表示状态0(初始化) 1(open完毕) 2(send完毕) 3(返回部分结果) 4(返回所有结果)
             */
            xhr.onreadystatechange = function () {
                //共改变4次,触发4次
                //判断(服务端返回了所有的结果)
                if (this.readyState === 4) {
                    //判断响应状态码 200 404 403 401 500
                    //2xx成功
                    if (this.status >= 200 && this.status < 300) {
                        resolve(this.response);
                    } else {
                        reject(this.status);
                    }

                }
            }
        })
    }
    sendAJAX('http://127.0.0.1:3000/server3').then(value => {
        console.log(value)
    }, reason => {
        console.log(reason)
    });

1.3.4 API

  • Promise 构造函数: Promise (excutor) {}
  1. executor 函数: 执行器 (resolve, reject) => {}
  2. resolve 函数: 内部定义成功时我们调用的函数 value => {}
  3. reject 函数: 内部定义失败时我们调用的函数 reason => {}
    说明: executor 会在 Promise 内部立即同步调用,异步操作在执行器中执行
    var p = new Promise((resolve, reject) => {
        //同步调用
        console.log('111');
       setTimeout(function () {
           console.log('333');
           result=1;
           if (result <= 3) {
               resolve('444');  // 将 promise 对象的状态设置为 『成功』
           } else {
               reject('error'); // 将 promise 对象的状态设置为 『失败』
           }
       },500)
    });
    //异步调用
    p.then((value) => {
        console.log(value)
    },(reason)=>{
        console.log(reason)
    });
    p.catch((reason)=>{
        console.log(reason)
    })
    console.log('222');
    //依次输出111 2222 333 444
  • Promise.prototype.then 方法: (onResolved, onRejected) => {}
  1. onResolved 函数: 成功的回调函数 (value) => {}
  2. onRejected 函数: 失败的回调函数 (reason) => {}
    说明: 指定用于得到成功 value 的成功回调和用于得到失败 reason 的失败回调, 返回一个新的 promise 对象
//异步调用
    var pp=p.then((value) => {
        console.log(value)
    },(reason)=>{
        console.log(reason)
    });
    console.log(pp);//返回一个新的promise 对象
  • Promise.prototype.catch 方法: (onRejected) => {}
  1. onRejected 函数: 失败的回调函数 (reason) => {}
    说明: then()的语法糖, 相当于: then(undefined, onRejected)
 var ppp=p.catch((reason)=>{
        console.log(reason)
    })
    console.log(ppp);//返回一个新的promise 对象
  • Promise.resolve 方法: (value) => {}
  1. value: 成功的数据或 promise 对象
    说明: 返回一个成功/失败的 promise 对象 (结果是传入的值或者 传入的 promise对象的value或reason值)
/**
 * 如果传入的参数为 非Promise类型的对象 -> 则返回的结果为成功promise对象
 * 如果传入的参数为 Promise 对象 -> 则参数的结果决定了 resolve 的结果
 */
var p_resolve1=Promise.resolve(123);
    var p_resolve2=Promise.resolve(p);
    console.log(p)
    console.log(p_resolve1)
    console.log(p_resolve2)
    p_resolve2.then((value) => {
        console.log('p_resolve2'+value)
    },(reason)=>{
        console.log('p_resolve2'+reason)
    });
    console.log(p===p_resolve2)//true
  • Promise.reject 方法: (reason) => {}
  1. reason: 失败的原因
    说明: 返回一个失败的 promise 对象 (失败状态,结果是 输入的字符串值,或者promise对象)
 var p_reject1 = Promise.reject(123);
    var p_reject2 = Promise.reject(p);
    console.log(p_reject1)//失败状态,结果123
    console.log(p_reject2)//失败状态,结果是p
    p_reject1.then((value) => {
        console.log('p_reject1-then ' + value)
    }, (reason) => {
        console.log('p_reject1-then ' + reason)
    })
    p_reject2.then((value) => {
        console.log('p_reject2-then ' + value)
    }, (reason) => {
        console.log('p_reject2-then ' + reason)
    });
  • Promise.all 方法: (promises) => {}
  1. promises: 包含 n 个 promise 的数组
    说明: 返回一个新的 promise, 只有所有的 promise 都成功才成功(结果:所有成功的promise数组), 只要有一个失败了就直接失败(结果返回失败的reason值)
var p_all1=Promise.all([p,p2]);
console.log(p_all1);
  • Promise.race 方法: (promises) => {}
  1. promises: 包含 n 个 promise 的数组
    说明: 返回一个新的 promise, 第一个完成的 promise 的结果状态就是最终的结果状态(结果是value或reason值)
var p_race=Promise.race([p,p2]);
console.log(p_race);

1.3.5 promise 的几个关键问题

  • 如何改变 promise 的状态?
 var p = new Promise((resolve, reject) => {
        //1. resolve 函数
        // resolve('ok'); // pending   => fulfilled (resolved)
        //2. reject 函数
        // reject("error");// pending  =>  rejected
        //3. 抛出错误
        throw '出问题了';
});
console.log(p)
  • 一个 promise 指定多个成功/失败回调函数, 都会调用吗?

当 promise 改变为对应状态时都会调用

  • 改变 promise 状态和指定回调函数谁先谁后?(指定和执行有差别)
  1. 都有可能, 正常情况下是先指定回调再改变状态, 但也可以先改状态再指定回调
  2. 如何先改状态再指定回调?
    1. 在执行器中直接调用 resolve()/reject()
    2. 延迟更长时间才调用 then()
  3. 什么时候才能得到数据?
    1. 如果先指定的回调, 那当状态发生改变时, 回调函数就会调用, 得到数据
      2.如果先改变的状态, 那当指定回调时, 回调函数就会调用, 得到数据
   var p = new Promise((resolve, reject) => {
        // resolve('ok'); // 先改状态再指定回调

        setTimeout(() => {
            resolve('OK');// 先指定回调再改状态再
        }, 3000);
    });
    console.log(p);
    p.then(value => {
            console.log(value);
    })
    // setTimeout(function () {//将then延长更长时间执行
    //     p.then(value => {
    //         console.log(value);
    //     }),5000
    // });
  • promise.then()返回的新 promise 的结果状态由什么决定?
  1. 简单表达: 由 then()指定的回调函数执行的结果决定
  2. 详细表达:
    1. 如果抛出异常, 新 promise 变为 rejected, reason 为抛出的异常
    2. 如果返回的是非 promise 的任意值, 新 promise 变为 resolved, value
    3. 如果返回的是另一个新 promise, 此 promise 的结果就会成为新 promise 的结果
    var p = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('111');// 先指定回调再改状态再
        }, 1000);
    });

    pp = p.then(value => {
        console.log(value);
        // throw 'error';//1.抛出异常, 新 promise 变为 rejected, reason 为抛出的异常
        // return 'ok2';//2.返回的是非 promise 的任意值, 新 promise 变为 resolved, value 为返回的值
        return new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve('222');// 先指定回调再改状态再
            }, 1000);
        });//3.返回的是另一个新 promise, 此 promise 的结果就会成为新 promise 的结果
    })
    console.log(p);
    console.log(pp);
  • promise 如何串连多个操作任务?
  1. promise 的 then()返回一个新的 promise, 可以开成 then()的链式调用
  2. 通过 then 的链式调用串连多个同步/异步任务
  • promise 异常传透?
  1. 当使用 promise 的 then 链式调用时, 可以在最后指定失败的回调,
  2. 前面任何操作出了异常, 都会传到最后失败的回调中处理
   var p = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('111');// 先指定回调再改状态再
            // reject('err');// 先指定回调再改状态再
        }, 1000);
    });

    p.then(value => {
        console.log(value);
        return new Promise((resolve, reject) => {
            setTimeout(() => {
                // resolve('222');
                reject('err');
            }, 1000);
        });
    }).then(value => {
        console.log(value);
    }).catch(reason => {
        console.log(reason)
    })//串联(末尾也可用then)
    //.catch(value => {
    //     console.log(value);
    // },reason => {
    //     console.log(reason)
    // })
  • 中断 promise 链?
  1. 当使用 promise 的 then 链式调用时, 在中间中断, 不再调用后面的回调函数
  2. 办法: 在回调函数中返回一个 pendding 状态的 promise 对象
 var p = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('111');// 先指定回调再改状态再
            // reject('err');// 先指定回调再改状态再
        }, 1000);
    });

    p.then(value => {
        console.log(value);
        return new Promise(() => {});//返回pending状态promise对象
    }).then(value => {
        console.log(value);
    }).catch(reason => {
        console.log(reason)
    })

1.4 手写Promise

1.5 async 与 await

1.5.1 async 函数

  1. 函数的返回值为 promise 对象
  2. promise 对象的结果由 async 函数执行的返回值决定
    (和then一样)
//then
    async function main() {
        //1. 如果返回值是一个非Promise类型的数据
        // return 521;
        //2. 如果返回的是一个Promise对象
        // return new Promise((resolve, reject) => {
        //     // resolve('OK');
        //     reject('Error');
        // });
        //3. 抛出异常
        throw "Oh NO";
    }
    let result = main();
    console.log(result)
    result.then(value => {
        console.log(value)
    },reason=>{
        console.log(reason);
    });

1.5.2 await 表达式

  1. await 右侧的表达式一般为 promise 对象, 但也可以是其它的值
  2. 如果表达式是 promise 对象, await 返回的是 promise 成功的值
  3. 如果 await 的 promise 失败了, 就会抛出异常, 需要通过 try…catch 捕获处理
  4. 如果表达式是其它值, 直接将此值作为 await 的返回值
    await 必须写在 async 函数中, 但 async 函数中可以没有 await

1.5.3 async和await结合

var fs = require('fs');
//引入util模块
var util = require('util');
// //返回promise版本函数
var promisify = util.promisify(fs.readFile);

async function main() {
   try{
       data1=await promisify('./a.txt');
       data2=await promisify('./b.txt');
       data3=await promisify('./c.txt');

       console.log(data1.toString())
       console.log(data2.toString())
       console.log(data3.toString())
   }catch (e) {
       console.log(e)
   }
}
main();

1.5.4 async和await结合-ajax

/**
     * 封装一个函数 sendAJAX 发送 GET AJAX 请求
     * 参数   URL
     * 返回结果 Promise 对象
     */
    function sendAJAX(url) {
        return new Promise((resolve, reject) => {
            //1.创建对象
            var xhr = new XMLHttpRequest();
            //2.初始化 设置请求方法和url
            xhr.open('GET', url);
            //3.发送
            xhr.send();
            //4.事件绑定,处理服务端返回的结果
            /**
             * on when 当...时候
             * readystate 是xhr对象中的属性, 表示状态0(初始化) 1(open完毕) 2(send完毕) 3(返回部分结果) 4(返回所有结果)
             */
            xhr.onreadystatechange = function () {
                //共改变4次,触发4次
                //判断(服务端返回了所有的结果)
                if (this.readyState === 4) {
                    //判断响应状态码 200 404 403 401 500
                    //2xx成功
                    if (this.status >= 200 && this.status < 300) {
                        resolve(this.response);
                    } else {
                        reject(this.status);
                    }

                }
            }
        })
    }
    $('#btn').on('click', async function () {
        data=await sendAJAX('http://127.0.0.1:8000/server3');
        console.log(data);
    });
骑鱼过海的猫123
关注
Web前端 Promise 入门 【尚硅谷】
weixin_46703850的博客
08-21 436
尚硅谷Web前端Promise教程从入门到精通
2024前端面试题！（附答案及解析）（2024.10月最新版）
热门推荐
这世上从不缺让人上头的新鲜感，能顾及你情绪的人实属难得。
03-27 17万+
2024前端面试题！面试宝典！总结心得！（附答案及解析）会持续更新哦！（2024.10月最新版）感谢支持，你们的鼓励是我的动力！
Promise学习笔记（尚硅谷）
Ch_ensf的博客
05-16 1339
一、Promise 的理解和使用 二、手写 Promise
《尚硅谷Web前端Promise教程从入门到精通》系列博客_Promise API
buyaotutou的博客
05-25 745
为学习axios打基础。本Promise从入门到自定义博客内容介绍。Promise是ES6引入的进行异步编程的新的解决方案，从语法上说它是一个构造函数，可以封装异步的任务，并且可以对结果进行处理。Promise最大的好处在于可以解决回调地狱的问题，并且在指定回调和处理错误方面更加灵活，在Web或者App项目中应用十分广泛，无论前端还是后端都可以看到Promise的身影，且是现在面试的高频题目，想进入一线大厂必须掌握Promise内部运行的原理。
《尚硅谷Web前端Promise教程从入门到精通》系列博客_Promise自定义封装
buyaotutou的博客
05-25 312
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言Promise 自定义封装(手写Promise)1.定义整体结构2.resolve和reject结构搭建3.resolve和reject内部功能代码实现。4.throw抛出异常改变状态5.Promise对象状态只能改变一次6.then()方法执行回调7.异步任务回调的执行8.指定多个回调的实现9.同步修改状态时then方法结果返回10.异步修改状态时then方法结果返回11.then方法补充和优化11.catch方法和异常穿透
Promise相关笔记 — 尚硅谷promise学习记录
qq_44363897的博客
03-12 553
Promise相关笔记 — 尚硅谷promise 一、实例对象和函数对象 函数对象：将函数作为对象使用时，简称为函数对象 实例对象：new 函数产生的对象，简称对象 <script type='text/javascript'> //js中所有函数都是Function类的实例 function Fn () { //Fn函数 } const fn =...
尚硅谷Web前端Promise教程从入门到精通——笔记
weixin_58325898的博客
09-03 815
文章参考尚硅谷的promsie教程，其中包括些个人理解，有需要的同学可以自取~ 内容包括：Promise属性，Promise工作流程，Promise相关API，async和await
尚硅谷_Vue全家桶_基于VUE_vue；尚硅谷_vue_
10-04
5. **Axios**：Axios是一个基于Promise的HTTP库，可以方便地在Vue应用中发送HTTP请求。 【尚硅谷_Vue全家桶.docx】学习资源 "尚硅谷_Vue全家桶.docx"可能是一份详细的教学文档，涵盖了Vue.js的基础知识，如模板...
atguigu-utils:尚硅谷前端工具函数库
05-13
尚硅谷大前端自定义工具函数库 说明 1. 包含以下8个方面 1). 函数相关 2). 数组相关 3). 对象相关 4). 字符串相关 5). 事件总线 6). 消息订阅与发布 7). Promise 8). ajax函数axios 9). 数据结构与算法 2. 使用 1). ...
Promise
qq_45050686的博客
09-22 403
Promise、Promise.then
尚硅谷-Promise系统学习笔记
huangliangbao2009的专栏
03-04 357
该笔记为观看`尚硅谷Web前端Promise教程从入门到精通（2021抢先版）`与`尚硅谷Promise教程(promise前端进阶必学)`两个课程视频以及参考其课件;
Promise笔记
dihuaooo的博客
04-04 808
Promise笔记
Nodejs 之 promise
loeyln的博客
04-08 691
express一、CommonJs二、Promise2.1 回调地狱2.2 promise是什么2.2.1 抽象表达2.2.2 具体表达2.2.3 Promise有三个状态2.2.4 promise的状态改变2.3 promise基本流程2.4 promise的优势2.4.1. 指定回调函数的方式更加灵活2.4.2 支持链式调用, 可以解决回调地狱问题2.5 promise的使用：解决回调地狱问题2.6 async/await 同时使用2.7 Promise的使用2.8 Promise的几个关键问题 一、C
promise的理解和使用-尚硅谷教程笔记
weixin_42349568的博客
10-05 575
一，理解 抽象表达：promise是js中进行异步编程的新的解决方案。（旧的是纯粹的回调函数） 具体表达：从语法上来看，promise是一个构造函数。从功能上来说，promise对象用来封装一个异步操作，并可以获取其结果。 异步操作的第一阶段处理方式：回调函数作为参数传入，异步结果作为回调函数的参数传入，回调函数在异步操作后调用，以完成对异步结果的获取和处理。 之前就学习过，异步操作的执行，是无法直接得到执行结果的。 为了拿到结果，人们将函数作为参数来定义异步操作的函数： 类似于上图这样，利用回调函数作
前端Promise总结笔记
你好呀，很高兴你在看这里~
04-16 9663
一.什么是Promise： Promise 是在 js 中进行异步编程的新解决方案。（以前旧的方案是单纯使用回调函数） 从语法来说，promise是一个构造函数。 从功能来说，promise对象用来封装一个异步操作，并且可以获得成功或失败的返回值。 二.为啥使用Promise： promise使用回调函数更灵活。旧的回调函数必须在启动异步任务前指定。 promise：启动异步任务 => 返回promise对象 => 给promise对象绑定回调函数（甚至能在异步任务结束后指定多个） pr
Promise使用详解1（基本概念、使用优点）
泥猴桃的博客
06-09 2971
以前看es6 教程 promise 看的有点一头雾水，后来发现用到的地方还很多，比如axios 后来决定好好研究下这个鬼！ 这篇文章是在网上搜到的，写的简单明了，转过来留着以后复习用 一、promises相关概念 promises 的概念是由 CommonJS 小组的成员在 Promises/A 规范中提出来的。 1，then()方法介绍 根据 Promise/A 规范，promis...
promise入门的准备工作-（尚硅谷教程笔记）
weixin_42349568的博客
10-04 195
一，函数对象与实例对象的区分 函数对象：将函数作为对象使用时，简称为函数对象 实例对象：new函数产生的对象，简称对象 正常来说，（）的左边是函数，点的左边是对象。 即可以根据（）或者点来判断这个函数是作为函数来使用的还是作为对象来使用的，作为函数使用，则是函数，作为对象使用，则是函数对象。而通过构造函数产生的对象，就直接判定为实例对象。 二，两种类型的回调函数 回忆下回调函数的定义：我自己定义的，我没有调用，但是最终它执行了。 1，同步回调 立即执行，完全执行完了才结束，并不会放入到回调队列中去。 例子
web扩展
x737510的博客
10-10 604
HTTP（Hypertext Transfer Protocol）协议中的它们在用途和使用方式上有一些区别。用于请求服务器上的资源，通常是获取数据。GET 请求是幂等的，多次请求返回的结果应该是相同的，而且不应该对服务器产生任何副作用。用于向服务器提交数据，通常是提交表单数据或上传文件等。POST 请求可能对服务器产生副作用，例如在数据库中创建新的资源。数据通过 URL 参数传递，附在 URL 后面。因为数据在 URL 中可见，所以不适合传递敏感信息，且有长度限制。
前端开发攻略---8种方法实现在浏览器中跨页面通信
最新发布
nibabaoo的博客
10-15 1084
浏览器实现跨标签页通信的多种方式
尚硅谷promise
10-19
尚硅谷Promise是一个基于JavaScript的Promise/A+规范实现的库，它提供了一种更加优雅的异步编程解决方案。Promise是一种异步编程的解决方案，它可以避免回调地狱，使得异步代码更加易于编写和维护。尚硅谷Promise...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值