0Pricing
Lua Academy · Lección

Tablas como arrays

Cree y manipule arrays indexados desde 1 con table.insert y table.remove.

Tablas como arrays es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 1 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.

Arrays indexados desde 1

Los arrays de Lua son tablas con claves enteras consecutivas que comienzan en 1. Esto difiere de la mayoría de los lenguajes, que comienzan en 0. La convención es universal en Lua: todas las funciones de la biblioteca estándar asumen una indexación basada en 1. Acceder a una posición fuera de los límites devuelve nil, no un error.

local colors = {"red", "green", "blue"}
print(colors[1])   -- red
print(colors[2])   -- green
print(colors[3])   -- blue
print(colors[0])   -- nil (no index 0)
print(#colors)     -- 3 (length operator)

table.insert y table.remove

table.insert(t, val) añade un elemento al final. table.insert(t, pos, val) inserta un elemento en una posición y desplaza los elementos hacia la derecha. table.remove(t, pos) elimina el elemento de pos (por defecto, el último), desplaza los elementos hacia la izquierda y devuelve el valor eliminado.

local stack = {}
table.insert(stack, "first")
table.insert(stack, "second")
table.insert(stack, "third")
print(#stack)          -- 3

table.insert(stack, 2, "inserted")
print(stack[2])        -- inserted

local removed = table.remove(stack, 1)
print(removed)         -- first
print(stack[1])        -- inserted

Pilas con tablas

Una tabla de Lua es una pila perfecta. Use table.insert para apilar y table.remove para desapilar. De forma predeterminada, ambas operaciones trabajan desde el final de la tabla, por lo que tienen un coste amortizado O(1).

local stack = {}

-- Push
table.insert(stack, 10)
table.insert(stack, 20)
table.insert(stack, 30)

-- Pop
print(table.remove(stack))  -- 30
print(table.remove(stack))  -- 20
print(#stack)               -- 1

Colas con tablas

Una cola (FIFO) se puede implementar con una tabla, pero table.remove(t, 1) tiene un coste O(n), porque desplaza todos los elementos. Para obtener colas de alto rendimiento, use dos punteros (índices de inicio y final) y evite los desplazamientos.

local head, tail = 1, 0
local queue = {}

local function enqueue(v)
  tail = tail + 1
  queue[tail] = v
end

local function dequeue()
  if head > tail then return nil end
  local v = queue[head]
  queue[head] = nil
  head = head + 1
  return v
end

enqueue("a"); enqueue("b"); enqueue("c")
print(dequeue())  -- a
print(dequeue())  -- b

El operador de longitud #

El operador # devuelve el «borde» de una tabla: un índice i tal que t[i] ~= nil y t[i+1] == nil. En secuencias sin huecos, esto equivale a la longitud del array. Con huecos (nil en el medio), # produce resultados indefinidos; use table.pack o realice un seguimiento manual de la longitud.

local t = {10, 20, 30, 40, 50}
print(#t)   -- 5

-- Safe for dense arrays
for i = #t, 1, -1 do
  io.write(t[i] .. " ")
end
print()  -- 50 40 30 20 10

Segmentar arrays

Lua no tiene una operación de segmentación integrada, pero puede extraer un subarray con table.move (Lua 5.3 o posterior) o mediante un bucle manual. table.move(a1, f, e, t, a2) copia los elementos de a1[f..e] en a2, empezando en la posición t.

local src = {10,20,30,40,50,60}

-- Manual slice
local function slice(t, from, to)
  local result = {}
  for i = from, to do
    result[#result+1] = t[i]
  end
  return result
end

local sub = slice(src, 2, 4)
print(sub[1], sub[2], sub[3])  -- 20  30  40

Invertir un array

Invierta una tabla en el mismo lugar intercambiando los elementos de ambos extremos hacia el centro. Este es un algoritmo clásico que funciona con cualquier array de Lua sin memoria adicional.

local function reverse(t)
  local n = #t
  for i = 1, math.floor(n / 2) do
    t[i], t[n - i + 1] = t[n - i + 1], t[i]
  end
end

local arr = {1, 2, 3, 4, 5}
reverse(arr)
for _, v in ipairs(arr) do
  io.write(v .. " ")
end
print()  -- 5 4 3 2 1

Concatenar arrays

Para combinar dos arrays en uno, recorra el segundo y añada sus elementos al final. table.move realiza esta operación de forma eficiente en Lua 5.3 o posterior. El resultado es una tabla nueva que contiene, en orden, todos los elementos de ambos arrays.

local function concat(a, b)
  local result = {}
  for _, v in ipairs(a) do result[#result+1] = v end
  for _, v in ipairs(b) do result[#result+1] = v end
  return result
end

local merged = concat({1,2,3}, {4,5,6})
for i, v in ipairs(merged) do
  io.write(v .. " ")
end
print()  -- 1 2 3 4 5 6

Aplanar matrices anidadas

Aplane una matriz anidada de forma recursiva: si un elemento es una tabla, vuelva a recorrerla; de lo contrario, añádalo al resultado. Esta es una aplicación natural del recorrido recursivo de tablas.

local function flatten(t, result)
  result = result or {}
  for _, v in ipairs(t) do
    if type(v) == "table" then
      flatten(v, result)
    else
      result[#result+1] = v
    end
  end
  return result
end

local nested = {1, {2, 3}, {4, {5, 6}}, 7}
local flat = flatten(nested)
print(table.concat(flat, ", "))  -- 1, 2, 3, 4, 5, 6, 7

Matriz como conjunto

Puede implementar un conjunto usando una tabla en la que los valores sean las claves y el valor asociado sea true. Comprobar si un elemento pertenece al conjunto es una operación O(1). Crear un conjunto a partir de una matriz elimina los duplicados. Para convertirlo de nuevo en una matriz, recórralo con pairs.

local function toSet(arr)
  local set = {}
  for _, v in ipairs(arr) do set[v] = true end
  return set
end

local nums = {3,1,4,1,5,9,2,6,5,3}
local set = toSet(nums)
local unique = {}
for k in pairs(set) do unique[#unique+1] = k end
table.sort(unique)
print(table.concat(unique, " "))  -- 1 2 3 4 5 6 9

Comprobación rápida

¿Qué hace table.remove(t) cuando se llama con un solo argumento?

Repaso: tablas como matrices

Resumen:

  • Las matrices de Lua son tablas indexadas desde 1
  • table.insert/table.remove para insertar y extraer elementos
  • #t proporciona la longitud de las secuencias sin huecos
  • Pila: insertar y extraer por el final (O(1))
  • Cola: use punteros de inicio y final para evitar el desplazamiento O(n)
  • Use una tabla como conjunto para comprobar pertenencia en O(1)

Preguntas frecuentes

¿La lección «Tablas como arrays» es gratis?

Sí — el texto completo de «Tablas como arrays» 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 «Tablas como arrays»?

Cree y manipule arrays indexados desde 1 con table.insert y table.remove. 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 1 de 4.

¿Cuánto tiempo toma la lección «Tablas como arrays»?

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

  1. Tablas como arrays
  2. Tablas como diccionarios
  3. Iteración de tablas con pairs e ipairs
  4. Tablas anidadas y datos estructurados
← Volver a Lua Academy