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.

  • ⏸️ Comportamento Essencial: Um gerador suspende a operação em cada ciclo de produção e retoma exatamente de onde parou quando o próximo ciclo é acionado.
  • ✳️ Declaração: Um asterisco após a palavra-chave `function` indica que a função é um gerador, e não um gerador comum.
  • 🔄 Canal bidirecional: O valor passado para `next` torna-se o resultado da expressão `yield` que pausou a função.
  • 🪆 Inferno do Callback: As funções de retorno aninhadas tornam-se ilegíveis à medida que etapas são adicionadas, e esse é o problema que os geradores foram adotados para resolver.
  • 🏃 Precisa-se de corredor: Um gerador não se autoexecuta; uma função executora deve chamar `next` repetidamente para que o trabalho assíncrono prossiga.
  • 🦥 Execução preguiçosa: Suspender e retomar a execução permite que um programa obtenha valores somente no momento em que eles são necessários.

Node.js Generators Comparado com Callbacks

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.

  1. Método de rendimento — chamada dentro de uma função para interromper a execução exatamente na linha onde yield aparece.
  2. 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.

Node.js Generators

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

  1. O primeiro passo é definir a função geradora. Observe o * adicionado ao function palavra-chave. A função é chamada Add e recebe um parâmetro x.
  2. O yield A 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.
  3. O segundo yield ambas 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 de y.
  4. chamada gen.next() Na primeira execução, a função vai até o primeiro ponto. yield. Chamando gen.next(6) retoma o processo e atribui 6 a y, e retorna x + 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.

Retornos de chamada vs. Generators

function Timedelay(ptime, callback) {

    setTimeout(function() {

        callback("Pausing for " + ptime);

    }, ptime);   // the delay must use ptime, the parameter name
}

Code Explicação

  1. Uma função chamada Timedelay é criado com um parâmetro ptime, que indica o número de milissegundos durante os quais a pausa deve ocorrer.
  2. setTimeout Aguarda 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.

Retornos de chamada vs. Generators

Timedelay(1000, function(message) {

    console.log(message);

    Timedelay(2000, function(message) {

        console.log(message);

        Timedelay(3000, function(message) {

            console.log(message);
        });
    });
});

Code Explicação

  1. Timedelay é chamada como um retorno de chamada com o valor 1000.
  2. Dentro desse retorno de chamada, Timedelay é chamado novamente com 2000.
  3. 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.

Retornos de chamada vs. Generators

function* Messages() {
    console.log(yield Timedelay(1000));
    console.log(yield Timedelay(2000));
    console.log(yield Timedelay(3000));
}

Code Explicação

  1. Uma função geradora é definida para chamar a Timedelay função.
  2. yield é usado com Timedelay e 1000 como valor do parâmetro.
  3. 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 um function*.
  • 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. yield No entanto, envie dados a partir da segunda chamada.
  • Loop infinito em um programa de execução: result.done nunca é verificado, então next() 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.

Perguntas Frequentes

Um objeto com duas propriedades: value, retendo tudo o que foi cedido, e done, um valor booleano que se torna verdadeiro quando o gerador termina. Os executores testam "done" para saber quando parar.

Sim. Um gerador contendo um loop infinito é seguro porque nada é computado até que next() seja chamado. Isso torna os geradores adequados para fluxos de identificadores ou resultados paginados.

Sim. Travas deslizantes portáteis AI As ferramentas trocam `yield` por `await` e descartam o executor completamente. RevAnalise cuidadosamente as sequências preguiçosas, pois um gerador que nunca termina não tem um equivalente direto para async/await.

Assistentes de IA trace se o executor parou de chamar next, se um callback de retomada nunca foi invocado ou se done nunca foi alcançado. Esses três fatores explicam quase todos os geradores paralisados.

Não. Um gerador assíncrono é declarado. async function* e é consumido com for await...ofEle combina ambas as ideias e é adequado para streaming de dados assíncronos, como cursores de banco de dados.

Resuma esta postagem com: