手写Promise教程_then方法|今日热门

手写Promise教程_then方法

1、Promise结构分析

console.log(new Promise((resolve, reject) => {}));

通过打印Promise的实例对象，观察promise的对象结构：

分析上图，可以得出一些信息：

• 1、promise实例对象上有PromiseState属性和PromiseResult属性
• 2、Promise构造函数上有all方法、race方法、resolve方法、reject方法。
• 3、Promise构造函数的原型对象上有then方法、catch方法。

这些是Promise最核心的属性和方法，手写Promise也就是去实现它们的功能。

(资料图片)

2、构造函数

创建一个promise_test.js文件，被在html文件中中引入：

index.html：

                    <script src="./promise_test.js"></script>    <script>        new Promise((resolve, reject) => {});    </script>

promise_test.js：

function Promise(executor) {    // 添加属性    this.PromiseState = "pending";    this.PromiseResult = undefined;    executor(resolve, reject);}

在promise_test.js文件中写上一个Promise构造函数，把JS为我们提供的原生Promise构造函数覆盖掉，然后运行代码，报错：

Uncaught ReferenceError: resolve is not defined。

为什么会出现这个错误呢？

因为在index.html中new Promise( 匿名函数(resolve, reject) )，作为实参传进来的匿名函数(resolve, reject)，在构造函数内调用的时候，传入了resolve和reject实参方法，但构造函数中没有这两个方法，因此我们要在构造函数中定义resolve和reject这两个方法：

2.1、resolve 和 reject

功能分析：

• 1、修改PromiseState的状态为fulfilled，并且PromiseState的状态只能修改一次。
• 2、可以接收一个参数，将这个参数的值赋给PromiseResult。

index.html：

new Promise((resolve, reject) => { resolve("test"); });

promise_test.js：

function Promise(executor) {    // 添加属性    this.PromiseState = "pending";    this.PromiseResult = undefined;    // 定义resolve函数    function resolve(data) {      console.log(this.PromiseState); // undefined    }    executor(resolve, reject);}

既然要修改PromiseState的值，那么我们先尝试获取这个值，构造函数中声明的是pending，但结果却是：undefined，为什么？

this的指向问题，我们在代码中打印了了一下this，结果：Window，为什么是Window？

这里复习一下this的指向，1、普通函数中的this指向window。2、构造函数中的this指向实例对象。3、箭头函数中的this指向父级作用域的this。

ok，如果知道了这两点的话，那么就可以知道如何解决：1、将this的指向作为一个属性保存下来。2、使用箭头函数。

这里选择保存this的指向：

function Promise(executor) {    // 添加属性    this.PromiseState = "pending";    this.PromiseResult = undefined;    // 保存实例对象的this值    const _this = this;    // 定义resolve函数    function resolve(data) {        // 判断状态，promise状态只能更改一次        if (_this.PromiseState !== "pending") return;        // 1、修改对象的状态（promiseState）        _this.PromiseState = "fulfilled"; // resolved        // 2、设置对象的结果值（promiseResult）        _this.PromiseResult = data;    }    function reject(data) {        // 判断状态，promise状态只能更改一次        if (_this.PromiseState !== "pending") return;        // 1、修改对象的状态（promiseState）        _this.PromiseState = "rejected"; // rejected        // 2、设置对象的结果值（promiseResult）        _this.PromiseResult = data;    }    executor(resolve, reject);}

index.html：

测试1：

const p = new Promise((resolve, reject) => {     resolve("success");});console.log(p);

结果1：Promise{PromiseState: "fulfilled", PromiseResult: "success"}

——

测试2：

const p = new Promise((resolve, reject) => {     reject("fail");});console.log(p);

结果2：Promise{PromiseState: "rejected", PromiseResult: "fail"}

——

经过测试，PromiseState和PromiseResult成功被修改！

3、then方法

3.1、功能分析

通过1的分析，我们可以得知then方法是放在原型对象上的，这样做的目的是为了通过实例对象调用.then进行链式调用。

链式调用是Promise最重要的特性，它解决了回调地狱的问题，下面我们来分析一下then方法的功能：

1、Promise.prototype.then方法：then(onResolved, onRejected) => {}，

它传入两个回调函数作为形参，onResolved作为PromiseState为fulfilled时的回调函数，onRejected作为PromiseState为rejected时的回调函数。

验证代码：

const p = new Promise((resolve, reject) => {    // resolve将PromiseState状态改为了fulfilled    resolve("success");    // reject将PromiseState状态改为了rejected    // reject("fail");});p.then(value => {    // onResolved方法的回调函数，状态时fulfilled执行    console.log(value); // success}, reason => {    // onRejected方法的回调函数，状态时rejected执行    console.log(reason); // fail});

2、then方法的返回值是一个新的promise对象，这个新的promise对象的结果状态由then指定的回调函数执行的返回值决定。

• 如果then回调函数的返回值是：非Promise的数据。那么新promise的状态（PromiseState）是fulfilled，值（PromiseResult）是这个非Promise的数据。
• 如果then回调函数的返回值是：Promise类型的数据，那么新的promise的状态（PromiseState）由返回值promise对象的状态决定，值（PromiseResult）也由它的值决定。
• 如果抛出异常，新promise变成rejected，reason为抛出的异常。

验证代码：

const p = new Promise((resolve, reject) => {    // resolve将PromiseState状态改为了fulfilled    resolve("success");    // reject将PromiseState状态改为了rejected    // reject("fail");});const p2 = p.then(value => {    // onResolved方法的回调函数，状态时fulfilled执行下面的代码    // 返回值是value变量，非promise，也就是"success"    // return value;    // 返回值是promise对象    return new Promise((resolve, reject) => {        // 如果调用resolve，那么p2的PromiseStatus就是fulfilled,PromiseResult是success2        resolve("success2");        // 如果调用reject，那么p2的PromiseStatus就是rejected,PromiseResult是fail2        // reject("fail2");        // 如果抛出异常，那么p2的PromiseStatus就是rejected,PromiseResult是error        // throw "error";    });}, reason => {    // onRejected方法的回调函数，状态时rejected执行下面的代码    console.log(reason); // fail});console.log(p2);

3、链式调用，并且异步调用。

• 1、then里面的代码，会按照链式调用的顺序，顺序执行。
• 2、then里面的代码，是异步执行。

验证代码：

const p = new Promise((resolve, reject) => {    resolve();    console.log("111");});const p2 = p.then(value => {    // 没有return返回值，默认是return undefined，这个也是非promise的数据，因此状态是fulfilled，值是undefined    console.log("222");}, reason => {    console.log(reason); // fail});p2.then(value => {    console.log("333");});console.log("444");

执行结果：111 444 222 333

可以看到，同步代码先执行，执行完之后再执行then中的异步代码，并且是按照链式操作的顺序执行下来。

以上就是then方法的功能分析，下面是手写实现：

3.2、功能实现

1、实现异步执行 + 判断返回值进行不同的操作

Promise.prototype.then = function(onResolved, onRejected) {    // then函数的返回值是一个新的promise对象    return new Promise((resolve, reject) => {        // 如果实例对象上的PromiseState是fulfilled，执行onResolved        if (this.PromiseState === "fulfilled") {            // 异步执行            setTimeout(() => {                try {                    let result = onResolved(this.PromiseResult);                    // 如果返回值是promise对象                    if (result instanceof Promise) {                        result.then(v => {                            resolve(v);                        }, r => {                            reject(r);                        });                    } else {                        // 如果返回值是非promise对象                        resolve(result);                    }                } catch (e) {                    // 如果抛出异常，新promise变成rejected，reason为抛出的异常。                    reject(e);                }            });        }        // 如果实例对象上的PromiseState是fulfilled，执行onRejected        if (this.PromiseState === "rejected") {            // 异步执行            setTimeout(() => {                try {                    let result = onRejected(this.PromiseResult);                    // 如果返回值是promise对象                    if (result instanceof Promise) {                        result.then(v => {                            resolve(v);                        }, r => {                            reject(r);                        });                    } else {                        // 如果返回值是非promise对象                        resolve(result);                    }                } catch (e) {                    // 如果抛出异常，新promise变成rejected，reason为抛出的异常。                    reject(e);                }            });        }    });}

上述代码看似可以完美实现，但是却存在一个缺陷，以下是测试index.html：

const p = new Promise((resolve, reject) => {    // 如果这里是异步的，出现bug：永远不会触发then方法    setTimeout(() => {        resolve("111");    }, 1000);});const p2 = p.then(value => {    console.log("then中：" + value);}, reason => {    console.log(reason);});

上述测试，及时是等一秒甚至一百秒，then方法中的回调也不会执行，为什么？

因为这个时候p这个对象中的promiseState还处于pending状态，所以我们要在then方法中加上第三种情况，pending。

做法是：将回调函数保存起来，在resolve和reject方法中去调用，如此就可以实现链式调用。

2、链式调用的实现

promise_test.js：

function Promise(executor) {    // 添加属性    this.PromiseState = "pending";    this.PromiseResult = undefined;    // 用于保存回调函数的数组    this.callbacks = [];    // 保存实例对象的this值    const _this = this;    // 定义resolve函数    function resolve(data) {        // 判断状态，promise状态只能更改一次        if (_this.PromiseState !== "pending") return;        // 1、修改对象的状态（promiseState）        _this.PromiseState = "fulfilled"; // fulfilled        // 2、设置对象的结果值（promiseResult）        _this.PromiseResult = data;        // 3、调用异步任务下，成功的回调函数        setTimeout(() => {            _this.callbacks.forEach(item => {                item.Resolved(data);            });        });    }    function reject(data) {        // 判断状态，promise状态只能更改一次        if (_this.PromiseState !== "pending") return;        // 1、修改对象的状态（promiseState）        _this.PromiseState = "rejected"; // rejected        // 2、设置对象的结果值（promiseResult）        _this.PromiseResult = data;        // 3、调用异步任务下，失败的回调函数        setTimeout(() => {            _this.callbacks.forEach(item => {                item.Rejected(data);            });        });    }    executor(resolve, reject);}Promise.prototype.then = function(onResolved, onRejected) {    // then函数的返回值是一个新的promise对象    return new Promise((resolve, reject) => {        // 如果实例对象上的PromiseState是fulfilled，执行onResolved        if (this.PromiseState === "fulfilled") {            // 异步执行            setTimeout(() => {                try {                    let result = onResolved(this.PromiseResult);                    // 如果返回值是promise对象                    if (result instanceof Promise) {                        result.then(v => {                            resolve(v);                        }, r => {                            reject(r);                        });                    } else {                        // 如果返回值是非promise对象                        resolve(result);                    }                } catch (e) {                    // 如果抛出异常，新promise变成rejected，reason为抛出的异常。                    reject(e);                }            });        }        // 如果实例对象上的PromiseState是rejected，执行onRejected        if (this.PromiseState === "rejected") {            // 异步执行            setTimeout(() => {                try {                    let result = onRejected(this.PromiseResult);                    // 如果返回值是promise对象                    if (result instanceof Promise) {                        result.then(v => {                            resolve(v);                        }, r => {                            reject(r);                        });                    } else {                        // 如果返回值是非promise对象                        resolve(result);                    }                } catch (e) {                    // 如果抛出异常，新promise变成rejected，reason为抛出的异常。                    reject(e);                }            });        }        // 如果new Promise中的函数是异步的，例如一秒之后再调用resolveo或者reject的情况        // 后续的新promise对象的状态都是pending，都会走这里。        // 我们就将回调函数保存起来，在resolve和reject方法中去调用        if (this.PromiseState === "pending") {            // 注意保存一下this的指向，因为下面两个都是普通函数，内部的this指向是window            const _this = this;            function Resolved() {                try {                    let result = onResolved(_this.PromiseResult);                    // 如果返回值是promise对象                    if (result instanceof Promise) {                        result.then(v => {                            resolve(v);                        }, r => {                            reject(r);                        });                    } else {                        // 如果返回值是非promise对象                        resolve(result);                    }                } catch (e) {                    // 如果抛出异常，新promise变成rejected，reason为抛出的异常。                    reject(e);                }            }            function Rejected() {                try {                    let result = onRejected(_this.PromiseResult);                    // 如果返回值是promise对象                    if (result instanceof Promise) {                        result.then(v => {                            resolve(v);                        }, r => {                            reject(r);                        });                    } else {                        // 如果返回值是非promise对象                        resolve(result);                    }                } catch (e) {                    // 如果抛出异常，新promise变成rejected，reason为抛出的异常。                    reject(e);                }            }            this.callbacks.push({                Resolved,                Rejected            });        }    });}

3、链式调用的实现_代码优化

可以看出，上述有很多重复代码，是为了更好帮助理解，故意的。

以下则是优化后的代码promise_test.js：

function Promise(executor) {    // 添加属性    this.PromiseState = "pending";    this.PromiseResult = undefined;    // 用于保存回调函数的数组    this.callbacks = [];    // 保存实例对象的this值    const _this = this;    // 定义resolve函数    function resolve(data) {        // 判断状态，promise状态只能更改一次        if (_this.PromiseState !== "pending") return;        // 1、修改对象的状态（promiseState）        _this.PromiseState = "fulfilled"; // fulfilled        // 2、设置对象的结果值（promiseResult）        _this.PromiseResult = data;        // 3、调用异步任务下，成功的回调函数        setTimeout(() => {            _this.callbacks.forEach(item => {                item.Resolved(data);            });        });    }    function reject(data) {        // 判断状态，promise状态只能更改一次        if (_this.PromiseState !== "pending") return;        // 1、修改对象的状态（promiseState）        _this.PromiseState = "rejected"; // rejected        // 2、设置对象的结果值（promiseResult）        _this.PromiseResult = data;        // 3、调用异步任务下，失败的回调函数        setTimeout(() => {            _this.callbacks.forEach(item => {                item.Rejected(data);            });        });    }    executor(resolve, reject);}Promise.prototype.then = function(onResolved, onRejected) {    // 注意保存一下this的指向，因为下面普通函数，内部的this指向是window    const _this = this;    // then函数的返回值是一个新的promise对象    return new Promise((resolve, reject) => {        function handler(func) {            try {                let result = func(_this.PromiseResult);                // 如果返回值是promise对象                if (result instanceof Promise) {                    result.then(v => {                        resolve(v);                    }, r => {                        reject(r);                    });                } else {                    // 如果返回值是非promise对象                    resolve(result);                }            } catch (e) {                // 如果抛出异常，新promise变成rejected，reason为抛出的异常。                reject(e);            }        }        // 如果实例对象上的PromiseState是fulfilled，执行onResolved        if (this.PromiseState === "fulfilled") {            // 异步执行            setTimeout(() => {                handler(onResolved);            });        }        // 如果实例对象上的PromiseState是rejected，执行onRejected        if (this.PromiseState === "rejected") {            // 异步执行            setTimeout(() => {                handler(onRejected);            });        }        // 如果new Promise中的函数是异步的，例如一秒之后再调用resolveo或者reject的情况        // 后续的新promise对象的状态都是pending，都会走这里。        // 我们就将回调函数保存起来，在resolve和reject方法中去调用        if (this.PromiseState === "pending") {            this.callbacks.push({                Resolved: () => {                    handler(onResolved);                },                Rejected: () => {                    handler(onRejected);                }            });        }    });}

测试代码index.html：

const p = new Promise((resolve, reject) => {    // 开启异步    // setTimeout(() => {        // resolve("ok");        reject("no");    // });});p.then(value => {    console.log(111);}, reason => {    // 如果返回值是非promise类型的数据    return reason;}).then(value => {    console.log(value); // "no"    // 如果返回值是promise类型的数据    return new Promise((resolve, reject) => {        resolve(333);    });}, reason => {    // ...}).then(value => {    console.log("收到的值是：", value); // 333    // 如果抛出异常    throw "error"}).then(() => {    // ...}, reason => {    console.log(reason); // error})// 如果then中是空值，什么也不传，出现bug！！！.then().then(() => {    console.log("我的上一个then是空值，我还可以输出吗？");});

最后的测试，如果then中是空值，什么也不传，出现bug！！！

4、值的穿透

解决：

Promise.prototype.then = function(onResolved, onRejected) {    // 注意保存一下this的指向，因为下面普通函数，内部的this指向是window    const _this = this;    // 判断回调函数参数    if (typeof onRejected !== "function") {        onRejected = reason => {            throw reason;        }    }    if (typeof onResolved !== "function") {        onResolved = value => value;    }    .....

当我们不在 then 中放入参数，例：promise.then().then()，那么其后面的 then 依旧可以得到之前 then 返回的值，这叫做值的穿透。

4、完整代码示例

写这个then方法，被这个then方法折磨了一整天了，中途踩了一些巨坑。

关于Promise的手写教程就先写到这里吧，catch、all、race、resolve、reject等方法的实现，会在下一篇博客中进行讲解。

这些方法相对then方法来说就简单得多了。

如果关于本篇文章有什么问题的话，可以私信我，谢谢阅读。

function Promise(executor) {    // 添加属性    this.PromiseState = "pending";    this.PromiseResult = undefined;    // 用于保存回调函数的数组    this.callbacks = [];    // 保存实例对象的this值    const _this = this;    // 定义resolve函数    function resolve(data) {        // 判断状态，promise状态只能更改一次        if (_this.PromiseState !== "pending") return;        // 1、修改对象的状态（promiseState）        _this.PromiseState = "fulfilled"; // fulfilled        // 2、设置对象的结果值（promiseResult）        _this.PromiseResult = data;        // 3、调用异步任务下，成功的回调函数        setTimeout(() => {            _this.callbacks.forEach(item => {                item.Resolved(data);            });        });    }    function reject(data) {        // 判断状态，promise状态只能更改一次        if (_this.PromiseState !== "pending") return;        // 1、修改对象的状态（promiseState）        _this.PromiseState = "rejected"; // rejected        // 2、设置对象的结果值（promiseResult）        _this.PromiseResult = data;        // 3、调用异步任务下，失败的回调函数        setTimeout(() => {            _this.callbacks.forEach(item => {                item.Rejected(data);            });        });    }    try {        executor(resolve, reject);    } catch (e) {        reject(e);    }}Promise.prototype.then = function(onResolved, onRejected) {    // 注意保存一下this的指向，因为下面普通函数，内部的this指向是window    const _this = this;    // 判断回调函数参数    if (typeof onRejected !== "function") {        onRejected = reason => {            throw reason;        }    }    if (typeof onResolved !== "function") {        onResolved = value => value;    }    // then函数的返回值是一个新的promise对象    return new Promise((resolve, reject) => {        function handler(func) {            try {                let result = func(_this.PromiseResult);                // 如果返回值是promise对象                if (result instanceof Promise) {                    result.then(v => {                        resolve(v);                    }, r => {                        reject(r);                    });                } else {                    // 如果返回值是非promise对象                    resolve(result);                }            } catch (e) {                // 如果抛出异常，新promise变成rejected，reason为抛出的异常。                reject(e);            }        }        // 如果实例对象上的PromiseState是fulfilled，执行onResolved        if (this.PromiseState === "fulfilled") {            // 异步执行            setTimeout(() => {                handler(onResolved);            });        }        // 如果实例对象上的PromiseState是rejected，执行onRejected        if (this.PromiseState === "rejected") {            // 异步执行            setTimeout(() => {                handler(onRejected);            });        }        // 如果new Promise中的函数是异步的，例如一秒之后再调用resolveo或者reject的情况        // 后续的新promise对象的状态都是pending，都会走这里。        // 我们就将回调函数保存起来，在resolve和reject方法中去调用        if (this.PromiseState === "pending") {            this.callbacks.push({                Resolved: () => {                    handler(onResolved);                },                Rejected: () => {                    handler(onRejected);                }            });        }    });}

关键词：

• 

  手写Promise教程_then方法|今日热门

  手写Promise教程_then方法1、Promise结构分析console log(newPromise((resolve,reject)=>{}));通过打印Prom

  来源： 2023-05-12
• 

  Json序列化对象后，使用Lombok后属性xAxis大写变成小写xaxis解决方法-天天时讯

  一、问题描述最近在开发后端接口时，发现返回结构中，一个字段大小写转化有问题。lombok版本：1 18 14VO对

  来源： 2023-05-12
• 

  微软本周不会为 Win11 Canary 或 Dev 频道发布新版本|精选

  本周不会这样做Windows11Canary或Dev新版本的频道发布，微软正在准备下周的新版本。叶紫网注：由于发布到Ca

  来源： 2023-05-12
• 

  重庆未来三年将实施水利项目超1800个 环球短讯

  5月9日，重庆日报记者从市水利局获悉，《重庆市水利高质量发展三年行动实施方案（2023—2025年）》（以下简

  来源： 2023-05-12

• 手写Promise教程_then方法|今日热门

• Json序列化对象后，使用Lombok后属性xAxis大写变成小写xaxis解决方法-天天时讯

• 微软本周不会为 Win11 Canary 或 Dev 频道发布新版本|精选

• 重庆未来三年将实施水利项目超1800个 环球短讯

• 跑分最高的安卓旗舰！已有1000多人下单iQOO Neo8系列|天天快看

• NVIDIA一代神卡RTX 3060 Ti要停产了：清完库存即止

• 惊了！女网红用AI同时交往1000多个“男友” 年入4亿？-世界实时

• 电脑也能秒开3A大作！Win11或将引入Xbox Quick Resume功能-全球消息

• 世界速看：女大学生坐高铁拒绝补票刁难乘务长 后排乘客理论遭辱骂

• 团结就是力量合唱动作编排视频_团结就是力量合唱动作 焦点快报

• 如何注册appuploader账号​

• 【申请教程】ChatGPT访问互联网插件-焦点信息

• 夺冠秘诀？华为软件精英挑战赛两届冠军这样复盘比赛经验

• 当前速讯：没关系，前端还死不了

• Java设计模式【单例模式】 当前速读

• 【新华500】新华500指数（989001）12日收跌1.31%_每日消息

• 辅助工具管理器_辅助工具管理器-焦点关注

• 东莞一锂电池厂深夜大火：照亮整个天空 无人伤亡

• 部分男厕改女厕引不满 四川大学再回应：进一步完善优化

• 汶川地震15周年 微信地震预警功能四川上线：秒级预警

• 世界今热点：《庆余年2》海报疑似抄袭 海报设计公司致歉

• 别说“刹车失灵”了！特斯拉回应大规模召回：降低交通事故概率

• 环球热文：PTP主时钟（时间同步装置）是怎样实现时钟同步的？

• MSCI中国指数季度调整出炉 新纳入53只标的|全球速看料

• 【天天热闻】4月MPV销量排名出炉 别克GL8大战腾势D9 受伤的是五菱宏光

• 0糖0脂 清新甜润：平仄青柑乌龙茶12瓶39元

• 自研半固态技术！蔚来1000公里续航车型申报：比宁王麒麟电池还猛 世界热头条

• 特斯拉FSD再不来真没机会了 比亚迪出手：智能驾驶年内上车 每日快报

• 榴莲涨到39.9元/斤 网友直呼吃不起 盒马回应：货源少了

• 袋鼠云产品功能更新报告05期｜应有尽“优”，数栈一大波功能优化升级！

• 环球快报:易基因：DNA甲基化和转录组分析揭示野生草莓干旱胁迫分子调控机制｜植物抗逆

• 今日讯！NES 系统架构

• 环球热资讯！被任天堂拉黑媒体发声：有人给《塞尔达传说：王国之泪》打6分很好

• 世界今日报丨法拉第晒财报 贾跃亭真成了！FF：已生产40辆FF91 百万豪车买不买？

• 三次输错密码后，系统是怎么做到不让我继续尝试的？|全球短讯

• 在C#中使用默认值初始化字符串数组的3种方式

• 世界热头条丨OPPO终止ZEKU芯片业务：这是一个艰难的决定！

• 天天看热讯：OPPO终止自研芯片业务！小米王化：确实不容易

• 哪吒汽车CEO：电吸门是脑残无用设计 出门基本不动手的人才用-当前速看

• 又菜又爱玩 加塞不成一路别车：结局笑出了声！|最新资讯

• 天天视点！签约保底要400万？孟羽童回应董明珠给百万年薪：在格力月薪没过万 工作21小时

• 环球头条：开源.NetCore通用工具库Xmtool使用连载 - 随机值篇

• JDK8 新特性之新的日期&时间API，一篇讲清楚！

• 智能化生产应用搭建的实战案例 世界微头条

• 精彩看点：echarts的散点图和中国地图配合使用

• 【经验分享】最新Microsoft Edge Dev游览器游览Flash网页的办法_今日聚焦

• iPhone/iPad全系可用：闪魔MFi苹果认证线21.8元大促 世界简讯

• 4月轿车销量排名出炉 燃油车新能源“混战” 好戏即将开场

• 环球时讯：某日系车一把手摊牌了：现在最害怕比亚迪

• 格局有了！SteamDeck官方庆祝ROG Ally开卖

• 精彩看点：深圳某公司母亲节放假3天不调休：和妈妈度过完整的母亲节

• 驾特斯拉遭遇车祸后 林志颖现身珠海首次参加赛车比赛：状态良好

• 战斗力爆表！无人机航拍时被鹰叼走：画面剧烈晃动

• 高通骁龙8 Gen2下放！一加Ace2 Pro曝光

• 曾盛赞比亚迪股票的巴菲特又减持了！本人回应：不想跟马斯克的特斯拉竞争

• 不止安装失败！Win11 KB5026372更新出现诸多问题 天天观天下

• 当前短讯！【转】为什么 TCP 建立连接需要三次握手

• 快看：Linux驱动开发笔记（三）：基于ubuntu的helloworld驱动源码编写、makefile编写以及驱动编译加载流程测试

• Java设计模式-适配器模式

• “原神玩家”和“塞尔达玩家”打起来了？不过是恶臭互联网的又一次狂欢_世界新消息

• 别了机械硬盘？全固态玩家转向了当“垃圾佬”

• 全系2.0T+8AT比BBA香多了！新款林肯冒险家上市：24.58万起

• 环球即时看！最大96GB内存不是梦！笔记本将迎来单条48GB DDR5内存

• 7499元 华硕天选4R游戏本上架：锐龙7-7735H、165Hz高刷

• 取代C++！微软改用Rust语言重写的Win11内核：正式来了

• 中药成香饽饽！ “药茅”片仔癀20年涨价18次 专家称没病别跟风买_全球快资讯

• 多省加入封杀行列！老头乐销冠雷丁汽车申请破产 创始人被曝身居海外

• SSD能有多便宜：2TB新品不到700元！长江存储232层原片颗粒加持

• 全球微资讯！Windows7 上运行docker实战

• 4月份以来17家银行下调存款利率 有望助推债市继续走牛 聚焦

• 美债上限谈判无进展 债务违约风险加大-环球速讯

• 沙特等减产石油 美国被逼补库存：印度捡漏俄油占大便宜 2022年省下50亿美元

• 当前资讯!国内第一！深圳要打造5G-A之城 全市5G网速平均必500Mbps 上行下载更狠

• 焦点热议:1000W用户1Wqps高并发签到系统的架构和实操

• 学系统集成项目管理工程师（中项）系列21a_整体管理（上）

• 长沙霸占车位车主致歉 栏杆拆除：双方均再次道歉 从没想会被网暴-环球今亮点

• 众望所归！马斯克宣布卸任推特CEO：神秘女子将接班

• 狗狗失踪7年后回家 主人煮饺子庆团圆：网友感慨万物皆有灵

• IGN 10分新神作！《塞尔达传说：王国之泪》港服日服已正式解锁

• 热消息：刘强东真兄弟！20年投入员工福利近500亿、建设公寓2.5万套

• 【天天播资讯】百度的“New Bing”终于来了！但别高兴得太早

• 全球看热讯：苹果年度跳水王！M2版Mac mini降到3399元了：不用领券

• 当前动态:Python学习之二：不同数据库相同表是否相同的比较方法

• 中芯国际人事再变动 刘训峰担任副董事长：基本年薪334万元 世界信息

• 性能逼近PS5 ROG掌机正式发布：首发锐龙Z1处理器 畅玩3A大作-天天观速讯

• 两个妈妈！英国首批三亲婴儿诞生：体内有三个人的DNA

• [Linux] 如何查看Centos用户登陆记录？[转载]_全球即时

• 今日热讯：【财经分析】REITs二级市场止跌回稳 机构看好高速板块后续表现

• 5月26日上映！迪士尼《小美人鱼》内地版配唱阵容官宣：黄绮珊领衔 短讯

• 环球今亮点！任天堂《塞尔达传说：王国之泪》获超低评分：太复杂玩不进去

• 司机400升油箱加到430升仍没加满：费用近3000元 已向多部门举报|看热讯

• 打开PDB报错ORA-30013

• 曝APP停摆、发不出工资 爱驰汽车再渡劫-每日短讯

• 当前快播：兆易创新首发Arm Cortex-M7内核MCU：600MHz超高频率！性能暴涨40％

• 《塞尔达传说：王国之泪》评分公布！IGN无悬念打出10分满分-新资讯

• 视点！高叶祝张颂文福如东海寿比南山：晒吃面照庆生

• 中芯国际发布Q1财报：利润下滑44% 尚未看到市场回暖 焦点日报

• S5PV210 | 微处理器启动流程

• P3723 [AH2017/HNOI2017]礼物（FFT）

• 益科正润：美国债务违约倒计时，“去美元化”正当时