ES6의 Generator 자동 실행에 대한 자세한 설명

이 글은 ES6의 Generator 자동 실행에 대한 자세한 설명을 제공합니다. 필요한 친구들이 참고할 수 있기를 바랍니다.

단일 비동기 작업

var fetch = require('node-fetch');

function* gen(){
    var url = 'https://api.github.com/users/github';
    var result = yield fetch(url);
    console.log(result.bio);
}

최종 실행 결과를 얻으려면 다음을 수행해야 합니다.

var g = gen();
var result = g.next();

result.value.then(function(data){
    return data.json();
}).then(function(data){
    g.next(data);
});

먼저 생성기 함수를 실행하여 traverser 개체를 가져옵니다.

그런 다음 다음 메서드를 사용하여 비동기 작업의 첫 번째 단계인 fetch(url)를 실행합니다.

fetch(url)은 Promise 개체를 반환하므로 결과 값은 다음과 같습니다.

{ value: Promise { <pending> }, done: false }</pending>

마지막으로 이 Promise 개체에 then 메서드를 추가하고 먼저 반환된 데이터의 형식을 지정합니다(data.json()). 그런 다음 g.next를 호출하여 획득한 데이터를 전달하면 비동기 작업의 두 번째 단계가 실행되고 코드 실행이 완료됩니다.

여러 비동기 작업

마지막 섹션에서는 하나의 인터페이스만 호출했기 때문에 여러 인터페이스를 호출하고 여러 Yield를 사용한다면 계속해서 then 함수에 중첩시켜야 하지 않을까...

그래서 여러 비동기 작업을 실행하는 상황을 살펴보겠습니다.

var fetch = require('node-fetch');

function* gen() {
    var r1 = yield fetch('https://api.github.com/users/github');
    var r2 = yield fetch('https://api.github.com/users/github/followers');
    var r3 = yield fetch('https://api.github.com/users/github/repos');

    console.log([r1.bio, r2[0].login, r3[0].full_name].join('\n'));
}

최종 실행 결과를 얻으려면 다음과 같이 작성해야 할 수도 있습니다.

var g = gen();
var result1 = g.next();

result1.value.then(function(data){
    return data.json();
})
.then(function(data){
    return g.next(data).value;
})
.then(function(data){
    return data.json();
})
.then(function(data){
    return g.next(data).value
})
.then(function(data){
    return data.json();
})
.then(function(data){
    g.next(data)
});

하지만 절대 이렇게 작성하고 싶지 않을 거라는 걸 압니다..

실제로 재귀를 사용하면 다음과 같이 작성할 수 있습니다.

function run(gen) {
    var g = gen();

    function next(data) {
        var result = g.next(data);

        if (result.done) return;

        result.value.then(function(data) {
            return data.json();
        }).then(function(data) {
            next(data);
        });

    }

    next();
}

run(gen);

핵심은 양보할 때 Promise 객체를 반환하고, 이 Promise 객체에 then 메서드를 추가하고, 비동기 작업이 성공하면 실행하는 것입니다. 그런 다음 onFullfilled 함수는 onFullfilled 함수에서 g.next를 실행하여 생성기가 다음을 수행할 수 있도록 합니다. 실행을 계속한 다음 Promise를 반환하고 성공 시 g.next를 실행한 다음 반환합니다...

Launcher 함수

Run Launcher 함수에서는 then 함수 .json()에서 데이터 형식을 지정하지만 보다 일반적인 경우, 예를 들어 fetch 함수에서 반환된 Promise 대신 Yield 바로 뒤에 Promise가 옵니다. json 메서드가 없기 때문에 코드에서 오류를 보고합니다. 따라서 보다 다양하게 활용하기 위해 이 예제 및 스타터와 함께 다음과 같이 수정했습니다.

var fetch = require('node-fetch');

function* gen() {
    var r1 = yield fetch('https://api.github.com/users/github');
    var json1 = yield r1.json();
    var r2 = yield fetch('https://api.github.com/users/github/followers');
    var json2 = yield r2.json();
    var r3 = yield fetch('https://api.github.com/users/github/repos');
    var json3 = yield r3.json();

    console.log([json1.bio, json2[0].login, json3[0].full_name].join('\n'));
}

