javascript - the - title html attribute

¿Puedo rendirme desde una función interior?

Question

Con los generadores ES6, veo código como este:

var trivialGenerator = function *(array) {
    var i,item;
    for(var i=0; i < array.length; i++){
        item = array[i];
        yield item;
    };
};

¿Es posible escribir algo más parecido al código de abajo?

var trivialGenerator = function *(array) {
    array.forEach(function *(item){
        yield item;
    });
};

Lo pregunto porque el clásico for bucle es una abominación.

Answer 1

No, no puedes rendirte de una devolución de llamada (técnicamente, no es una "función interna", que significa otra cosa). Obviamente, no hay forma de llamar a forEach con el equivalente de * , o, si la devolución de llamada en sí misma es un generador, decirle a forEach que invoque la devolución de llamada con yield * .

Una alternativa es escribir una función para forEachGen , de la siguiente manera:

function *forEachGen(array, fn) { for (var i of array) yield *fn(i); }

Básicamente moviendo el for-loop en forEachGen . Definiendo un pequeño generador de muestras como

function *yieldSelf(item) { yield item; }

forEachGen sería utilizado como

yield *forEachGen(array, yieldSelf);

Esto supone que la devolución de llamada es un generador en sí mismo, como parece implicar que quiere en su ejemplo. Si la devolución de llamada fuera un ROF (función antigua regular), como

function returnSelf(item) { return item; }

Entonces seria

function *forEachGen(array, fn) { for (var i of array) yield fn(i); }

Usado como

yield *forEachGen(array, returnSelf);

Si no le importa agregar esto al prototipo de matriz, entonces

Object.defineProperty(Array.prototype, ''forEachGen'', { value :
    function *(fn) { for (i of this) yield fn(i); }
});

entonces hazlo

yield *array.forEachGen(yieldSelf)

Puede estar interesado en http://fitzgen.github.io/wu.js/ , que define una envoltura para generadores con métodos como forEach en la envoltura.

async / await

Con await , deberías poder hacer lo siguiente.

Defina una devolución de llamada trivial que solo devuelve una promesa por sí misma.

async function returnSelf(item) { return await item; }

forEachAsync asigna la matriz de entrada a una serie de promesas, y usa await * para crear y devolver una promesa para todas las promesas individuales que están listas.

async function forEachAsync(values, fn) {
  return await *values.map(returnSelf);
}

Podemos tratar el resultado como una promesa regular e imprimirlo en un then :

forEachAsync([1,2,3], returnSelf) .
  then(result => console.log(result);

o use un poco de envoltorio async IIFE para esperar el resultado y luego imprímalo:

(async function() { 
    console.log(await forEachAsync([1,2,3], returnSelf));
})();

Probado usando

babel-node --experimental test.js

Answer 2

No, no puedes usar el yield dentro de la función interna. Pero en tu caso no lo necesitas. Siempre se puede utilizar el bucle for-of lugar del método forEach . Se verá mucho más bonito, y puedes usar continue , break , yield dentro de él:

var trivialGenerator = function *(array) {
    for (var item of array) {
        // some item manipulation
        yield item;
    }
}

Puede usar for-of si tiene algunas manipulaciones con el elemento dentro de él. De lo contrario, no necesita crear este generador, ya que la array tiene una interfaz de iterator forma nativa.