JavaScript特性

关于JavaScript特性与异步模型

执行上下文

JS在第一次执行时会根据web引擎创建 全局上下文 在该上下文中运行JS脚本,在 调用函数时 从内存堆中提取函数 创建该函数的函数执行上下文 再将程序的执行转入 该函数上下文中 函数执行后再 返回全局上下文(这与C/C++的函数栈帧不同,反倒与thread机制类似,即进行上下文的保存和转换, 据此可推知: JS所实现的单线程异步是以此为基础实现的)

  • 关于JS中函数的存储

    是的,JS将定义的函数及其形参都按一定规则存入内存堆,在调用时从堆中提取。

调用栈

调用栈是JS引擎 跟踪 被调用函数所处位置的方式,JS使用其管理 执行上下文。

JS为每个被调用的函数创建一个 函数上下文 并依次压入调用栈中,由于JS为单线程语言,所以 只维护一个调用栈 当栈空后 脚本停止 。当执行的是一个递归函数,且陷入无限递归时会产生 栈溢出。

由于JS为单线程语言,只维护一个调用栈,所以 一次只执行一个操作 所有操作都是 同步的 而JS的 异步 特性可以在等待另一个任务完成时,执行其他任务。

事件循环

JS引擎从文件顶部向下执行,创建 执行上下文 和 管理 调用堆栈

在程序运行时,有可能会遇到执行时间很长的 阻塞函数 会阻塞交互行为,

所以使用Web API传入回调函数,函数向宿主环境发送任务消息后返回上一层上下文继续执行,其任务交由宿主环境进行处理,再接收宿主环境返回的完成信息(包含之前所注册的回调函数),压入 任务队列 (或回调队列),再由 事件循环 检查任务队列中的内容,当 调用栈 和 任务队列 都为空后 脚本停止 。

例如以下代码,始终返回 undefined

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Person
{
private username: string = 'join';
public getUserName(): string {
return this.username;
}

private email: string = '[email protected]';
public getEmail(): string {
return this.email;
}

public constructor(n: string, e: string) {
this.username = n;
this.email = e;
}

};

function getUsers(): Person[] {
let users : Person[] = [];

setTimeout(() => {
users = [
new Person('name1', 'email2'),
new Person('name2', 'email2'),
new Person('name3', 'email3'),
new Person('name4', 'email4'),
new Person('name5', 'email5'),
];
}, 1000);

return users;
}

function findUser(username: string): Person | undefined {
const users: Person[] = getUsers();
const user: Person | undefined = users.find((user) => user.getUserName() === username);
return user;
}

console.log(findUser('name1'));
  • JS非阻塞I/O的核心理解

    JS调用其Web API是否是向宿主环境发送一份消息(包括注册的回调函数),然后将所期望的操作移交宿主环境运行,该JS Web API函数调用返回到全局上下文,由宿主环境将被期望的行为执行后传回回调函数给JS 引擎的事件队列机制的任务队列,在全局上下文的合适时刻调用

    即,Web API 函数调用本身会很快从调用栈中弹出

    即,JS通过向宿主环境的委托实现了并发的异步处理机制。

Promise 对象

Promise 是一个对象,封装了 异步操作 的结果

Promise对象有一个状态,是以下三个之一

  • 等待中 | pending
  • 已完成,带有 值 | fulfilled
  • 由于 原因 而被拒绝 | rejected

初始时为 等待 ,之后根据运行结果,将状态更改为, 已完成 或 拒绝

使用 构造函数 Promise() 来创建 Promise对象

1
2
3
4
5
6
7
8
9
10
11
let promise = new Promise();

const promise = new Promise((resolve, reject) => {

if(success) {
resolve(value); // 返回一个值,即,处理结果
}
if(reject) {
reject(error); // 返回一个失败原因
}
});

异步操作 成功执行 调用resolve回调函数,将对象状态改为已完成,并返回值

