Iteradores e Geradores no JavaScript.
Tags: javascript, beginners, programming
Published: 2023-02-06 18:24:38

Iteradores e Geradores são conceitos importantes no JavaScript que ajudam a trabalhar com dados. Eles permitem que você trabalhe com eles de maneira mais fácil, organizada e eficiente. Vamos explorar o que são iteradores e geradores, como funcionam e alguns exemplos para ajudá-lo a entender melhor. Veremos agora como funcionam os iteradores e geradores.

**O que são Iteradores? -**

Iteradores são objetos que representam uma sequência de valores. Eles fornecem uma maneira de percorrer essa sequência de valores de forma controlada.

Por exemplo: em JavaScript, qualquer objeto que implemente o método `next()` é considerado um iterador. O método `next()`retorna um objeto com duas propriedades: `value` e `done`. A propriedade `value` contém o próximo valor na sequência e a propriedade `done` indica se a sequência já foi percorrida completamente.

```
const numbers = [1, 2, 3, 4, 5];
const iterator = numbers[Symbol.iterator]();

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: 4, done: false }
console.log(iterator.next()); // { value: 5, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
```

No código acima, o método `next` retorna o próximo valor na sequência até que a sequência tenha sido percorrida completamente, quando o valor de `done` é verdadeiro.



Existem também os caso da estrutura `for...of`. Normalmente o `for` é usado principalmente para iterar sequências/coleções, onde um contador é usado para acompanhar todos os elementos na sequência.  Já o `for...of` pode resumir a estrutura padrão encurtando o processo.


```
var nums = [1, 5, 16];

for (var num of nums) {
   console.log(num);
}
```


**O que são Geradores? -**

Já os geradores são uma forma especial de funções que retornam iteradores.

Por exemplo, suponha que queremos trabalhar com uma sequência de todos os números pares até um milhão, ou todos os números quadrados menores que setenta mil, ou ainda, todos os números primos menores que um determinado número Y. Não queremos criar as sequências desejadas de uma só vez, mas sim gerá-las uma a uma. Nesse caso é necessário um gerador JavaScript

Eles são definidos com a sintaxe `function*` e incluem a palavra-chave `yield` para controlar a sequência de valores retornados pelo iterador. Quando a função geradora é invocada, ela não é executada imediatamente. Em vez disso, ela retorna um iterador que pode ser usado para controlar a execução da função.

```
function* gen() {
  yield 1;
  yield 2;
  yield 3;
}

var g = gen(); // "Generator { }"
```

Para facilitar o entendimento, veja um gerador simples:

```
function positiveInts(n) {
   var i = 1;
   var max = (n < 1 || typeof n !== "number") ? 1 : n;
   return {
      next: function() {
         if (i > max) return {value: undefined, done: true}
         return {value: i++, done: false}
      }
   }
}
```

Percebe que nesse caso, a função só declara aquele valor até que o valor desejado seja alcançado. A instrução na linha 5 verifica se `i` é maior que max e, se for, retorna o objeto{value: undefined, done: true}.

Vale lembrar algo importante: Um gerador simplesmente define uma sequência com a ajuda de um objeto iterador; ele NÃO cria a sequência de uma só vez.


Em uma conclusão simples: Iteradores em JavaScript são objetos que permitem acessar itens em uma coleção sequencialmente, como arrays ou outros objetos iteráveis. Eles são usados para percorrer os itens em uma coleção e realizar ações sobre eles.

Já os geradores são funções especiais que podem ser pausadas e retomadas em uma sequência de passos. Eles fornecem uma maneira de criar iteradores personalizados que não precisam ser carregados completamente na memória.


Obrigado por ler!