Henry.HE的文档库

✍️述-Javascript Core

📖1. 异步与同步

实现：task按顺序执行后「可以多个」，最后执行run。

下面的实现方法可能不是最佳，只是个人思路。

将每一次的调用进行缓存，在最后执行run时进行同步控制
/**
 * 
 * @description: 实现一个链式调用的task
 * 
 */
function Queue() {
}

Queue.prototype.resolves = []

Queue.prototype.run = async function (cb) {
    var self = this

    self.resolves.push(
        () =>
            new Promise((rs, rj) => {
                cb && cb()
                rs()
            })
    )

    for (let index = 0; index < self.resolves.length; index++) {
        const fn = self.resolves[index];
        await fn()
    }
}

Queue.prototype.task = function (cb, st) {
    var self = this

    self.resolves.push(
        () =>
            new Promise((rs, rj) => {
                setTimeout(() => {
                    cb && cb()
                    rs()
                }, st)
            })
    )

    return queue2 = new Queue()
}

// test units
const q = new Queue()
    .task(() => {
        console.info('1')
    }, 1000)
    .task(() => {
        console.info('2')
    }, 2000)
    .run(() => {
        console.info('run')
    })
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
43
44
45
46
47
48
49
50
51
52
53
54

📖2. 闭包

实现如下sum方法求和，最终使用valueOf获取最终值

利用闭包Closure将变量缓存在内存中
/**
 * 
 * @description: sum 闭包应用 连续无限求和
 * sum(1)(2)(3)(4).valueOf()
 * 
 */

function sum(v) {
    var all = v
    var inside = function (val) {
        if (arguments.length === 0) {
            return all
        } else {
            all += val
            return inside
        }
    }

    inside.valueOf = function () {
        return all
    }

    return inside
}
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

←