प्रौद्योगिकी साझेदारी

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

ES6 Generator कार्याणां अतुल्यकालिकं अनुप्रयोगं मुख्यतया Promise इत्यनेन सह तस्य उपयोगेन कार्यान्वितं भवति । एतत् प्रतिरूपं "thunk" प्रतिमानं कथ्यते, तथा च एतत् भवन्तं समकालिकं दृश्यते इति अतुल्यकालिकसङ्केतं लिखितुं शक्नोति ।

लक्षणम् : १.

1. निष्पादनं स्थगयन्तु: यदा Generator function yield expression इत्यस्य सम्मुखीभवति तदा execution विरामं करिष्यति तथा Promise इत्यस्य समाधानं प्रतीक्षते ।
2. निष्पादनं पुनः आरभत: यदा Promise सम्पन्नं भवति (समाधानं वा अस्वीकृतं वा), तदा Generator फंक्शन् पुनः निष्पादनं आरभते तथा च yield expression इत्यस्य परिणामं प्रत्यागच्छति ।
3. त्रुटिनियन्त्रणम्: अतुल्यकालिकसञ्चालनेषु त्रुटयः गृहीतुं संसाधितुं च शक्यन्ते ।
4. श्रृङ्खला आह्वान: भवान् अतुल्यकालिक-क्रियाणां श्रृङ्खलां निर्मातुम् अर्हति, प्रत्येकं क्रिया पूर्व-क्रियायाः समाप्तेः अनन्तरं आरभ्यते ।

1. मूलभूत अतुल्यकालिक जनरेटर कार्य

function delay(time) {
    return new Promise(resolve => setTimeout(resolve, time));
}

function* asyncGenerator() {
    console.log("Start");
    yield delay(1000); // 等待1秒
    console.log("After 1 second");
    yield delay(1000); // 再等待1秒
    console.log("After another second");
    return "Done";
}

let gen = asyncGenerator();

function runGenerator(g) {
    let result = g.next();
    result.value.then(() => {
        if (!result.done) {
            runGenerator(g);
        }
    });
}

runGenerator(gen);
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

2. Use for...of and async...wait syntax sugar इति

// 假设我们有以下 async generator
async function* asyncGen() {
    yield await Promise.resolve(1);
    yield await Promise.resolve(2);
    yield await Promise.resolve(3);
}

// 我们可以使用 for...of 循环和 async...await 语法糖来简化调用
(async () => {
    for await (let value of asyncGen()) {
        console.log(value); // 依次输出 1, 2, 3
    }
})();
1
2
3
4
5
6
7
8
9
10
11
12
13

3. अतुल्यकालिकसञ्चालनेषु दोषाणां नियन्त्रणम्

function* asyncGenWithError() {
    try {
        yield Promise.reject("Error occurred!");
    } catch (e) {
        console.log(e); // 输出：Error occurred!
    }
}

let genWithError = asyncGenWithError();

genWithError.next().value.catch(err => console.log(err));
1
2
3
4
5
6
7
8
9
10
11

4. अन्येषु अतुल्यकालिकजनरेटर् कार्येषु प्रत्यायोजयितुं yield* इत्यस्य उपयोगं कुर्वन्तु

function* innerAsyncGen() {
    yield Promise.resolve("A");
    yield Promise.resolve("B");
}

function* outerAsyncGen() {
    yield "Start";
    yield* innerAsyncGen(); // 委托给另一个异步 Generator 函数
    yield "End";
}

let outerGen = outerAsyncGen();

function runOuterGenerator(g) {
    let result = g.next();
    result.value.then(val => {
        if (!result.done) {
            runOuterGenerator(g);
        }
    });
}

runOuterGenerator(outerGen);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23