function run(gen) {
    var g = gen();

    function next(data) {
        var result = g.next(data);

        if (result.done) return;

        result.value.then(function(data) {
            next(data);
        });

    }

    next();
}

run(gen);

Yield 뒤에 Promise 개체가 있는 한 이 실행 함수를 사용하여 생성기 함수를 자동으로 실행할 수 있습니다.

콜백 함수

제너레이터의 자동 실행을 보장하려면 Promise 객체가 뒤에 와야 합니까? 단지 콜백 함수라면 어떨까요? 예를 살펴보겠습니다.

먼저 일반적인 비동기 요청을 시뮬레이션합니다.

function fetchData(url, cb) {
    setTimeout(function(){
        cb({status: 200, data: url})
    }, 1000)
}

이 함수를 다음과 같이 변환합니다.

function fetchData(url) {
    return function(cb){
        setTimeout(function(){
            cb({status: 200, data: url})
        }, 1000)
    }
}

이러한 생성기 함수의 경우:

function* gen() {
    var r1 = yield fetchData('https://api.github.com/users/github');
    var r2 = yield fetchData('https://api.github.com/users/github/followers');

    console.log([r1.data, r2.data].join('\n'));
}

최종 결과를 얻으려는 경우:

var g = gen();

var r1 = g.next();

r1.value(function(data) {
    var r2 = g.next(data);
    r2.value(function(data) {
        g.next(data);
    });
});

이렇게 작성하면 첫 번째 섹션과 동일한 문제에 직면하게 됩니다. 즉, 여러 Yield를 사용하면 코드가 루프에 중첩됩니다...

Recursion도 사용되므로 다음과 같이 변환할 수 있습니다.

function run(gen) {
    var g = gen();

    function next(data) {
        var result = g.next(data);

        if (result.done) return;

        result.value(next);
    }

    next();
}

run(gen);

run

제너레이터 함수의 자동 실행에는 메커니즘이 필요하다는 것을 알 수 있습니다. 즉, 비동기 작업의 결과가 나오면 실행 권한이 자동으로 반환될 수 있습니다.

이를 수행하는 방법에는 두 가지가 있습니다.

(1) 콜백 함수. 비동기 작업을 래핑하고, 콜백 함수를 노출하고, 콜백 함수에서 실행 권한을 반환합니다.

(2) 약속 개체. 비동기 작업을 Promise 객체로 래핑하고 then 메서드를 사용하여 실행 권한을 반환합니다.

두 메소드 각각에 실행 실행기 함수를 작성했습니다. 이 두 메소드를 결합하여 일반 실행 함수를 작성할 수 있나요? 시도해 보세요:

// 第一版
function run(gen) {
    var gen = gen();

    function next(data) {
        var result = gen.next(data);
        if (result.done) return;

        if (isPromise(result.value)) {
            result.value.then(function(data) {
                next(data);
            });
        } else {
            result.value(next)
        }
    }

    next()
}

function isPromise(obj) {
    return 'function' == typeof obj.then;
}

module.exports = run;

사실 구현은 매우 간단합니다. result.value가 Promise인지 확인하세요. 그렇다면 then 함수를 추가하세요.

return Promise

우리는 콜백 함수 또는 Promise 개체가 뒤따르는 항복을 지원하는 멋진 시작 함수를 작성했습니다.

이제 생각해 봐야 할 질문이 있습니다. 즉, Generator 함수의 반환 값을 어떻게 얻을 수 있습니까? 존재하지 않는 인터페이스를 가져오는 등 Generator 함수에서 오류가 발생하는 경우 이 오류를 어떻게 잡을 수 있나요?

생각하기 쉽습니다. Promise, 이 시작 함수가 Promise를 반환하면 이 Promise 객체에 then을 추가할 수 있습니다. 모든 비동기 작업이 성공적으로 실행되면 onFullfilled 함수를 실행하고, 실패할 경우 onRejected 함수를 실행합니다.

버전을 작성합니다:

// 第二版
function run(gen) {
    var gen = gen();

    return new Promise(function(resolve, reject) {

        function next(data) {
            try {
                var result = gen.next(data);
            } catch (e) {
                return reject(e);
            }

            if (result.done) {
                return resolve(result.value)
            };

            var value = toPromise(result.value);

            value.then(function(data) {
                next(data);
            }, function(e) {
                reject(e)
            });
        }

        next()
    })

}

