Trechos de códigos para a palestra "O Poder do Generator"

codes.js

// - Symbol

// Sintaxe
Symbol(); // symbol

console.log(Symbol()); // imprime "Symbol()" no console

typeof Symbol(); //'symbol'

// Valoração
console.log(Symbol('qualquer_valor')); // imprime "Symbol(foo)" no console.

const stringSymbol = 'Um valor qualquer';
console.log(stringSymbol); // Um valor qualquer

const objectSymbol = {};
console.log(objectSymbol); // {}

//---

// Chaveamento de objetos
const chaveSymbol = Symbol('chave_1');
const meuObj = {};

meuObj['nome'] = 'Maria';
meuObj[primeiroSym] = 'Algum valor';

console.log(meuObj); // { nome: "Maria", Symbol(chave_1): "Algum valor" }
console.log(meuObj[chaveSymbol]); // Algum valor

//---

// Valores únicos
Symbol() === Symbol(); // false
Symbol('A') === Symbol('B'); // false
Symbol('A') === Symbol('A'); // false

const foo1 = Symbol('foo');
const foo2 = Symbol('foo');
const object = {
    [foo1]: 1,
    [foo2]: 2,
};
object[foo1] === 1; // true 
object[foo2] === 2; // true

// - Iterable & Iterator

const arr = [];

arr.__proto__;
// console
concat: ƒ concat()
constructor: ƒ Array()
copyWithin: ƒ copyWithin()
entries: ƒ entries()
(...)
unshift: ƒ unshift()
values: ƒ values()
Symbol(Symbol.iterator): ƒ values()

// string iterator
const someString = 'hi';
typeof someString[Symbol.iterator]; // "function"

const iterator = someString[Symbol.iterator]();

iterator.next(); // { value: "h", done: false }
iterator.next(); // { value: "i", done: false }
iterator.next(); // { value: undefined, done: true }

// Alterando um iterator
const minhaString = new String('oi');

minhaString[Symbol.iterator] = function() {
  // este é o objeto do iterator, 
  // retornando um "bye" 
  return {
    _first: true, // eu adicionei esse atributo
    next: function() {
      if (this._first) {
        this._first = false;
        return { value: 'tchau', done: false };
      } else {
        return { done: true };
      }
    }
  };
};

[...minhaString]; // ['tchau']

// ---

// - generators

const generatorObject = function* () {
    yield 1;
    yield 2;
    yield 3;
}();

generatorObject.next(); // {value: 1, done: false}
generatorObject.next(); // {value: 2, done: false}
generatorObject.next(); // {value: 3, done: false}
generatorObject.next(); // {value: undefined, done: true}

// generator é um iterator e iterable
const generatorObject = function* () {
    yield 1;
    yield 2;
    yield 3;
}();

typeof generatorObject.next;
// "function", por que tem o método next(), logo é um iterator
typeof generatorObject[Symbol.iterator];
// "function", então é um iterable
generatorObject[Symbol.iterator]() === generatorObject;
// true, por que o método que o torna um iterable retorna ele mesmo (um iterator)

[...generatorObject]; // [1, 2, 3]

// dois generators

function* outroGerador(i) {
  yield i + 1;
  yield i + 2;
  yield i + 3;
}

function* gerador(i){
  yield i;
  yield* outroGerador(i);
  yield i + 10;
}

const gen = gerador(10);

console.log(gen.next().value); // 10
console.log(gen.next().value); // 11
console.log(gen.next().value); // 12

// generators passando parâmetros

function* logGenerator() {
  console.log(0);
  console.log(1, yield);
  console.log(2, yield);
  console.log(3, yield);
}

const gen = logGenerator();

// a primeira chamada next é executada desde o início da função
// até a primeira declaração yield
gen.next(); // 0
gen.next('oi'); // 1 oi
gen.next('oi denovo'); // 2 oi denovo
gen.next('oi mais uma vez'); // 3 oi mais uma vez