Os geradores são um estilo de javascript coroutine (coroutina). Refere -se a funções que podem ser paradas e depois retomadas durante a execução. A função é acompanhada por símbolos de asterisco na função, como função*, e algumas palavras -chave características na função, como rendimento e rendimento*.
função* generatorfn () {console.log ('look ma eu estava suspenso')} var generator = generatorfn () // [1] setTimeout (function () {generator.next () // [2]}, 2000)Os [1] e [2] marcados no código são explicados da seguinte forma:
1. Este é um gerador que começa com uma pausa. Não há saída de console no momento.
2. Somente chamando seu método próximo (), o gerador pode ser executado e executado até encontrar a próxima palavra -chave de rendimento ou retornar. Agora temos a saída do console.
Vejamos outro caso:
function *generator () {console.log ('start!'); var i = 0; while (true) {if (i <3) produz i ++; }} var gen = generator ();O código acima é semelhante ao primeiro, mas há uma palavra -chave de rendimento adicional na função do gerador. Quando o código acima for chamado, ele não será executado imediatamente, mas pausará o estado de espera, para que não haja saída inicial. Não é executado até sua próxima chamada ().
var ret = gen.next (); // start! console.log (ret); // {value: 0, feito: false}O RET acima é o resultado do gerador. Tem duas propriedades:
■ Valor, valor de rendimento na função do gerador,
■ Feito, este é um sinalizador indicando se a função do gerador retorna.
Continue o código da seguinte forma:
console.log (gen.Next ()); // {value: 1, feito: false} console.log (gen.next ()); // {value: 2, feito: false} console.log (gen.Next ()); // {value: undefined, feito: verdadeiro}}O gerador não tem mistério na programação síncrona e é especialmente adequado para programação assíncrona.
O gerador tem duas características:
1. Você pode optar por sair de uma função, deixe o código externo decidir quando voltar a essa função e continuar a execução.
2. Capaz de realizar controle assíncrono.
Veja o seguinte código de execução assíncrona:
var gen = generator (); console.log (gen.Next (). value); setTimeout (function () {console.log (gen.Next (). value); console.log ('primeiro passo');}, 1000); console.log ('Segunda etapa');A saída é:
0
Etapa 2
1
primeiro passo
Em outras palavras, você não esperará o tempo limite terminar no setTimeout, mas continuará diretamente com o "segundo passo" e não será bloqueado no setTimeout.
Vejamos outro pedaço de código:
function* canal () {var name = rendimento 'Olá, qual é o seu nome?' // [1] retorna 'Bem, oi' + nome} var gen (canal () console.log (gen.next (). [2] Console.log (gen.Next ('billy')) // Bem, o seu Billy [3]Você também pode usar * durante o Traversal:
function* iter () {for (var i = 0; i <10; i ++) rendimento i} para (var val de iter ()) {console.log (val) // saídas 1? -? 9}Mal -entendidos comuns
Como posso pausar uma execução de função, devo deixá -los executar em paralelo? Não, porque o JavaScript é um único thread e, se você deseja buscar melhorias de desempenho, o gerador não é o seu prato.
Por exemplo, o código a seguir executa números de Fibonacci separadamente:
function fib (n) {var atual = 0, próximo = 1, troca para (var i = 0; i <n; i ++) {swap = corrente, corrente = a seguir = swap+swap+a seguir} retornar atual} função* fibgen (n) {var atual = 0, a seguir = 1, swap para (var i = 0; i <n; i ++) {{Os resultados do desempenho são os seguintes: (quanto maior, melhor)
Resultados:
1263899 regular
Gerador 37541
Geradores brilham
Os geradores podem simplificar a complexidade das funções no JavaScript.
Atribuição preguiçosa
Embora a atribuição preguiçosa possa ser implementada usando o fechamento de JS, o uso do rendimento simplificará bastante. Através da pausa e recuperação, podemos obter valores numéricos quando precisamos. Por exemplo, a função FibGen acima pode puxar novos valores quando precisamos:
var fibiter = fibgen (20) var a seguir = fibiter.Next () console.log (next.value) setTimeout (function () {var next = fibiter.Next () console.log (next.value)}, 2000), é claro, ele também usa um loop: é preguiçoso (var n de fibgen), é claro que é um loop: (e o cenário), que ainda é atribuído a (não é preguiçoso (n), que ainda é preguiçoso (e), que ainda é atribuído a (não), que ainda é preguiçoso (), que ainda é atribuído a (n), que ainda é atribuído a (n), que ainda é atribuído a (n), que ainda é atribuído a (n), que ainda é atribuído a (não é atribuído (e), que ainda é atribuído a (não é preguiçoso ()}, 2000), que ainda é atribuído a (não é preguiçoso (n)}, n).Sequência infinita
Como você pode ter preguiça de atribuir valores, você pode executar alguns truques Haskell, semelhantes às seqüências infinitas. Aqui você pode produzir o número de uma sequência infinita.
função* fibgen () {var fren = 0, próximo = 1, troca while (true) {swap = current = a próxima = swap + swap + rendimento de corrente}}Vejamos a atribuição preguiçosa de um fluxo de Fibonacci e solicite que ele retorne o primeiro número de Fibonacci após 5000:
para (var num de fibgen ()) {if (num> 5000) quebra} console.log (num) // 6765Controle de processo assíncrono
Usando geradores para implementar o controle de processos assíncronos, geralmente vários pacotes de bibliotecas de promessas, então como funciona?
No mundo dos nós, tudo está relacionado a retornos de chamada, que é a nossa função assíncrona de baixo nível. Podemos usar geradores para criar um canal de comunicação, para escrever código assíncrono no estilo de programação síncrona.
RUN (function* () {console.log ("Iniciando") var arquivo = hield readfile ("./ async.js") // [1] console.log (file.toString ())})Nota 1 significa que o programa continuará antes de aguardar o Async.js retornar o resultado.
Genify é uma estrutura que leva os geradores a um ambiente de programação normal, usando o seguinte:
NPM Instale Genify para instalação, o código é o seguinte:
var q = requer ('q'); var fs = requer ('fs'); var genify = requer ('genify'); // enrole seu objeto em genify functionVar objeto = genify ({concatfiles: function * (file1, file2, outfile) {file1 = rendimento q.nfcall (fs.readfile, file1); file2 = rendimento q.nfcall (fs.readfile, file2); var concedido = file1 + file2; rendimento q.nfcn (file1); }}); // ConcatFiles é uma função geradora que usa os poderosos recursos dos geradores. object.ConcatFiles ('./ SomeFile1.txt', './womefile2.txt', './concated.txt').then(function (res) {// Faça algo com resultado}, function (err) {// faça algo com erro});A explicação detalhada acima do uso de geradores JavaScript no Node.js é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.