Lua Academy · Lección

Iteradores con estado mediante closures

Construya iteradores que mantengan su estado entre llamadas mediante closures.

Iteradores con estado mediante closures es una lección gratuita de Lua 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 Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

Cuándo ayudan los closures

Cuando un iterador necesita mantener un estado complejo y cambiante (posición, pila o historial), los closures son la herramienta natural. El estado vive en los upvalues.

Patrón de iterador basado en un closure

Devuelva una sola función; el estado se conserva en los upvalues. El generic for no proporciona ningún estado externo, sino que simplemente llama a la función cada vez.

local function chars(s)
  local i = 0
  return function()
    i = i + 1
    local c = s:sub(i, i)
    return c ~= "" and c or nil
  end
end
for c in chars("lua") do print(c) end

Iterador de líneas de archivo

Un iterador clásico basado en una clausura con estado devuelve las líneas de un descriptor de archivo hasta llegar al EOF.

local function lines(filename)
  local f = io.open(filename, "r")
  return function()
    local line = f:read("*l")
    if not line then f:close() end
    return line
  end
end

Iterador con filtrado

Envuelva un iterador existente con una clausura que omita los elementos que no coincidan con un predicado.

local function filtered(iter, pred)
  return function()
    local v = iter()
    while v ~= nil and not pred(v) do
      v = iter()
    end
    return v
  end
end

Iterador con mapeo

Un iterador de mapeo transforma cada elemento sobre la marcha sin crear una tabla intermedia.

local function mapped(iter, fn)
  return function()
    local v = iter()
    if v ~= nil then return fn(v) end
  end
end

Iterador intercalado

Un iterador zip obtiene elementos de dos iteradores simultáneamente y se detiene cuando uno de ellos se agota.

local function zipped(iter1, iter2)
  return function()
    local a, b = iter1(), iter2()
    if a ~= nil and b ~= nil then return a, b end
  end
end

Iterador encadenado

Un iterador encadenado agota un iterador antes de pasar al siguiente.

local function chained(...)
  local iters = {...}
  local idx = 1
  return function()
    while idx <= #iters do
      local v = iters[idx]()
      if v ~= nil then return v end
      idx = idx + 1
    end
  end
end

Iterador limitado

Limite un iterador a un máximo de N valores mediante un contador en una clausura.

local function take(n, iter)
  local count = 0
  return function()
    count = count + 1
    if count <= n then return iter() end
  end
end

Iterador de recorrido de árboles

Un recorrido en profundidad de un árbol utiliza una pila (una tabla como upvalue) para mantener el estado del recorrido.

local function dfs(root)
  local stack = {root}
  return function()
    if #stack == 0 then return nil end
    local node = table.remove(stack)
    for _, child in ipairs(node.children or {}) do
      stack[#stack+1] = child
    end
    return node
  end
end

Consideraciones de memoria

Los iteradores con estado asignan un objeto de clausura. En bucles internos extremadamente ajustados, puede ser preferible un iterador sin estado. Para recorridos complejos, la clausura compensa ampliamente.

Comparación: con estado frente a sin estado

Con estado: estado complejo, cualquier orden de recorrido y facilidad de escritura.
Sin estado: acceso secuencial simple, cero asignaciones y rapidez.

Pregunta sobre iteradores con estado

¿Dónde almacena su estado un iterador basado en una clausura con estado?

Resumen: iteradores con estado

Los iteradores con estado basados en clausuras almacenan el estado complejo del recorrido en upvalues, lo que permite crear filtros, mapeos, árboles y pipelines perezosos, todos componibles y eficientes en memoria.

Preguntas frecuentes

¿La lección «Iteradores con estado mediante closures» es gratis?

Sí — el texto completo de «Iteradores con estado mediante closures» 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 Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Iteradores con estado mediante closures»?

Construya iteradores que mantengan su estado entre llamadas mediante closures. Practicas Lua 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 Lua Academy?

No se requiere experiencia previa. Lua 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 «Iteradores con estado mediante closures»?

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 Lua Academy?

Sí. Cada lección de Lua 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

← Volver a Lua Academy