No, no estas ciego, estas viendo frente a ti la quinta entrega de los tutoriales de programación en LUA, esta vez te sorprenderás aprendiendo todo sobre las estructuras de Control y Algoritmos, cosas de vital importancia en la programación, bueno, pero ya basta de tanta palabra y mejor a aprender...

Estructuras de Control

Ahora que ya hemos visto lo que son las operaciones lógicas, veremos porque son de gran utilidad. Las estructuras de control son ciertas sentencias que usan palabras reservadas para realizar distintas acciones, como repetir un fragmento de código mientras se cumpla una condición, o realizar cierto código si se cumple una condición, y si no se cumple, realizar otro código.

Pues bien, en Lua disponemos de las siguientes estructuras de control:

if...then...else: Esta estructura condicional, permite ejecutar un código si una condición se cumple, su uso es el siguiente:

if CONDICIÓN then
	BLOQUE
end

De tal manera que si condición es true (ya sea por medio de una operación lógica o de una variable booleana), realiza el bloque de código que hemos puesto. Esta estructura tiene algunas variantes que veremos a continuación:

if CONDICIÓN then
	BLOQUE1
else
	BLOQUE2
end

Si condición es true, se realizará lo que esté en bloque1, sino se cumple, se realizará bloque2.

Otra variante que tenemos es con el uso de elseif:

if CONDICIÓN1 then
	BLOQUE1
elseif CONDICIÓN2 then
	BLOQUE2
elseif CONDICIÓN3 then
	BLOQUE3
.
.
.
elseif CONDICIÓN# then
	BLOQUE#
end

Como podemos ver, se puede colocar la cantidad de elseifs que se requiera, esta forma de if es como si tuviéramos varios ifs en uno solo, de tal manera que si se cumple una de las condiciones (verificando desde la primera hasta la última), realizará el bloque que esté dentro.

Y la última variante, es igual que la de arriba pero añadiendo un else después de todos los elseifs:

if CONDICIÓN1 then
	BLOQUE1
elseif CONDICIÓN2 then
	BLOQUE2
else
	BLOQUE3
end

De forma que si no se cumple ninguna de las condiciones que pongamos, se realizará lo que esté dentro del else.

Ahora veremos lo que son los bucles. Los bucles o lazos repetitivos se encargan de repetir un fragmento de código mientras se cumpla cierta condición. En Lua disponemos de estos bucles:

while CONDICIÓN do
	BLOQUE
end

Este bucle primero verifica si condición es true (verdadera), si lo es y mientras lo sea, relizará el bloque de código, y se detendrá cuando condición sea false (falsa).

Otro bucle que tenemos es el repeat - until, y su uso es este:

repeat
	BLOQUE
until CONDICIÓN

Este bucle realiza el bloque de código primero, de tal manera que se ejecutará al menos una vez a diferencia del while, luego realiza la comprobación de si condición es true (verdadero) o si es false (falso), si es true, volverá al principio del bloque, lo realizará otra vez, y hará la comprobación de nuevo, una vez que la condición sea falsa saldrá del bucle.

El último bucle que veremos, es el for:

for variable=inicio,fin[,step] do
	BLOQUE
end

A diferencia de los otros, este bucle usa una variable como índice, la cual tendrá un valor inicial (inicio) que aumentará progresivamente una cantidad (step es el incremento o decremento, sino se lo coloca, por default step será 1).

Al igual que los otros, realizará una comprobación, si la variable no ha alcanzado un valor final (fin) continuará con la ejecución del bloque de código, cuando la variable haya alcanzado o sobrepasado el valor final, este bucle se detendrá.

Y una variación algo especial del for, es esta:

for key,value in funcion(array) do
	BLOQUE
end

Este bucle usará una función que recorra los elementos de un array, devolviendo el índice (key), siendo este number o string dependiendo de la función, y devuelve también el valor o dato (value) del elemento almacenado en dicho índice, este bucle se detendrá cuando se termine de recorrer el array. La función a usar puede ser next, pairs o ipairs.

En los bucles, tenemos dos palabras reservadas con funciones muy útiles:

break: Esto se lo usa cuando se quiere salir de un bucle, por ejemplo:

while true do
	BLOQUE1
	break
	BLOQUE2
end
BLOQUE3

eso haría que sólo se ejecute el bloque1 una vez, pasando por alto el bloque2 y continuaría hacia bloque3, esto se lo puede usar en un condicional también, de este modo:

while true do
	BLOQUE1
	if CONDICIÓN then
		break
	end
	BLOQUE2
end
BLOQUE3

de tal forma que cuando la condición sea true (verdadera), saldrá del bucle y seguirá con el resto del programa (bloque3)

continue (sólo en LuaDEV): Como la de arriba, sirve para "saltarse" partes de código, pero sin salir del bucle, es decir, sólo continúa hacia la siguiente iteración:

while true do
	BLOQUE1
	if CONDICIÓN then
		continue
	end
	BLOQUE2
end
BLOQUE3

Cuando condición sea true, se saltará el bloque2 y continuará desde bloque1

Ahora un ejemplo usando tanto break como continue:

for i=0, 5 do
	print("Iniciando iteracion... [i="..i.."]")
	if i < 3 then
		continue
	end
	if i == 4 then
		break
	end
	print( i )
end
print("FIN")

Ese trozo de código daría este resultado:

Iniciando iteracion... -- i=0
Iniciando iteracion... -- i=1
Iniciando iteracion... -- i=2
Iniciando iteracion... -- i=3
3                      
Iniciando iteracion... -- i=4
FIN

Nota: todo lo que va después de dos guiones "--" es un comentario, es decir, no afecta en nada al código

Eso es todo en cuanto a estructuras de control.

Algoritmos

Un algoritmo no es más que una serie de pasos ORDENADOS de tal forma que nos ayuden a resolver un problema o alcanzar una meta propuesta, para ello nos valdremos de lo que hemos estado aprendiendo.

Por poner un ejemplo, queremos abrir una ventana (no de Microsoft Windows ¬¬'), los pasos a seguir serán:

1.- Caminar hacia la ventana
2.- Verificar si la ventana está cerrada (esto representa un if)
3.- si lo está, procedemos a abrirla (bloque)
4.- FIN

¿Ven porque la importancia de un algoritmo?, un algoritmo bien planteado nos ayudará luego a codificar lo que queremos lograr.

Compliquemos un poco el algoritmo de arriba para introducir más estructuras de control:

1.- Si estamos sentados en una silla (if condición then)
2.- Nos levantamos (bloque1)
3.- Sino (else), nos quedamos parados (bloque2)
(Ahora procedemos a avanzar)
4.- Mientras no estemos al pie de la ventana hacer lo que sigue: (while condicion do)
5.- Dar un paso hacia ella (bloque)
(Aquí sale del "while" y continúa)
6.- Verificar si la ventana está cerrada (otro if)
7.- Si lo está, procedemos a abrirla (bloque1)
8.- Si no lo está (else), la dejamos quieta (bloque2)
9.- FIN

Y ya con eso tendríamos un algoritmo para abrir una ventana. Entonces, cuando queramos programar algo, tenemos que plantearnos primero estas dos preguntas y resolverlas:

 - ¿A dónde queremos llegar?

 - ¿Cómo lo vamos a lograr?

Hasta aquí la parte teórica y básica de programación, las próximas entregas serán prácticas, e iremos a lo concreto, el intérprete LuaDEV.

Tutoriales realizados con la ayuda y asesoramiento de DeViaNTe