function isPromise(obj) {
    return 'function' == typeof obj.then;
}

function toPromise(obj) {
    if (isPromise(obj)) return obj;
    if ('function' == typeof obj) return thunkToPromise(obj);
    return obj;
}

function thunkToPromise(fn) {
    return new Promise(function(resolve, reject) {
        fn(function(err, res) {
            if (err) return reject(err);
            resolve(res);
        });
    });
}

module.exports = run;

첫 번째 버전과 매우 다릅니다:

먼저 프라미스(Promise)를 반환합니다. result.done이 true이면 값을 해결(result.value)합니다. 집행을 하고 적발되면 그 이유를 거부합니다.

두 번째로 thunkToPromise를 사용하여 콜백 함수를 Promise로 래핑한 다음 then 함수를 균일하게 추가하겠습니다. 여기서 thunkToPromise 함수에서는 오류 원칙을 먼저 따른다는 점에 주목할 가치가 있습니다. 즉, 콜백 함수의 상황을 처리할 때 다음과 같습니다.

// 模拟数据请求
function fetchData(url) {
    return function(cb) {
        setTimeout(function() {
            cb(null, { status: 200, data: url })
        }, 1000)
    }
}

성공 시 첫 번째 매개변수는 null을 반환해야 하며 이는 오류가 있음을 나타냅니다. 오류 이유 없음.

Optimization

두 번째 버전을 기반으로 코드를 더욱 간결하고 우아하게 작성했습니다. 최종 코드는 다음과 같습니다.

// 第三版
function run(gen) {

    return new Promise(function(resolve, reject) {
        if (typeof gen == 'function') gen = gen();

        // 如果 gen 不是一个迭代器
        if (!gen || typeof gen.next !== 'function') return resolve(gen)

        onFulfilled();

        function onFulfilled(res) {
            var ret;
            try {
                ret = gen.next(res);
            } catch (e) {
                return reject(e);
            }
            next(ret);
        }

        function onRejected(err) {
            var ret;
            try {
                ret = gen.throw(err);
            } catch (e) {
                return reject(e);
            }
            next(ret);
        }

        function next(ret) {
            if (ret.done) return resolve(ret.value);
            var value = toPromise(ret.value);
            if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
            return onRejected(new TypeError('You may only yield a function, promise ' +
                'but the following object was passed: "' + String(ret.value) + '"'));
        }
    })
}

function isPromise(obj) {
    return 'function' == typeof obj.then;
}

function toPromise(obj) {
    if (isPromise(obj)) return obj;
    if ('function' == typeof obj) return thunkToPromise(obj);
    return obj;
}

function thunkToPromise(fn) {
    return new Promise(function(resolve, reject) {
        fn(function(err, res) {
            if (err) return reject(err);
            resolve(res);
        });
    });
}

module.exports = run;

co

如果我们再将这个启动器函数写的完善一些，我们就相当于写了一个 co，实际上，上面的代码确实是来自于 co……

而 co 是什么？ co 是大神 TJ Holowaychuk 于 2013 年 6 月发布的一个小模块，用于 Generator 函数的自动执行。

如果直接使用 co 模块，这两种不同的例子可以简写为：

// yield 后是一个 Promise
var fetch = require('node-fetch');
var co = require('co');

function* gen() {
    var r1 = yield fetch('https://api.github.com/users/github');
    var json1 = yield r1.json();
    var r2 = yield fetch('https://api.github.com/users/github/followers');
    var json2 = yield r2.json();
    var r3 = yield fetch('https://api.github.com/users/github/repos');
    var json3 = yield r3.json();

    console.log([json1.bio, json2[0].login, json3[0].full_name].join('\n'));
}

co(gen);

// yield 后是一个回调函数
var co = require('co');

function fetchData(url) {
    return function(cb) {
        setTimeout(function() {
            cb(null, { status: 200, data: url })
        }, 1000)
    }
}

function* gen() {
    var r1 = yield fetchData('https://api.github.com/users/github');
    var r2 = yield fetchData('https://api.github.com/users/github/followers');

    console.log([r1.data, r2.data].join('\n'));
}

co(gen);

是不是特别的好用？

위 내용은 ES6의 Generator 자동 실행에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!