Compromisos entre evaluación perezosa y entusiasta
Sepa cuándo la evaluación perezosa ayuda o perjudica.
Compromisos entre evaluación perezosa y entusiasta es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 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.
No hay almuerzo gratis
Lo lazy no siempre es más rápido. Cambia la asignación inicial por una sobrecarga en cada acceso y modifica el momento en que se ejecutan los efectos secundarios. Conocer estas ventajas y desventajas le permite elegir correctamente.
Lazy gana: consumo parcial
Solo hace falta una parte de una transformación enorme — lazy omite el resto:
let data = Array(1...1_000_000)
let top = data.lazy.map { $0 * 2 }.prefix(3)
print(Array(top)) // [2, 4, 6] -- 999,997 transforms skippedEager gana: reutilización completa
Si itera el resultado muchas veces, eager calcula una sola vez; lazy vuelve a calcularlo en cada pasada:
let doubled = [1, 2, 3].map { $0 * 2 } // computed once
print(doubled.reduce(0, +)) // 12
print(doubled.max()!) // 6 -- no recomputeLazy recalcula
La misma vista lazy vuelve a hacer el trabajo en cada iteración:
var work = 0
let view = [1, 2, 3].lazy.map { (n: Int) -> Int in work += 1; return n }
_ = view.reduce(0, +)
_ = view.max()
print(work) // 6 -- transformed twiceSobrecarga por elemento
Cada paso lazy envuelve la secuencia en otro tipo y realiza llamadas a través de closures, elemento por elemento. En arrays pequeños, esa sobrecarga puede superar el ahorro de la asignación.
En un array pequeño, eager está bien
Para unos pocos elementos que se consumen por completo, prefiera eager sin más — es más sencillo y la asignación es insignificante:
let nums = [3, 1, 2]
let sorted = nums.map { $0 + 1 }.sorted()
print(sorted) // [2, 3, 4]El momento de los efectos secundarios es diferente
Con lazy, el cuerpo de la closure se ejecuta después de la línea que la define. Evite depender de efectos secundarios dentro de transformaciones lazy:
var log: [Int] = []
let v = [1, 2].lazy.map { (n: Int) -> Int in log.append(n); return n }
print(log) // [] -- nothing ran yet
_ = Array(v)
print(log) // [1, 2]Operaciones que obligan a eager
Algunas operaciones deben leer toda la secuencia de todos modos, por lo que lazy no aporta ningún beneficio:
let nums = Array(1...10)
print(nums.lazy.map { $0 * 2 }.sorted()) // sorted must see all -> [2,4,...,20]
print(nums.lazy.map { $0 }.count) // count walks everythingLazy y contains
Las operaciones de cortocircuito, como contains(where:), se benefician de lazy con entradas grandes:
let big = Array(1...1_000_000)
let found = big.lazy.map { $0 * 2 }.contains { $0 == 8 }
print(found) // true -- stops at element 4Una lista de comprobación para decidir
Use lazy cuando: la fuente es grande Y solo conserva una parte (prefix / first / contains) Y itera una sola vez. Use eager cuando: el array es pequeño, reutiliza el resultado o la legibilidad importa más que una microoptimización.
let huge = Array(1...100_000)
let first = huge.lazy.filter { $0 % 9973 == 0 }.first
print(first!) // 9973Mida, no adivine
La intuición sobre el rendimiento suele equivocarse. Cuando sea importante, compare ambas versiones con datos realistas antes de decidirse por lazy.
let nums = Array(1...50)
let eager = nums.filter { $0 > 25 }.count
let lazyC = nums.lazy.filter { $0 > 25 }.count
print(eager == lazyC) // true -- same answer, profile for speedComprobación rápida
¿Cuándo es eager una opción mejor que lazy?
Repaso
Ha aprendido las ventajas y desventajas:
- Lazy gana con fuentes grandes y un consumo parcial en una sola pasada
- Eager gana con arrays pequeños y resultados reutilizados (lazy recalcula)
- Los efectos secundarios de las transformaciones lazy se ejecutan más tarde — evite depender de ellos
- Mida antes de optimizar
Siguiente: crear secuencias lazy personalizadas.
Preguntas frecuentes
¿La lección «Compromisos entre evaluación perezosa y entusiasta» es gratis?
Sí — el texto completo de «Compromisos entre evaluación perezosa y entusiasta» 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 «Compromisos entre evaluación perezosa y entusiasta»?
Sepa cuándo la evaluación perezosa ayuda o perjudica. 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 3 de 4.
¿Cuánto tiempo toma la lección «Compromisos entre evaluación perezosa y entusiasta»?
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
- La propiedad lazy
- map y filter perezosos
- Compromisos entre evaluación perezosa y entusiasta
- Crear secuencias perezosas personalizadas