1488 字
7 分钟
JS异步

目录#

Promise#

Promise,async/await https://zh.javascript.info/async

回调

// 问题引入, 如何获取异步函数的返回值?
{
function fun() {
setTimeout(() => {
return "hello";
}, 0);
}
// 直接返回undefined, 因为setTimeout是异步的
console.log(fun()); // undefined
}
{
function fun(callback) {
setTimeout(() => {
callback("hello");
}, 0);
}
// 使用回调函数接收到异步的返回参数
fun((str) => console.log(str));
}
{
function fun() {
return new Promise((resolve) =>
setTimeout(() => {
resolve("hello");
}, 0)
);
}
fun().then(console.log); // hello
}
function loadScript(src, callback) {
let script = document.createElement('script');
script.src = src;
script.onload = () => callback(script);
document.head.append(script);
}
loadScript('https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js', script => {
alert(`酷,脚本 ${script.src} 加载完成`);
alert( _ ); // _ 是所加载的脚本中声明的一个函数
});

嵌套回调

loadScript('/my/script.js', function(script) {
alert(`酷,脚本 ${script.src} 加载完成,让我们继续加载另一个吧`);
loadScript('/my/script2.js', function(script) {
alert(`酷,第二个脚本加载完成`);
});
});

Promise对象#

let promise = new Promise(function(resolve, reject) {
// executor(生产者代码,“歌手”)
});

它的参数 resolve 和 reject 是由 JavaScript 自身提供的回调。我们的代码仅在 executor 的内部。

当 executor 获得了结果,无论是早还是晚都没关系,它应该调用以下回调之一:

  • resolve(value) —— 如果任务成功完成并带有结果 value。
  • reject(error) —— 如果出现了 error,error 即为 error 对象。

由 new Promise 构造器返回的 promise 对象具有以下内部属性:

  • state —— 最初是 "pending",然后在 resolve 被调用时变为 "fulfilled",或者在 reject 被调用时变为 "rejected"。
  • result —— 最初是 undefined,然后在 resolve(value) 被调用时变为 value,或者在 reject(error) 被调用时变为 error。

executor 只能调用一个 resolve 或一个 reject。任何状态的更改都是最终的。

所有其他的再对 resolve 和 reject 的调用都会被忽略:

let promise = new Promise((resolve, reject) => {
setTimeout(() => {
resolve("hello");
reject("error"); // 被忽略
}, 0);
});
promise.then(
// str的值从 resolve中获取
(str) => {
console.log("str", str); // str hello
},
// err 的值从reject中获取
(err) => {
console.log("err", err);
}
);

.catch(f) 调用是 .then(null, f) 的完全的模拟,它只是一个简写形式

let promise = new Promise((resolve, reject) => {
setTimeout(() => {
reject(new Error("error"));
}, 0);
});
promise.then(console.log).catch(console.log); // Error: error

就像常规 try {...} catch {...} 中的 finally 子句一样,promise 中也有 finally。

调用 .finally(f) 类似于 .then(f, f),因为当 promise settled 时 f 就会执行:无论 promise 被 resolve 还是 reject。

finally 的功能是设置一个处理程序在前面的操作完成后,执行清理/终结。

  • finally 处理程序(handler)没有参数。在 finally 中,我们不知道 promise 是否成功。没关系,因为我们的任务通常是执行“常规”的完成程序(finalizing procedures)。

    请看上面的例子:如你所见,finally 处理程序没有参数,promise 的结果由下一个处理程序处理。

  • finally 处理程序将结果或 error “传递”给下一个合适的处理程序。

    例如,在这结果被从 finally 传递给了 then:

finally 处理程序也不应该返回任何内容。如果它返回了,返回的值会默认被忽略。

执行顺序#

let promise = new Promise((resolve, reject) => {
console.log(1)
resolve()
})
promise.then(() => console.log(3))
console.log(2)

执行顺序是123, 在 new Promise()的时候,Promise的执行器就会立马执行,但是调用resolve()会触发异步操作,传入的then()方法的函数会被添加到任务队列并异步执行

Promise 处理始终是异步的,因为所有 promise 行为都会通过内部的 “promise jobs” 队列,也被称为“微任务队列”(V8 术语)。

因此,.then/catch/finally 处理程序总是在当前代码完成后才会被调用。

如果我们需要确保一段代码在 .then/catch/finally 之后被执行,我们可以将它添加到链式调用的 .then 中。

Promise链#

// 通过then想resolve传递参数
new Promise((resolve) => {
setTimeout(resolve, 0);
}).then(() => {
console.log("hello");
});
new Promise((resolve) => {
// resolve 返回值到then的参数中
setTimeout(() => resolve(1), 0);
})
.then((res) => {
console.log(res);
return res * 2;
})
.then((res) => {
console.log(res);
return res * 2;
})
.then((res) => {
console.log(res);
});

Promise API#

Promise.all#

假设我们希望并行执行多个 promise,并等待所有 promise 都准备就绪。

例如,并行下载几个 URL,并等到所有内容都下载完毕后再对它们进行处理。

这就是 Promise.all 的用途。

let promise = Promise.all(iterable);

Promise 类有 6 种静态方法:

  1. Promise.all(promises) —— 等待所有 promise 都 resolve 时,返回存放它们结果的数组。如果给定的任意一个 promise 为 reject,那么它就会变成 Promise.all 的 error,所有其他 promise 的结果都会被忽略。
  2. Promise.allSettled(promises)(ES2020 新增方法)—— 等待所有 promise 都 settle 时,并以包含以下内容的对象数组的形式返回它们的结果:
    • status: "fulfilled" 或 "rejected"
    • value(如果 fulfilled)或 reason(如果 rejected)。
  3. Promise.race(promises) —— 等待第一个 settle 的 promise,并将其 result/error 作为结果返回。
  4. Promise.any(promises)(ES2021 新增方法)—— 等待第一个 fulfilled 的 promise,并将其结果作为结果返回。如果所有 promise 都 rejected,Promise.any 则会抛出 AggregateError 错误类型的 error 实例。
  5. Promise.resolve(value) —— 使用给定 value 创建一个 resolved 的 promise。
  6. Promise.reject(error) —— 使用给定 error 创建一个 rejected 的 promise。

以上所有方法,Promise.all 可能是在实战中使用最多的。

async/await#

async#

在函数前面的 “async” 这个单词表达了一个简单的事情:即这个函数总是返回一个 promise。其他值将自动被包装在一个 resolved 的 promise 中。

下面三种方式等同, 显然使用async更简洁

{
async function fun() {
return 1;
}
fun().then(console.log); // 1
}
{
function fun() {
return new Promise(resolve => resolve(1));
}
fun().then(console.log); // 1
}
{
function fun() {
return Promise.resolve(1);
}
fun().then(console.log); // 1
}

await#

  • await只能在async修饰的函数中使用
  • 关键字 await 让 JavaScript 引擎等待直到 promise 完成(settle)并返回结果。
  • await 实际上会暂停函数的执行,直到 promise 状态变为 settled,然后以 promise 的结果继续执行。这个行为不会耗费任何 CPU 资源,因为 JavaScript 引擎可以同时处理其他任务:执行其他脚本,处理事件等。
fetch("http://api.uixsj.cn/hitokoto/get").then(resp => resp.text()).then(data => console.log(data));
JS异步
https://blog.tiamix.cn/posts/js异步/
作者
Tiam
发布于
2023-02-21
许可协议
CC BY-NC-SA 4.0