TypeScript: Iteradores y generadores
Los iteradores y generadores son patrones importantes en JavaScript/TypeScript para el manejo de colecciones.
Proporcionan una forma unificada de recorrer datos, lo que facilita el manejo de grandes flujos de datos, secuencias infinitas, etc.
Diagrama SVG: Iteradores y generadores
¿Por qué necesitamos iteradores y generadores?
Al trabajar con datos de colecciones, a menudo necesitamos recorrer estructuras de datos como arrays, objetos, etc.
Los iteradores proporcionan una interfaz de recorrido unificada y personalizable, lo que permite que cualquier objeto pueda ser recorrido.
Los generadores son una forma concisa de crear iteradores; te permiten pausar y reanudar la ejecución usando funciones, ideal para manejar grandes flujos de datos o secuencias infinitas.
Explicación del concepto:Un iterador es un objeto que proporciona el método next() para recorrer datos. Un generador es un tipo especial de función que puede pausarse durante la ejecución y devolver un valor.
Protocolo iterable
Los objetos que implementan el método Symbol.iterator pueden ser recorridos con un bucle for...of.
Ejemplo
var arr = [1, 2, 3];
for (var _i = 0, arr_1 = arr; _i < arr_1.length; _i++) {
var item = arr_1[_i];
console.log("Elementos del array: " + item);
}
// Las cadenas son iterables por defecto
var str = "hello";
for (var _i = 0, str_1 = str; _i < str_1.length; _i++) {
var char = str_1[_i];
console.log("Caracteres: " + char);
}
Resultado de ejecución:
数组元素: 1 数组元素: 2 数组元素: 3 字符: h 字符: e 字符: l 字符: l 字符: o
Explicación:Tanto los arrays como las cadenas implementan de forma nativa el método Symbol.iterator, por lo que se pueden recorrer directamente con for...of.
Objetos iterables personalizados
Haz que los objetos ordinarios implementen la interfaz Symbol.iterator para que puedan ser recorridos.
Ejemplo
var range = {
from: 1,
to: 5,
// Implementar el método Symbol.iterator
[Symbol.iterator]: function() {
return {
current: this.from,
last: this.to,
// El método next() devuelve el resultado de la iteración
next: function() {
if (this.current <= this.last) {
// No terminado, devuelve el valor actual e incrementa
return { done: false, value: this.current++ };
}
// Terminado
return { done: true, value: undefined };
}
};
}
};
// Recorrer con for...of
for (var _i = 0, range_1 = range; _i < range_1.length; _i++) {
var num = range_1[_i];
console.log("Rango: " + num);
}
Protocolo del iterador:Un iterador debe tener un método next() que devuelva un objeto con el formato { done: boolean, value: any }.
Funciones generadoras
Utiliza la sintaxis function* para crear generadores, y yield para pausar la ejecución y devolver un valor.
Ejemplo
function* numberGenerator() {
yield 1; // Pausa y devuelve 1
yield 2; // Pausa y devuelve 2
yield 3; // Pausa y devuelve 3
}
// Crear una instancia del generador
var gen = numberGenerator();
// Cada llamada a next() se ejecuta hasta el siguiente yield
console.log("Primero: " + gen.next().value);
console.log("Segundo: " + gen.next().value);
console.log("Tercero: " + gen.next().value);
console.log("Completado: " + gen.next().done);
Resultado de ejecución:
第一个: 1 第二个: 2 第三个: 3 完成: true
Generador:Una función generadora devuelve un iterador; cada llamada a next() se ejecuta hasta la siguiente sentencia yield.
Generadores infinitos
Los generadores pueden producir secuencias infinitas; gracias a la evaluación perezosa, no ocupan memoria infinita.
Ejemplo
// Cada llamada genera solo un número, no todos a la vez
function* infiniteNumbers() {
var n = 1;
while (true) { // Bucle infinito
yield n++; // Pausa y devuelve el valor actual, luego incrementa
}
}
var gen = infiniteNumbers();
console.log("Primero: " + gen.next().value);
console.log("Segundo: " + gen.next().value);
console.log("Tercero: " + gen.next().value);
// Obtener solo los primeros 5 números
var nums = [];
var iter = infiniteNumbers();
for (var i = 0; i < 5; i++) {
nums.push(iter.next().value);
}
console.log("Primeros 5: " + nums);
Resultado de ejecución:
第1个: 1 第2个: 2 第3个: 3 前5个: 1,2,3,4,5
Evaluación perezosa:La mayor ventaja de los generadores es la evaluación perezosa: solo se calcula el siguiente valor al llamar a next(), lo que los hace ideales para manejar secuencias infinitas.
Generadores delegados
Usa yield* para delegar en otro generador u objeto iterable.
Ejemplo
function* gen1() {
yield 1;
yield 2;
}
// Segundo generador
function* gen2() {
yield 3;
yield 4;
}
// Generador combinado: usar yield* para delegar
function* combined() {
yield* gen1(); // Delegar en gen1
yield* gen2(); // Delegar en gen2
}
// Recorrer el generador combinado
for (var _i = 0, combined_1 = combined(); _i < combined_1.length; _i++) {
var num = combined_1[_i];
console.log("Valor: " + num);
}
Resultado de ejecución:
值: 1 值: 2 值: 3 值: 4
yield*:Los generadores delegados pueden combinar múltiples generadores u objetos iterables, ideales para construir flujos de datos reutilizables.
TypeScript: Tipos de generadores
La anotación de tipo para los generadores utiliza el tipo Generator.
Ejemplo
function* idGenerator(): Generator<number, void, unknown> {
var i = 1;
while (i <= 3) {
yield i++; // yield de tipo number
}
// return void
}
var gen = idGenerator();
console.log(Array.from(gen));
Explicación de tipos:Generator<T, R, N> significa: T es el tipo de yield, R es el tipo de retorno final, y N es el tipo del parámetro de next().
Consideraciones
- Protocolo del iterador:Implementar Symbol.iterator para devolver un objeto con el método next().
- Sintaxis de generadores:Usa function* en lugar de function
- Palabra clave yield:Pausa la ejecución y devuelve un valor
- Evaluación perezosa:Los generadores calculan bajo demanda y no generan todos los valores a la vez.
Mejores prácticas:Usa generadores al manejar grandes flujos de datos, secuencias infinitas o escenarios que requieran pausar/reanudar.
Resumen
Los iteradores y generadores son herramientas potentes para el procesamiento de datos en TypeScript.
- Objetos iterables:Implementar la interfaz Symbol.iterator
- Generadores:Crear con function* y yield
- yield:Pausar la ejecución y devolver un valor
- Delegación:Usar yield* para combinar múltiples generadores
Otras extensionesRecomendación:Usa iteradores y generadores cuando necesites recorrer objetos personalizados, manejar flujos de datos o crear secuencias infinitas.