Node.js Generators e comparar com retornos de chamada
⚡ Resumo Inteligente
GeneratorEm Node.js, funções são funções cuja execução pode ser suspensa e retomada sob demanda. A palavra-chave `yield` pausa a função, o método `next` a retoma, e essa combinação transforma callbacks profundamente aninhados em código sequencial legível.

Neste tutorial, vamos analisar os geradores e como eles diferem dos callbacks.
O que são geradores?
Generators tornou-se popular em Node.js por causa do que eles são capazes de fazer.
- Generators são execuções de funções que podem ser suspensas e retomadas posteriormente.
- GeneratorOs `s` são úteis para conceitos como "execução preguiçosa". Ao suspender a execução e retomá-la conforme necessário, os valores são obtidos somente quando precisos.
GeneratorOs sistemas possuem os dois métodos principais descritos abaixo.
- Método de rendimento — chamada dentro de uma função para interromper a execução exatamente na linha onde
yieldaparece. - Próximo método — chamada a partir da aplicação principal para retomar uma função que foi interrompida. A execução continua até a próxima chamada.
yieldou até o final da função.
Vejamos um exemplo de como os geradores podem ser usados. O exemplo define uma função simples de adição que soma dois números, interrompendo a execução em pontos diferentes para mostrar como os geradores se comportam.
function* Add(x) { yield x + 1; // The value passed into the second next() call lands here var y = yield(null); return x + y; } var gen = Add(5); gen.next(); // runs to the first yield, returns { value: 6, done: false } gen.next(6); // resumes, y becomes 6, returns { value: 11, done: true }
Code Explicação
- O primeiro passo é definir a função geradora. Observe o
*adicionado aofunctionpalavra-chave. A função é chamadaAdde recebe um parâmetrox. - O
yieldA palavra-chave é específica para geradores e pausa a função no meio da execução. A execução é interrompida aqui até que...next()é invocado. - O segundo
yieldambas as funções pausam e recebem um valor: qualquer valor que seja passado para a seguinte função.next()a chamada se torna o valor dey. - chamada
gen.next()Na primeira execução, a função vai até o primeiro ponto.yield. Chamandogen.next(6)retoma o processo e atribui 6 ay, e retornax + y.
⚠️ Correção: a listagem original continha a linha y = 6 imediatamente depois var y = yield(null);Essa atribuição sobrescreve qualquer valor. next() suprimentos, o que frustra o propósito do exemplo e torna o segundo yield sem sentido. O valor agora é transmitido através de gen.next(6), que é como um gerador realmente recebe dados do chamador.
Callbacks vs geradores
GeneratorAs funções de callback resolvem o problema conhecido como "inferno de callbacks". Durante o desenvolvimento de uma aplicação Node.js, as funções de callback podem ficar tão aninhadas que se tornam difíceis de acompanhar.
É aqui que os geradores ajudam. Um dos exemplos mais comuns é a criação de funções de temporizador. O exemplo abaixo cria uma função simples de atraso de tempo e, em seguida, a chama com atrasos de 1000, 2000 e 3000 ms.
Passo 1) Defina a função de retorno de chamada com o código de atraso de tempo necessário.
function Timedelay(ptime, callback) { setTimeout(function() { callback("Pausing for " + ptime); }, ptime); // the delay must use ptime, the parameter name }
Code Explicação
- Uma função chamada
Timedelayé criado com um parâmetroptime, que indica o número de milissegundos durante os quais a pausa deve ocorrer. setTimeoutAguarda esse número de milissegundos e então invoca a função de retorno de chamada fornecida.
⚠️ Correção: o código original passou time como o segundo argumento para setTimeout, mas nenhuma variável chamada time existe — o parâmetro é ptime. Conforme escrito, lança ReferenceError: time is not defined.
Passo 2) Agora, considere o código que utiliza callbacks. Para encadear atrasos de 1000, 2000 e 3000 milissegundos, os callbacks são aninhados uns dentro dos outros.
Timedelay(1000, function(message) { console.log(message); Timedelay(2000, function(message) { console.log(message); Timedelay(3000, function(message) { console.log(message); }); }); });
Code Explicação
Timedelayé chamada como um retorno de chamada com o valor 1000.- Dentro desse retorno de chamada,
Timedelayé chamado novamente com 2000. - Dentro daquele,
Timedelayé chamada uma terceira vez com 3000.
⚠️ Correção: cada retorno de chamada no registro original msg, mas o parâmetro é nomeado messageTodas as três linhas lançaram ReferenceError: msg is not defined.
Pelo código acima, você pode ver que ele fica mais confuso a cada chamada adicional — esse aninhamento é o que o inferno de callbacks descreve.
Passo 3) Agora veja o mesmo comportamento escrito com geradores. A sequência é lida como três linhas retas em vez de três níveis de aninhamento.
function* Messages() { console.log(yield Timedelay(1000)); console.log(yield Timedelay(2000)); console.log(yield Timedelay(3000)); }
Code Explicação
- Uma função geradora é definida para chamar a
Timedelayfunção. yieldé usado comTimedelaye 1000 como valor do parâmetro.yieldÉ usado novamente com 2000 e mais uma vez com 3000.
⚠️ Correção: o original escreveu console,log(...) Com uma vírgula em vez de um ponto em todas as três linhas, o que é um erro de sintaxe e impede completamente a análise do arquivo.
Como executar um Generator com função de corredor
O gerador acima é visualmente impressionante, mas não fará nada sozinho. Este é o detalhe que a maioria das explicações omite, e é por isso que a versão simplificada pode parecer mágica. Um gerador é uma máquina pausada, e algo precisa continuar pressionando o botão. Chamando Messages() O método simplesmente cria o objeto gerador e retorna imediatamente; nenhum temporizador é iniciado e nada é impresso.
A peça que falta é um executor: uma pequena função que chama next(), aguarda a conclusão do trabalho assíncrono e, em seguida, chama next() Novamente com o resultado.
// Timedelay now hands its result back to the runner function Timedelay(ptime) { return function(resume) { setTimeout(function() { resume("Pausing for " + ptime); }, ptime); }; } // The runner drives the generator to completion function run(generatorFunction) { var it = generatorFunction(); function step(value) { var result = it.next(value); if (result.done) return; // result.value is the function returned by Timedelay result.value(step); } step(); } run(Messages);
Três pontos fazem isso funcionar. Primeiro, Timedelay não recebe mais um callback diretamente; retorna uma função que o executor pode invocar, devolvendo o controle quando o temporizador dispara. Segundo, it.next(value) alimenta o gerador pausado com o resultado anterior, o que permite yield Aparecer no lado direito de uma tarefa. Terceiro, o corredor para assim que result.done se torna verdadeira, então a recursão termina naturalmente. Esse padrão de execução é exatamente o que bibliotecas como o co fornecem, e é o mecanismo que async/await posteriormente absorvida pela própria língua.
Generators vs async/await: qual usar?
GeneratorAntes, os s eram a maneira padrão de escrever código assíncrono simples. async/await existiam, e ambos compartilham a mesma ideia subjacente de pausar uma função no meio da sua execução. O Node oferece suporte a isso. async/await nativamente desde a versão 7.6, o que altera a recomendação para qualquer pessoa que esteja começando um novo trabalho hoje.
| Aspecto | Generators | assíncrono / aguardar |
|---|---|---|
| Precisa-se de corredor | Sim, escrito por você ou por uma biblioteca. | Não, está incorporado ao idioma. |
| Palavra-chave de pausa | yield |
await |
| Tratamento de erros | O corredor deve encaminhar os erros. | Tentativa e captura comuns |
| Pode pausar a meio caminho | Sim, e pode ser retomado seletivamente. | Não, corre até o fim. |
| Melhor para | Sequências preguiçosas e fluxos infinitos | Trabalho assíncrono comum |
Uso async/await Para fluxos assíncronos em código novo, isso remove o executor e restaura o uso de blocos try e catch comuns. Reserve os geradores para o que eles fazem bem: produzir valores de forma preguiçosa, iterar sequências grandes ou infinitas e em qualquer caso em que o consumidor decide exatamente quando o próximo valor será calculado.
comum Generator Erros e como corrigi-los
A maioria dos problemas com geradores surge do esquecimento de que a função é inerte até que algo a chame. next()ou devido a pequenos erros de sintaxe em torno do asterisco. Cada sintoma abaixo indica sua causa e sua solução.
- Nada acontece quando o gerador é chamado: A chamada retorna um iterador, não um resultado.
next()Ou passe a bola para um corredor. - Erro de sintaxe ao executar `yield`: O asterisco está faltando.
yieldé válido apenas dentro de umfunction*. - O valor retornado por next() é indefinido: o primeiro
next()A chamada não pode retornar um valor, porque o gerador não atingiu um determinado nível.yieldNo entanto, envie dados a partir da segunda chamada. - Loop infinito em um programa de execução:
result.donenunca é verificado, entãonext()Continua sendo chamado após o término. Sempre retornar quando terminar é verdadeiro. - Os erros desaparecem silenciosamente: Uma rejeição dentro da etapa assíncrona nunca é repassada para o gerador. Encaminhe-a com
it.throw(err)para que um bloco try-catch escrito dentro do gerador possa efetivamente vê-lo e processá-lo.




