0Pricing
Lua Academy · Lección

Resumen de los tipos de datos de Lua

Explore los tipos nil, boolean, number, string, table, function y userdata.

Resumen de los tipos de datos de Lua 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.

Bienvenido a Lua

Lua es un lenguaje de scripting ligero, rápido e integrable que se utiliza en motores de videojuegos, servidores web y sistemas embebidos. Antes de escribir programas reales, necesita entender cómo representa los datos Lua.

Lua tiene 8 tipos básicos: nil, boolean, number, string, table, function, userdata y thread. Cada valor de Lua pertenece exactamente a uno de estos tipos.

-- Check the type of any value with type()
print(type(42))        -- number
print(type("hello"))   -- string
print(type(true))      -- boolean
print(type(nil))       -- nil

nil: ausencia de valor

nil es la forma que tiene Lua de representar nada o ningún valor. Es el único valor de su tipo. Las variables a las que nunca se les ha asignado un valor contienen nil automáticamente.

Asignar nil a una variable global, en la práctica, la elimina. En las tablas, establecer una clave en nil elimina por completo esa entrada.

-- Unassigned variables are nil
print(x)          -- nil

x = 10
print(x)          -- 10

x = nil
print(x)          -- nil (variable is gone)

boolean: verdadero y falso

El tipo boolean tiene exactamente dos valores: true y false. Las reglas de veracidad de Lua son sencillas, pero importantes: solo nil y false son falsos. Todo lo demás —incluidos el número 0 y la cadena vacía ""— es verdadero.

Esto difiere de muchos lenguajes en los que 0 o "" se consideran falsos.

-- Lua truthiness examples
if 0 then print("0 is truthy!") end       -- prints!
if "" then print("empty str is truthy!") end -- prints!
if nil then print("nil") else print("nil is falsy") end
if false then print("false") else print("false is falsy") end

number: enteros y números de coma flotante

Lua 5.3+ tiene dos subtipos de number: integer y float. Los enteros son valores exactos de 64 bits; los números de coma flotante usan doble precisión IEEE 754. En Lua 5.1/5.2, todos los números son de doble precisión.

La función math.type() distingue entre los dos subtipos. La división con / siempre devuelve un número de coma flotante; // (división entera) devuelve un entero cuando ambos operandos son enteros.

