Lua primer

El código del amuleto está escrito en Lua . La versión de Lua

utilizada por defecto es LuaJIT-2 en Windows, Mac y Linux y Lua-5.1
en todas las demás plataformas.

Lo que sigue es una introducción rápida a Lua. Para más detalles,

consulte el manual de Lua .

Comentarios:

-- This is a single line comment

--[[ This is

a multi-line

comment ]]

Variables locales (alcance del bloque):

local x = 3.14 -- a number

local str = "a string"

local str2 = [[

multi-line

string]]

local bool = true -- a bool, can also be false

local y = nil -- nil value

local v1, v2 = 1, 2 -- create two local variables at once

Variables globales:

score = 0

title = "My Game"

If-then-else:

local x = 2

if x > 1 then

print ("x > 1")

elseif x > 0 then

print ("0 < x <= 0")

else

print ("x <= 0")

end

La parte else de un if-then-else se ejecuta solo si la condición se

evalúa como falseo nil.

Mientras bucle:

local n = 5

while n > 0 do

print (n)

n = n - 1

end

-- prints 5 4 3 2 1

Repetir-hasta el bucle:

local n = 0

repeat

n = n + 1

print (n)

until n == 5

-- prints 1 2 3 4 5

En bucle:

for i = 1, 5 do

print (i)

end

-- prints 1 2 3 4 5

for j = 10, 1, -2 do

print (j)

end

-- prints 10 8 6 4 2
Puede salir de un bucle utilizando la breakdeclaración:

for j = 1, 10 do

print (j)

if j == 5 then

break

end

end

-- prints 1 2 3 4 5

Operadores:

Los operadores aritméticos son: +, -, *, /, ^(exponente) y %

(módulo).

Tenga en cuenta que Amulet también sobrecarga al ^operador para

construir gráficos de escenas (consulte aquí para más detalles).

Los operadores relacionales son: ==, ~=(no iguales), <, >, <=y>=

Los operadores lógicos son: and, ory not.

El operador de concatenación de cadenas es dos puntos

(p "abc".."def". Ej .).

Mesas:

Las tablas son la única estructura de datos en Lua. Se pueden usar

como mapas o matrices de valores clave.

Las claves y los valores pueden ser de cualquier tipo, excepto nil.

local t = {} -- create empty table

t ["score"] = 10

t [1] = "foo"

t [true] = "x"

-- this creates a table with 2 string keys:

local t2 = {foo = "bar", baz = 123}

Se proporciona una sintaxis especial para las claves de cadena:

local t = {}

t .score = 10

print (t.score)

El #operador devuelve la longitud de una matriz y los índices de

matriz comienzan en 1 por defecto.

local arr = {3, 4, 5}

for i = 1, #arr do

print (arr[i])

end

-- prints 3, 4, 5

table.insert (arr, 6) -- appends 6 to end of arr

table.remove (arr, 1) -- removes the first element of arr

-- arr is now {4, 5, 6}

Establecer el valor de una clave para nileliminar la clave e indexar

una clave faltante devuelve nil.

Puede iterar sobre todos los pares clave / valor utilizando

la pairsfunción. Tenga en cuenta que el orden no se conserva.

local t = {a = 1, b = 2, c = 3}

for k, v in pairs(t) do

print (k..":"..v)

end

-- prints a:1 c:3 b:2

Para iterar sobre una tabla de matriz, manteniendo el orden,

use ipairs:

local arr = {"a", "b", "c"}

for k, v in ipairs(arr) do

print (k..":"..v)

end

-- prints 1:a 2:b 3:c

Funciones:
function factorial(n)

if n <= 1 then

return 1

else

return n * factorial(n-1)

end

end

print (factorial(3)) -- prints 6

Las funciones son valores en Lua, por lo que pueden asignarse a

variables:

local add = function(a, b)

return a + b

end

print (add(1, 2)) -- prints 3

Se proporciona una sintaxis especial para agregar funciones a las

tablas:

local t = {}

function t.say_hello()

print("hello")

end

Esto es equivalente a:

local t = {}

t .say_hello = function()

print("hello")

end

El azúcar sintáctico especial le permite usar campos de función

como métodos en lenguajes orientados a objetos:

El código:

function t:f()
 ...

end

es equivalente a:

function t.f(self)

...

end

y el código:

t:f ()

es equivalente a:

t .f(t)

Por ejemplo:

local t = {x = 3}

function t:print_x()

print (self.x)

end

t:print_x () -- prints 3

t .x = 4

t:print_x () -- prints 4

Si una llamada de función solo tiene una cadena o argumento de

tabla, los paréntesis pueden omitirse:

local

function append_z(str)

return str.."z"

end

print (append_z"xy") -- prints xyz

local

function sum(values)

local total = 0
 for _, value in ipairs(values) do

total = total + value

end

return total

end

print (sum{3, 1, 6}) -- prints 10

Las funciones también pueden devolver múltiples valores:

function f()

return 1, 2

end

local x, y = f()

print (x + y) -- prints 3