异步函数策略

1、实现sleep()函数

1
2
3
4
5
6
7
8
9
10
async function sleep(delay) { 
    return new Promise((resolve) => setTimeout(resolve, delay)); 
} 
async function foo() { 
    const t0 = Date.now(); 
    await sleep(1500); // 暂停约 1500 毫秒
    console.log(Date.now() - t0); 
} 
foo(); 
// 1502

2、利用平行执行

我们来看下面这个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
async function randomDelay(id) { 
 // 延迟 0~1000 毫秒
    const delay = Math.random() * 1000; 
    return new Promise((resolve) => setTimeout(() => { 
        console.log(`${id} finished`); 
        resolve(); 
    }, delay)); 
} 
async function foo() { 
    const t0 = Date.now(); 
    for (let i = 0; i < 5; ++i) { 
        await randomDelay(i); 
    } 
    console.log(`${Date.now() - t0}ms elapsed`); 
} 
foo(); 
// 0 finished 
// 1 finished 
// 2 finished 
// 3 finished 
// 4 finished 
// 877ms elapsed
  • 这些期约之间没有依赖，异步函数也会依次暂停，等待每个超时完成。这样可以保证执行顺序，但总执行时间会变长。
  • 如果顺序不是必需保证的，那么可以先一次性初始化所有期约，然后再分别等待它们的结果。
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
async function randomDelay(id) { 
 // 延迟 0~1000 毫秒
    const delay = Math.random() * 1000; 
    return new Promise((resolve) => setTimeout(() => { 
        console.log(`${id} finished`); 
        resolve(id); 
    }, delay)); 
} 
async function foo() { 
    const t0 = Date.now(); 
    const promises = Array(5).fill(null).map((_, i) => randomDelay(i)); 
    for (const p of promises) { 
        console.log(`awaited ${await p}`); 
    } 
    console.log(`${Date.now() - t0}ms elapsed`); 
} 
foo(); 
// 1 finished 
// 2 finished 
// 4 finished 
// 3 finished 
// 0 finished 
// awaited 0 
// awaited 1 
// awaited 2 
// awaited 3 
// awaited 4 
// 645ms elapsed

3、串行执行期约

1
2
3
4
5
6
7
8
9
10
async function addTwo(x) {return x + 2;} 
async function addThree(x) {return x + 3;} 
async function addFive(x) {return x + 5;} 
async function addTen(x) { 
    for (const fn of [addTwo, addThree, addFive]) { 
        x = await fn(x); 
    } 
    return x; 
} 
addTen(9).then(console.log); // 19