0Pricing
Swift Academy · Lección

map y filter perezosos

Encadene transformaciones perezosas sin arrays intermedios.

map y filter perezosos es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Arrays intermedios

Las cadenas eager asignan un array nuevo entre cada paso. filter().map() sobre un array grande crea dos arrays completos, aunque quizá solo necesite unos pocos elementos.

La asignación eager

Aquí se crean dos arrays intermedios:

let nums = Array(1...6)
let result = nums
    .filter { $0 % 2 == 0 }  // builds [2, 4, 6]
    .map { $0 * 10 }         // builds [20, 40, 60]
print(result)  // [20, 40, 60]

Fusionar pasos con lazy

Una cadena lazy fusiona las operaciones: cada elemento pasa por todos los pasos antes de que comience el siguiente, por lo que nunca se asigna un array intermedio.

Una cadena lazy

La misma lógica, sin arrays intermedios:

let nums = Array(1...6)
let result = nums.lazy
    .filter { $0 % 2 == 0 }
    .map { $0 * 10 }
print(Array(result))  // [20, 40, 60]

Flujo elemento a elemento

El seguimiento muestra una ejecución intercalada, en lugar de una ejecución por etapas:

let out = [1, 2, 3].lazy
    .filter { n -> Bool in print("filter \(n)"); return n > 1 }
    .map   { n -> Int  in print("map \(n)");    return n }
print(Array(out))  // filter 1, filter 2, map 2, filter 3, map 3 -> [2, 3]

La salida temprana ahorra trabajo

Combine una cadena lazy con first(where:) para detenerse en cuanto sea posible:

let nums = Array(1...1_000_000)
let hit = nums.lazy.map { $0 + 1 }.first { $0 > 5 }
print(hit!)  // 6  -- only a handful of elements processed

lazy con prefix

Obtenga solo los primeros resultados de una transformación costosa:

let squares = (1...).lazy.map { $0 * $0 }
print(Array(squares.prefix(5)))  // [1, 4, 9, 16, 25]

Contar el trabajo omitido

Un contador demuestra cuántos elementos se procesan realmente:

var transforms = 0
let result = Array(1...100).lazy
    .map { (n: Int) -> Int in transforms += 1; return n * 2 }
    .prefix(3)
_ = Array(result)
print(transforms)  // 3, not 100

compactMap lazy

compactMap también tiene una forma lazy:

let raw = ["1", "x", "3", "y", "5"]
let first = raw.lazy.compactMap { Int($0) }.first
print(first!)  // 1

Combinar muchos pasos

Los pipelines largos fusionados no realizan asignaciones hasta que se materializan:

let r = Array(1...20).lazy
    .filter { $0 % 2 == 0 }
    .map { $0 * $0 }
    .filter { $0 > 50 }
print(Array(r))  // [64, 100, 144, 196, 256, 324, 400]

Cuándo resulta más útil la fusión

La fusión lazy resulta ventajosa cuando la fuente es grande y solo conserva parte del resultado. Si de todos modos consume todo en un array, el ahorro disminuye y eager puede resultar más claro.

let big = Array(1...10_000)
let sample = Array(big.lazy.filter { $0 % 1000 == 0 })
print(sample)  // [1000, 2000, ... 10000]

Comprobación rápida

¿Qué evita una cadena lazy de filter().map() que sí crea una cadena eager?

Repaso

Ha aprendido las cadenas lazy:

  • Las cadenas eager asignan un array entre cada paso
  • .lazy fusiona los pasos: elemento a elemento y sin arrays intermedios
  • Combina perfectamente con first(where:) y prefix para realizar una salida temprana
  • La mayor ventaja se obtiene con una fuente grande y un consumo parcial

A continuación: ventajas y desventajas de lazy frente a eager.

Preguntas frecuentes

¿La lección «map y filter perezosos» es gratis?

Sí — el texto completo de «map y filter perezosos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «map y filter perezosos»?

Encadene transformaciones perezosas sin arrays intermedios. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «map y filter perezosos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. La propiedad lazy
  2. map y filter perezosos
  3. Compromisos entre evaluación perezosa y entusiasta
  4. Crear secuencias perezosas personalizadas
← Volver a Swift Academy