print(type(10))       -- number
print(type(10.5))     -- number
print(math.type(10))  -- integer
print(math.type(10.5))-- float
print(10 / 3)         -- 3.3333...
print(10 // 3)        -- 3  (floor division)

string: texto en Lua

Las cadenas de Lua son secuencias inmutables de bytes. Puede delimitarlas con comillas simples, comillas dobles o corchetes largos [[...]] para cadenas multilínea. Las cadenas con corchetes largos ignoran el primer salto de línea y conservan literalmente todo lo demás.

Las cadenas de Lua están internadas, por lo que las cadenas idénticas comparten memoria. El operador de longitud # devuelve la cantidad de bytes.

local s1 = 'single quotes'
local s2 = "double quotes"
local s3 = [[multi-line
long string]]

print(#s1)           -- 13
print(type(s1))      -- string
print(s1 .. " works") -- concatenation with ..

table: el contenedor universal

El tipo table es la única estructura de datos compuesta de Lua, pero es lo bastante potente para implementar arrays, diccionarios, objetos, conjuntos y mucho más. Las tablas son arrays asociativos: asignan valores a claves, que pueden ser cualquier valor que no sea nil ni NaN.

Las tablas se crean con llaves {}. Las tablas con estilo de array utilizan claves enteras que empiezan en 1.

-- Array style
local fruits = {"apple", "banana", "cherry"}
print(fruits[1])   -- apple (1-indexed!)

-- Dictionary style
local person = {name = "Alice", age = 30}
print(person.name) -- Alice
print(person["age"]) -- 30

function: valores de primera clase

Las funciones de Lua son valores de primera clase del tipo function. Se pueden almacenar en variables, pasar como argumentos y devolver desde otras funciones. Esto hace que Lua sea naturalmente adecuado para los patrones de programación funcional.

Puede definir funciones mediante la palabra clave function o asignar funciones anónimas a variables. Ambas formas son equivalentes.

-- Two equivalent ways to define a function
function greet(name)
  return "Hello, " .. name
end

local greet2 = function(name)
  return "Hello, " .. name
end

print(type(greet))   -- function
print(greet("Lua"))  -- Hello, Lua

userdata y thread

userdata representa datos arbitrarios de C administrados por la aplicación anfitriona. No puede crear userdata en Lua puro: proviene de extensiones de C o de entornos embebidos, como los motores de videojuegos. Permite que el código C exponga objetos a los scripts de Lua.

thread representa corrutinas: hilos de ejecución independientes con sus propias pilas. Exploraremos las corrutinas en una lección específica. Por ahora, sepa que coroutine.create() devuelve un valor del tipo thread.

-- thread type via coroutine
local co = coroutine.create(function()
  print("coroutine body")
end)

print(type(co))  -- thread

-- userdata comes from C, not creatable in pure Lua
-- type(io.stdin) == "file" is a userdata variant

Uso de type() para inspeccionar valores

La función integrada type() siempre devuelve un string que indica el tipo de su argumento. Esto resulta útil para la programación defensiva y la depuración. Puede comparar directamente el resultado con las cadenas que representan los nombres de los tipos.

Tenga en cuenta que type(nil) devuelve la cadena "nil", no el valor nil en sí. Esto permite comprobar de forma segura si una variable contiene nil sin provocar errores.

local values = {42, "hi", true, nil, {}, function() end}

-- Note: nil in table stops ipairs early
for i = 1, 3 do
  print(i, type(values[i]))
end
-- 1  number
-- 2  string
-- 3  boolean

Diferencias de tipos con otros lenguajes

Si viene de JavaScript, Python o Java, algunas reglas de tipos de Lua pueden sorprenderle. No existe un tipo entero independiente visible para type(): tanto los enteros como los números de coma flotante devuelven "number". Los arrays no tienen un tipo propio: son simplemente tablas. Las clases no existen: los objetos son tablas con metatablas.

Comprender estas diferencias evita errores comunes al cambiar de un lenguaje a otro.

-- No separate array type
local arr = {1, 2, 3}
print(type(arr))      -- table (not array!)

-- No separate integer type visible
print(type(1))        -- number
print(type(1.0))      -- number

-- math.type distinguishes
print(math.type(1))   -- integer
print(math.type(1.0)) -- float

Comprobación rápida

¿Qué devuelve type(0) en Lua?

Resumen: descripción general de los tipos de datos de Lua

Ha aprendido los 8 tipos de Lua:

  • nil — ausencia de valor; falso
  • boolean — verdadero/falso; solo nil y false son falsos
  • number — entero o número de coma flotante; use math.type() para distinguirlos
  • string — secuencias inmutables de bytes; use .. para concatenar
  • table — el contenedor universal para arrays y diccionarios
  • function — valores de primera clase que se pueden almacenar en variables
  • userdata — datos de C expuestos a Lua
  • thread — referencias a corrutinas

A continuación: declaración de variables — ámbito global frente a local.

Preguntas frecuentes

¿La lección «Resumen de los tipos de datos de Lua» es gratis?

Sí — el texto completo de «Resumen de los tipos de datos de Lua» 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 «Resumen de los tipos de datos de Lua»?

Explore los tipos nil, boolean, number, string, table, function y userdata. 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 «Resumen de los tipos de datos de Lua»?

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. Resumen de los tipos de datos de Lua
  2. Declaración de variables en Lua
  3. Operadores aritméticos y relacionales
  4. Coerción y conversión de tipos
← Volver a Lua Academy