Também estou tentando entender a palavra-chave yield. Com base no meu entendimento atual, no gerador, a palavra-chave yield funciona como uma alternância de contexto da CPU. Quando a declaração de rendimento é executada, todos os estados (por exemplo, variáveis locais) são salvos.
Além disso, um objeto de resultado direto será retornado ao chamador, como {value: 0, done: false}. O chamador pode usar esse objeto de resultado para decidir se deseja 'ativar' o gerador novamente chamando next () (chamar next () é para iterar a execução).
Outra coisa importante é que ele pode definir um valor para uma variável local. Este valor pode ser passado pelo chamador 'next ()' ao 'acordar' o gerador. por exemplo, it.next ('valueToPass'), assim: "resultValue = yield slowQuery (1);" Assim como ao ativar uma próxima execução, o chamador pode injetar algum resultado em execução na execução (injetando-o na variável local). Assim, para esta execução, existem dois tipos de estado:
o contexto que foi salvo na última execução.
Os valores injetados pelo gatilho desta execução.
Portanto, com esse recurso, o gerador pode classificar várias operações assíncronas. O resultado da primeira consulta assíncrona será passado para a segunda, definindo a variável local (resultValue no exemplo acima). A segunda consulta assíncrona só pode ser acionada pela resposta da primeira consulta assíncrona. Em seguida, a segunda consulta assíncrona pode verificar o valor da variável local para decidir as próximas etapas, porque a variável local é um valor injetado da resposta da primeira consulta.
As dificuldades das consultas assíncronas são:
inferno de retorno de chamada
perda de contexto, a menos que sejam transmitidos como parâmetros no retorno de chamada.
rendimento e gerador podem ajudar em ambos.
Sem rendimento e gerador, para classificar várias consultas assíncronas, é necessário um retorno de chamada aninhado com parâmetros como contexto, o que não é fácil de ler e manter.
Abaixo está um exemplo de consultas assíncronas encadeadas que são executadas com o nodejs:
const axios = require('axios');
function slowQuery(url) {
axios.get(url)
.then(function (response) {
it.next(1);
})
.catch(function (error) {
it.next(0);
})
}
function* myGen(i=0) {
let queryResult = 0;
console.log("query1", queryResult);
queryResult = yield slowQuery('https://google.com');
if(queryResult == 1) {
console.log("query2", queryResult);
//change it to the correct url and run again.
queryResult = yield slowQuery('https://1111111111google.com');
}
if(queryResult == 1) {
console.log("query3", queryResult);
queryResult = yield slowQuery('https://google.com');
} else {
console.log("query4", queryResult);
queryResult = yield slowQuery('https://google.com');
}
}
console.log("+++++++++++start+++++++++++");
let it = myGen();
let result = it.next();
console.log("+++++++++++end+++++++++++");
Abaixo está o resultado atual:
+++++++++++ start +++++++++++
query1 0
+++++++++++ end +++++++++++
query2 1
query4 0
O padrão de estado abaixo pode fazer o mesmo no exemplo acima:
const axios = require('axios');
function slowQuery(url) {
axios.get(url)
.then(function (response) {
sm.next(1);
})
.catch(function (error) {
sm.next(0);
})
}
class StateMachine {
constructor () {
this.handler = handlerA;
this.next = (result = 1) => this.handler(this, result);
}
}
const handlerA = (sm, result) => {
const queryResult = result; //similar with generator injection
console.log("query1", queryResult);
slowQuery('https://google.com');
sm.handler = handlerB; //similar with yield;
};
const handlerB = (sm, result) => {
const queryResult = result; //similar with generator injection
if(queryResult == 1) {
console.log("query2", queryResult);
slowQuery('https://1111111111google.com');
}
sm.handler = handlerC; //similar with yield;
};
const handlerC = (sm, result) => {
const queryResult = result; //similar with generator injection;
if (result == 1 ) {
console.log("query3", queryResult);
slowQuery('https://google.com');
} else {
console.log("query4", queryResult);
slowQuery('https://google.com');
}
sm.handler = handlerEnd; //similar with yield;
};
const handlerEnd = (sm, result) => {};
console.log("+++++++++++start+++++++++++");
const sm = new StateMachine();
sm.next();
console.log("+++++++++++end+++++++++++");
A seguir, o resultado da execução:
+++++++++++ start +++++++++++
query1 0
+++++++++++ end +++++++++++
query2 1
query4 0