Tipos de datos Lua

Lua es un lenguaje de tipado dinámico, las variables no necesitan definición de tipo, solo hay que asignarles un valor. Los valores pueden almacenarse en variables, pasarse como parámetros o devolverse como resultado.

En Lua hay 8 tipos básicos: nil, boolean, number, string, userdata, function, thread y table.

Tipo de datosDescripción
nilEste es el más simple, solo el valor nil pertenece a esta clase, representa un valor no válido (equivalente a false en expresiones condicionales).
booleanContiene dos valores: false y true.
numberRepresenta números de coma flotante de doble precisión.
stringLas cadenas se representan con un par de comillas dobles o comillas simples.
functionFunciones escritas en C o Lua.
userdataRepresenta cualquier estructura de datos de C almacenada en una variable.
threadRepresenta una línea de ejecución independiente, utilizada para ejecutar corrutinas.
tableLa tabla (table) en Lua es en realidad un "array asociativo" (associative arrays), cuyos índices pueden ser números, cadenas o tipos de tabla. En Lua, la creación de tablas se realiza mediante "expresiones de construcción"; la expresión de construcción más simple es {}, que se usa para crear una tabla vacía.

Podemos usar la función type para comprobar el tipo de una variable o valor dado:

Ejemplo

print(type("Hello world"))      --> string
print(type(10.4*3))             --> number
print(type(print))              --> function
print(type(type))               --> function
print(type(true))               --> boolean
print(type(nil))                --> nil
print(type(type(X)))            --> string

nil (nulo)

El tipo nil representa un valor sin ningún valor válido, solo tiene un valor -- nil. Por ejemplo, al imprimir una variable sin asignar, se mostrará un valor nil:

> print(type(a))
nil
>

Para variables globales y tablas, nil también tiene un efecto de "eliminación". Asignar nil a una variable global o a una variable dentro de una tabla equivale a eliminarlas. Ejecute el siguiente código para verlo:

tab1 = { key1 = "val1", key2 = "val2", "val3" }
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end
 
tab1.key1 = nil
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end

Al comparar nil, se deben usar comillas dobles"：

> type(X)
nil
> type(X)==nil
false
> type(X)=="nil"
true
>

type(X)==nilEl resultado esfalseLa razón es que type(X) en realidad devuelve"nil"una cadena, es un tipo string:

type(type(X))==string

boolean (booleano)

El tipo boolean solo tiene dos valores posibles: true (verdadero) y false (falso). Lua considera false y nil como false, los demás son true, y el número 0 también es true:

Ejemplo

print(type(true))
print(type(false))
print(type(nil))
 
if false or nil then
    print("Al menos uno es true")
else
    print("false y nil son ambos false")
end

if 0 then
    print("El número 0 es true")
else
    print("El número 0 es false")
end

El resultado de ejecutar el código anterior es el siguiente:

$ lua test.lua 
boolean
boolean
nil
false 和 nil 都为 false
数字 0 是 true

number (número)

Lua tiene por defecto un solo tipo number -- tipo double (doble precisión) (el tipo predeterminado se puede modificar en la definición en luaconf.h). Las siguientes formas se consideran tipo number:

Ejemplo

print(type(2))
print(type(2.2))
print(type(0.2))
print(type(2e+1))
print(type(0.2e-1))
print(type(7.8263692594256e-06))

El resultado de ejecutar el código anterior:

number
number
number
number
number
number

string (cadena)

Las cadenas se representan con un par de comillas dobles o comillas simples.

string1 = "this is string1"
string2 = 'this is string2'

También se pueden usar dos corchetes '[[]]' para representar una cadena en bloque.

Ejemplo

html = [[
<html>
<head></head>
<body>
<a href="http://www.example.com/">Tutorial de Ejemplo</a>
</body>
</html>
]]
print(html)

El resultado de ejecutar el siguiente código es:

<html>
<head></head>
<body>
    <a href="../index.html">Ejemplo</a>
</body>
</html>

Al realizar operaciones aritméticas sobre una cadena numérica, Lua intenta convertir esa cadena numérica en un número:

