Tutorial lua en linux (variables,tipos)

Esta un poco muerto el sitio y como lo he dicho antes esto se debe a que no hay mucho de que hablar en linux,ya que mucha información que necesitemos esta a un simple comando:

man algo

Y es un poco aburrido hacer un tutorial de algo que nadie va a usar.

Lua es un buen lenguaje que se usa de diversas formas y aquí vamos a usarlo como script,como lo hacemos con Python,Perl y Bash.

Así que hola Lua :D y espero que les funcionen estos tutoriales.

Bien antes que nada vamos a instalar:

En ubuntu y derivados basta con:

sudo apt-get install lua5.2

Y es la versión que usaremos la 5.2,para otros sistemas solo usen los comandos que usan normalmente,por ejemplo:

En gentoo buscamos:

eix lua

Y luego instalamos el paquete.

Bien todo esto lo haremos desde la consola así que primero que nada vamos a crear una carpeta donde trabajar:

mkdir ~/Documentos/lua

Por ejemplo.

Y nos cambiamos a ese directorio:

cd ~/Documentos/lua

Ahora vamos a escribir el primer programa:

Con nuestro editor favorito(de consola) creamos un archivo llamado hola.lua:

Los archivos lua regularmente tienen la extensión .lua.

La primera linea del script puede ser el hashbang ya que podemos ejecutar el script como un ejecutable,así que es recomendable:

# : hash

! : bang

/usr/bin/env : Ruta del programa env que busca a lua

lua : Y el nombre del ejecutable que usa como parametro env

#!/usr/bin/env lua

Con eso ya podemos darle permisos de ejecución a nuestros scripts y los podremos correr sin llamar el lenguaje nosotros mismos,por ejemplo:

Con hashbang un programa se puede ejecutar así:

chmod +x /ruta/script.lua

y

/ruta/script.lua

o así:

lua /ruta/script.lua

Y sin el hashbang solo se puede ejecutar así:

lua /ruta/script.lua

Ahora la segunda linea puede ser un comentario los cuales inician con un doble guion medio,por ejemplo :

-- Este es mi primer script en lua5

Normalmente esas lineas son necesarias en todos los scripts aunque son opcionales,aunque menos opcionales que los módulos.

Así que todos nuestros script tendrán el hashbang y uno o mas comentarios.

El programa Hola mundo es un programa que se muestra por el stdout(standart ouput[Salida estándar]).

El cual podemos llevar a cabo con la función print de lua o con la función io.write:

print ("Mi primer programa en Lua :D")
io.write("Hola Mundo!!!\n")

Bien esa es la bienvenida,ahora vamos a ver algunos tipos de datos:

Primero que nada tenemos que almacenar nuestro valor en una variable:

Los cuales son string(cadenas de texto),encerradas en comillas o comillas dobles:

cadena = "Una cadena de texto"

Numeros (sin tipo,nada de flotante y entero,etc):

Por ejemplo:

num_f = 3.14

num_d = 10

Booleanos que son solo true y false(nada de 0 y 1),lua solo ve booleanos con las palabras especiales true o false.

bool = true

Funciones,como las que nosotros mismos crearemos en futuros tutoriales y las que trae programadas,como print.

Y nil que es un valor único el que se otorga a la nada(por así decirlo).

Si no me creen ejecuten este programa:

#!/usr/bin/env lua
-- Este es mi segundo script en lua5

cadena = "Una cadena de texto"
num_f = 3.14
num_d = 10
bool = true

print ("Variable cadena es : "..type(cadena))
print("Variable num_f es : "..type(num_f))
print("Variable num_d es : "..type(num_d))
print("Variable bool es : "..type(bool))
print("Print es :"..type(print))

Eso pudo haber salido mejor:

#!/usr/bin/env lua
-- Este es mi segundo script en lua5
--
cadena = "Una cadena de texto"
num_f = 3.14
num_d = 10
bool = true

vars = {cadena,num_f,num_d,bool}
tipos = {"Variable cadena","Variable num_f","Variable num_d","Variable bool"}

for i = 1,#tipos do
    print (tipos[i].." es : "..type(vars[i]))
end


Y aun mejor,pero es lo que aprenderán en estos tutoriales,pero eso me recuerda que están también los tipos de datos table,que antes usamos para crear un menú para awesome:

El cual se define de esta manera:

tabla = {"Hola","Mundo"}

print (type(tabla))

Esa es una tabla básica de una dimensión,a la cual podemos acceder a sus elementos usando corchetes indicando su valor comenzando desde uno.

print(tabla[1].." "..tabla[2])

Aunque el valor 0 esta definido (como nil),podemos cambiarlo,por ejemplo por el nombre de la tabla,pero por defecto se comienza a contar desde 1:

tabla[0] = "tabla"

print(tabla[0])

O también podemos hacer algo como esto:

tabla = {[0] = "Hola","Mundo"}

Pero eso lo veremos en una entrada dedicada,a las tablas por ultimo veremos paso de argumentos y leer valor desde el teclado:

Para pasar un parámetro se usa la tabla especial arg,con el valor que queramos usar comenzando desde el cero:

#!/usr/bin/env lua
-- Mi tercer programa con lua5

print("Nombre del programa: "..arg[0])

for i = 1,#arg do -- El # quiere decir el numero de valores de la tabla
    print(i..": Argumento => "..arg[i])
end

Podemos ejecutar nuestro script como esta en la imagen:

Otro ejemplo clásico:

#!/usr/bin/env lua
-- Mi cuarto programa en lua
--

if #arg > 0 then
    print("Hola : "..arg[1])
else
    print("Uso: "..arg[0].." <nombre>")     
end

También cabe aclarar que los argumentos comienzan con el 0,pero también cuenta lo que esta antes del nombre,por ejemplo si ejecutamos de esta manera:

lua script.lua uno

Estos serian los argumentos:

lua = arg[-1]

script.lua = arg[0]

uno = arg[1]

Bien ahora vamos a ver como se haría esto fácilmente desde la lectura del teclado(stdin[Standart input]):

#!/usr/bin/env lua
-- Mi quinto programa en lua
--

print("exit para salir")

while true do
    io.write("Escribe tu nombre: ")
    nombre = io.read() -- Funcion que usamos para stdin
    if nombre == "exit" then
        print("Hola : "..nombre.." :P")
        break
    else
        print("Hola : "..nombre)
    end
end

Como ven lua es sencillo y podríamos usarlo en administración del sistema o muchas cosas ya que cuenta con modulos desde JSON,hasta MVC Web,pero aquí termina el primer tutorial.