异步操作 被拒绝 调用reject回调函数,将状态对象改为被拒绝

一旦Promise 已完成 或 被拒绝 ,就 无法再 进入其他状态,实际上是被解析,只能从 等待 状态变为 已完成 或 被拒绝

Promise作为一个模板类,需要传入一个类型,该类型为数据的返回类型,即resolve中的value的类型

操作Promise的三种方法

  • then()

    1
    Promise.then(onFulFilled, onRejected);

    传入两个回调函数

    • onFulFilled

      已完成

    • onRejected

      被拒绝

    then中的返回值传入下一个链式调用的then的参数中

    因为then方法返回的是一个解析新值的Promise对象

  • catch()

    在Promise为拒绝状态时才获取错误,只传入 onRejected

  • finally()

    无论已完成或是被拒绝都执行相同代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
function getUser(userId) {
return new Promise((resolve, reject) => {
console.log('Get the user from the database.');
setTimeout(() => {
resolve({
userId: userId,
username: 'admin'
});
}, 1000);
})
}

function getServices(user) {
return new Promise((resolve, reject) => {
console.log(`Get the services of ${user.username} from the API.`);
setTimeout(() => {
resolve(['Email', 'VPN', 'CDN']);
}, 3 * 1000);
});
}

function getServiceCost(services) {
return new Promise((resolve, reject) => {
console.log(`Calculate the service cost of ${services}.`);
setTimeout(() => {
resolve(services.length * 100);
}, 2 * 1000);
});
}

getUser(100)
.then(getServices)
.then(getServiceCost)
.then(console.log);

// =============================================================================
// 以下为输出

Get the user from the database.
Get the services of admin from the API.
Calculate the service cost of Email,VPN,CDN.
300

Promise的其他方法

  • Promise.all() 静态方法 ( 聚合 )( 返回 多结果 或 单原因 )

    接受一个包含可迭代对象的Promise

    1
    2
    Promise.all(iterable);
    // iterable应为 [p1, p2, p3, ...]

    Promise.all() 返回一个单个Promise,当输入 Promise 都已解析时,该Promise会解析。返回的Promise解析为一个包含输入Promise 结果的数组 。

    即,所有传入的Promise对象被解析为fulfilled状态,该返回的数组中包含所有的解析后产生的结果。

    传入的iterable中某个Promise被拒绝,则返回一个被拒绝的Promise

    Promise.all() 起到一个 聚拢异步操作 的作用。

  • Promise.race() 静态方法 ( 竞态 )(返回 单结果 或 单原因 )

    Promise.race() 接收一个Promise的可迭代对象

    一旦传入的对象列表中有一个状态变为 fulfilled 或 reject 则直接返回该值或原因

    根据各回调函数从宿主环境的返回速度定该返回值

  • Promise.any() 静态方法

    Promise.any() 接收一个Promise的可迭代对象

    若传入的一个可迭代对象中有一个为 fulfilled 则为该any()方法的返回值,

    即,使用第一个状态为 fulfilled 的Promise的返回值,不计之前的 reject 状态的Promise对象。

    若传入的一个可迭代对象中所有的状态都为 reject 则返回一个 rejected Promise

  • Promise.allSettled() 静态方法

    Promise.allSettled() 接收一个Promise的列表,返回一个新的Promise,在所有输入Promise结算后解析,无论是已解析还是已拒绝,

    返回的Promise被解析为一个数组,按顺序接收每个传入的Promise的结果

  • Promise.prototype.finally()

    finally(onFinally) 是 实例的 方法,允许Promise在解析后执行一个回调函数

    可以在 finally() 中运行清理相关的代码

  • promise.withResolvers()

async / await

  • async 关键字允许定义一个处理异步操作的函数

    1
    2
    3
    async function sayHi(): Promise<string> {
    return 'Hi';
    }
  • await 使用await等待一个Promise解决。只能在async函数内使用await关键字。