> print("2" + 6)
8.0
> print("2" + "6")
8.0
> print("2 + 6")
2 + 6
> print("-2e2" * "6")
-1200.0
> print("error" + 1)
stdin:1: attempt to perform arithmetic on a string value
stack traceback:
        stdin:1: in main chunk
        [C]: in ?
>

En el código anterior, "error" + 1 produce un error. La concatenación de cadenas se realiza con .., por ejemplo:

> print("a" .. 'b')
ab
> print(157 .. 428)
157428
>

Usa # para calcular la longitud de una cadena, colocándolo delante de la cadena, como en el siguiente ejemplo:

Ejemplo

> len = "www.example.com"
> print(#len)
14
> print(#"www.example.com")
14
>

table (tabla)

En Lua, la creación de tablas se realiza mediante "expresiones de construcción"; la expresión de construcción más simple es {}, que se usa para crear una tabla vacía. También se pueden agregar algunos datos en la tabla e inicializarla directamente:

Ejemplo

-- Crear una tabla vacía
local tbl1 = {}
 
-- Inicializar la tabla directamente
local tbl2 = {"apple", "pear", "orange", "grape"}

La tabla (table) en Lua es en realidad un "array asociativo" (associative arrays), y los índices del array pueden ser números o cadenas.

Ejemplo

-- Archivo de script table_test.lua
a = {}
a["key"] = "value"
key = 10
a[key] = 22
a[key] = a[key] + 11
for k, v in pairs(a) do
    print(k .. " : " .. v)
end

El resultado de ejecutar el script es:

$ lua table_test.lua 
key : value
10 : 33

A diferencia de los arrays en otros lenguajes que usan 0 como índice inicial, en Lua el índice inicial predeterminado de una tabla generalmente comienza en 1.

Ejemplo

-- Archivo de script table_test2.lua
local tbl = {"apple", "pear", "orange", "grape"}
for key, val in pairs(tbl) do
    print("Key", key)
end

El resultado de ejecutar el script es:

$ lua table_test2.lua 
Key    1
Key    2
Key    3
Key    4

Una tabla no tiene un tamaño fijo; cuando se agregan nuevos datos, la longitud de la tabla crece automáticamente. Las tablas sin inicializar son nil.

Ejemplo

-- Archivo de script table_test3.lua
a3 = {}
for i = 1, 10 do
    a3[i] = i
end
a3["key"] = "val"
print(a3["key"])
print(a3["none"])

El resultado de ejecutar el script es:

$ lua table_test3.lua 
val
nil

function (función)

En Lua, las funciones se consideran "valores de primera clase" (First-Class Value), y las funciones pueden almacenarse en variables:

Ejemplo

-- Archivo de script function_test.lua
function factorial1(n)
    if n == 0 then
        return 1
    else
        return n * factorial1(n - 1)
    end
end
print(factorial1(5))
factorial2 = factorial1
print(factorial2(5))

El resultado de ejecutar el script es:

$ lua function_test.lua 
120
120

Las funciones pueden pasarse como parámetros en forma de funciones anónimas (anonymous function):

Ejemplo

-- Archivo de script function_test2.lua
function testFun(tab,fun)
        for k ,v in pairs(tab) do
                print(fun(k,v));
        end
end


tab={key1="val1",key2="val2"};
testFun(tab,
function(key,val)-- Función anónima
        return key.."="..val;
end
);

El resultado de ejecutar el script es:

$ lua function_test2.lua 
key1=val1
key2=val2

thread (hilo)

En Lua, el hilo principal es la corrutina (coroutine). Es similar a un hilo (thread), tiene su propia pila, variables locales y puntero de instrucciones, y puede compartir variables globales y la mayoría de las demás cosas con otras corrutinas.

La diferencia entre hilos y corrutinas: varios hilos pueden ejecutarse simultáneamente, mientras que una corrutina solo puede ejecutarse una a la vez, y una corrutina en ejecución solo se detiene cuando es suspendida (suspend).

userdata (tipo personalizado)

userdata es un dato definido por el usuario, utilizado para representar un tipo creado por la aplicación o por bibliotecas de C/C++. Puede almacenar datos de cualquier tipo de dato de C/C++ (generalmente structs y punteros) en variables de Lua para su invocación.

Otras extensiones