En tutoriales pasados vimos cómo Lua permite el manejo tanto de los valores y los tipos de manera dinámica, siempre destacando por su simplicidad y versatilidad al momento de realizar estas operaciones.

Pero esto no es todo lo que Lua ofrece en cuanto a simplicidad, el mismo soporta de manera convencional declaraciones que podemos encontrar en lenguajes como en C o Pascal, donde estas declaraciones incluyen asignaciones y estructuras de control por igual, incluso nos podemos topar con algunas maneras no convencionales como asignaciones múltiples y declaraciones locales.

Asignaciones

Las asignaciones en Lua son sumamente sencillas, y funcionan para cambiar el valor de una variable en un momento determinado dentro de nuestro programa, veamos un ejemplo sencillo utilizando la consola interactiva de Lua, a la cual podemos ingresar con colocar la palabra reservada lua en la terminal:

Como vemos tenemos algunos ejemplos sencillos de asignaciones, cambiando el valor de variables con operaciones de concatenación, aritméticas o simplemente sobre escritura de valores. Además de esto, Lua permite la asignación múltiple, donde una lista de valores es asignada a una lista de variables, siempre separando estas listas con comas para su correcto funcionamiento:

Como pudimos ver var1 obtuvo el valor numérico y var2 el valor de texto, esto de acuerdo al orden en el que se hace la asignación. Si somos observadores vemos como también podemos alternar los valores de ambas variables, algo que nos viene bastante útil cuando estamos trabajando con funciones.

Lua incluso puede ajustar el número de valores para el número de variables presentes, por ejemplo si la lista de valores es menor que la lista de variables, las variables extras reciben el tipo de valor nil por defecto como sus valores, veamos un ejemplo de este proceso:

Como vemos las dos primeras variables reciben sus valores correspondientes y la última de estas automáticamente recibe nil como explicamos. Es importante mencionar que las asignaciones múltiples no siempre son más rápidas que las asignaciones simples, pero estas nos permiten ayudarnos en recolectar múltiples retornos de la llamada de una función por mencionar alguno.

Variables locales y bloques

Además de las variables globales, Lua soporta variables locales las cuales a diferencias de las globales tienen un alcance limitado, el cual es dependiente del bloque en el cual se hayan declarado, veamos como declaramos una variable local:

Como vemos la declaración de estas variables las hacemos con la palabra reservada local, estas variables trabajan en el bloque en el cual se han declarado, por ejemplo podemos decir que un bloque puede ser una estructura de control o una función, veamos el siguiente ejemplo:

x = 10
local i = 1
while i <= x do
local x = i*2
print(x)
i = i + 1
end

if i > 20 then
local x
x = 20
print(x + 2)
else
print(x)
end
print(x)

Si ejecutamos el mismo en nuestra terminal, veremos como el resultado quizá no es el que esperamos, y esto se debe a que tenemos diferentes bloques en los cuales utilizamos las variables, veamos el resultado:

A pesar de que el control de nuestro programa puede verse limitado, podemos usar los delimitadores do-end para especificar un bloque y saber hasta dónde nuestras variables locales tienen alcance, veamos un ejemplo donde podemos hacer esto:

do
local var1 = 16
local var2 = var1+20
x = 5
y = x + var1
end
-- Aqui termina el alcance de var1 y var2
print(x, y)

print(var1, var2)

Al ejecutarlo en nuestra terminal veremos que las variables x e y son mostradas sin ningún problema por ser globales, pero para var1 y var2 el alcance de las mismas termina con el bloque do-end, veamos:

Podemos destacar que la utilización de variables locales en nuestros programas es una buena práctica, estas nos ayudan a no tocar el entorno global con nombres innecesarios, además que el acceso a estas variables es mucho más rápido que si lo hiciéramos con variables globales y por último estas variables se desvanecen tan pronto como su alcance termina liberando así espacio de memoria, por lo que recomendamos su uso cada vez que sea posible.

If, then y else

Como en la mayoría de los lenguajes de programación la declaración if verifica una condición y ejecuta la parte del then o la parte del else, donde esta último puede ser opcional, veamos un conjunto de estas condiciones como se ven en nuestros programas:

if var1 < 0 then var1 = 0 end

if var1 < var2 then return var1 else return var2 end

if lineas > maxlineas then

mostrar()
lineas = 0

end

Aquí tenemos tres tipos de funcionamientos, el básico con el then, usando el return para devolver un valor de acuerdo a la condición y una porción de código un poco más completa que llama una función. Además de esto podemos escribir if anidados utilizando elseif, lo que nos evita tener que utilizar múltiples ends, veamos como luce:

if operacion == "+" then
resultado = a + b
elseif operacion == "-" then
resultado = a - b
elseif operacion == "*" then
resultado = a*b
elseif operacion == "/" then
resultado = a/b
else
error("Operacion invalida")
end

Es importante destacar que esto no solo es más óptimo pero también necesario ya que Lua no posee las declaraciones de tipo switch por lo que este tipo de condiciones anidadas serán bastantes comunes en nuestros programas.

Bucle while

Como en otros lenguajes, Lua primero evalúa la condición del while, si la condición es falsa, el bucle termina y en caso contrario se ejecutan las líneas de código siguientes y se repite el proceso hasta que sea falsa la condición, veamos un ejemplo sencillo para ilustrar esto:

local i = 1
while var1[i] do
print(var1[i])
i = i + 1
end

Bucle repeat

Esta declaración a diferencia del while nos permite repetir el código dentro de la condición hasta que esta sea verdadera, donde incluso este código se puede ejecutar al menos una vez ya que la evaluación de la condición se realiza al final, veamos un ejemplo:

repeat
linea = os.read()
until linea ~= ""
print(linea)

For númerico y for genérico

En lo que respecta a los ciclos iterativos for, Lua posee dos variantes del mismo, el for numérico y el for genérico. Veamos la sintaxis del for númerico:

for var=exp1,exp2,exp3 do
<hacemos algo>
end

Este ciclo ejecutará algo por cada valor de var desde exp1 hasta exp2 usando exp3 como el valor para incrementar var o decrementarlo, si no lo incluimos Lua asume por defecto que va de uno en uno, veamos un ejemplo más detallado de estos ciclos:

for var=1,f(x) do print(var) end

for var2=10,1,-1 do print(var2) end

Como vemos su aplicación es bastante sencilla y nos permite implementar los útiles ciclos iterativos en nuestros programas, veamos ahora la sintaxis para el for genérico:

for i,var in ipairs(arreglo) do print(var) end

Lo que hace este ciclo es utilizar la función que nos brinda Lua llamada ipairs, la cual es un iterador de arreglos, donde por cada iteración i toma un índice, mientras var obtiene el valor asociado a ese índice.

Como vemos las declaraciones dentro de Lua no discrepan mucho de otros lenguajes, sin embargo el lenguaje le agrega ese extra de simplicidad para brindarnos un aprendizaje mucho más rápido de su sintaxis y un uso mucho más efectivo. Con esto finalizamos este tutorial, donde aprendimos las asignaciones y estructuras de control dentro Lua, añadiendo así otra capa de conocimiento en lo que respecta a este simple pero poderoso lenguaje.