Lua

Lua ( / ˈ l uː . ə / , LOO -ə ; del portugués : lua [ ˈlu(w)ɐ ] que significa luna ) es un lenguaje de programación ligero , de alto nivel y multiparadigma diseñado principalmente para su uso integrado en aplicaciones. ^{[ 2 ]} Lua es un software multiplataforma , ya que el intérprete del código de bytes compilado está escrito en ANSI C , ^{[ 3 ]} y Lua tiene una interfaz de programación de aplicaciones ( API ) C relativamente simple para integrarlo en aplicaciones. ^{[ 4 ]}

Lua surgió en 1993 como un lenguaje para extender aplicaciones de software y satisfacer la creciente demanda de personalización de la época. Ofrecía las funcionalidades básicas de la mayoría de los lenguajes de programación procedimentales , pero no incluía características más complejas o específicas de un dominio ; en cambio, incorporaba mecanismos para extender el lenguaje, permitiendo a los programadores implementar dichas características. Dado que Lua se concibió como un lenguaje de extensión general e integrable, sus diseñadores se centraron en mejorar su velocidad , portabilidad , extensibilidad y facilidad de uso en el desarrollo.

Lua fue creado en 1993 por Roberto Ierusalimschy , Luiz Henrique de Figueiredo y Waldemar Celes, miembros del Grupo de Tecnología de Gráficos por Computadora ( Tecgraf ) de la Pontificia Universidad Católica de Río de Janeiro , en Brasil .

Desde 1977 hasta 1992, Brasil mantuvo una política de fuertes barreras comerciales (conocida como reserva de mercado) para hardware y software informático , bajo la creencia de que Brasil podía y debía producir su propio hardware y software. En ese contexto, los clientes de Tecgraf no podían permitirse, ni política ni financieramente, comprar software personalizado en el extranjero; bajo la reserva de mercado, los clientes debían someterse a un complejo proceso burocrático para demostrar que sus necesidades no podían ser satisfechas por empresas brasileñas. Estas razones llevaron a Tecgraf a implementar desde cero las herramientas básicas que necesitaba. ^{[ 5 ]}

Los predecesores de Lua fueron los lenguajes de descripción y configuración de datos Simple Object Language (SOL) y Data-Entry Language (DEL). ^{[ 6 ]} Estos lenguajes fueron desarrollados de forma independiente en Tecgraf entre 1992 y 1993 para aportar flexibilidad a dos proyectos diferentes (ambos programas gráficos interactivos para aplicaciones de ingeniería en la empresa Petrobras ). SOL y DEL carecían de estructuras de control de flujo, y Petrobras sentía la creciente necesidad de dotarlos de plena capacidad de programación.

En La evolución de Lua , los autores del lenguaje escribieron: ^{[ 5 ]}

En 1993, el único competidor real era Tcl , diseñado específicamente para integrarse en aplicaciones. Sin embargo, Tcl tenía una sintaxis poco familiar, no ofrecía un buen soporte para la descripción de datos y solo funcionaba en plataformas Unix. Descartamos LISP y Scheme debido a su sintaxis poco amigable. Python aún estaba en sus inicios. En el ambiente de código abierto y de "hágalo usted mismo" que reinaba entonces en Tecgraf, era lógico que intentáramos desarrollar nuestro propio lenguaje de scripting  . Dado que muchos usuarios potenciales no eran programadores profesionales, el lenguaje debía evitar una sintaxis y semántica crípticas. La implementación del nuevo lenguaje debía ser altamente portable, ya que los clientes de Tecgraf utilizaban una gran variedad de plataformas informáticas. Finalmente, como esperábamos que otros productos de Tecgraf también necesitaran integrar un lenguaje de scripting, el nuevo lenguaje debía seguir el ejemplo de SOL y proporcionarse como una biblioteca con una API en C.

Lua 1.0 fue diseñado de tal manera que sus constructores de objetos, siendo entonces ligeramente diferentes del estilo ligero y flexible actual, incorporaron la sintaxis de descripción de datos de SOL (de ahí el nombre Lua: Sol significa "Sol" en portugués, y Lua significa "Luna"). La sintaxis de Lua para las estructuras de control se tomó prestada principalmente de Modula ( if, while, repeat/ until), pero también recibió influencia de CLU (asignaciones múltiples y retornos múltiples de llamadas a funciones, como una alternativa más simple a los parámetros de referencia o punteros explícitos ), C++ ("buena idea de permitir que una variable local se declare solo donde la necesitamos" ^{[ 5 ]} ), SNOBOL y AWK ( matrices asociativas ). En un artículo publicado en Dr. Dobb's Journal , los creadores de Lua también afirman que LISP y Scheme con su mecanismo de estructura de datos único y omnipresente (la lista ) fueron una gran influencia en su decisión de desarrollar la tabla como la estructura de datos principal de Lua. ^{[ 7 ]}

La semántica de Lua ha sido cada vez más influenciada por Scheme con el tiempo, ^{[ 5 ]} especialmente con la introducción de funciones anónimas y alcance léxico completo . Se agregaron varias características en nuevas versiones de Lua.

Las versiones de Lua anteriores a la 5.0 se publicaban bajo una licencia similar a la BSD . A partir de la versión 5.0, Lua se rige por la licencia MIT . Ambas son licencias de software libre permisivas y prácticamente idénticas.

Lua se describe comúnmente como un lenguaje " multiparadigma ", que proporciona un pequeño conjunto de características generales que pueden extenderse para adaptarse a diferentes tipos de problemas. Lua no incluye soporte explícito para la herencia , pero permite su implementación mediante metatablas . Asimismo, Lua permite a los programadores implementar espacios de nombres , clases y otras características relacionadas utilizando su implementación de tabla única; las funciones de primera clase permiten el empleo de muchas técnicas de la programación funcional y el alcance léxico completo permite ocultar información de forma granular para garantizar el principio del mínimo privilegio .

En general, Lua se esfuerza por proporcionar metacaracterísticas simples y flexibles que se puedan extender según sea necesario, en lugar de ofrecer un conjunto de características específico para un paradigma de programación. Como resultado, el lenguaje base es ligero ; el intérprete de referencia completo solo ocupa unos 293 kB compilado ^{[ 3 ]} y se adapta fácilmente a una amplia gama de aplicaciones. 

Como lenguaje de tipado dinámico diseñado para usarse como lenguaje de extensión o lenguaje de scripting , Lua es lo suficientemente compacto como para adaptarse a diversas plataformas. Admite solo un pequeño número de estructuras de datos atómicas, como valores booleanos , números ( de punto flotante de doble precisión y enteros de 64 bits por defecto) y cadenas . Las estructuras de datos típicas, como matrices , conjuntos , listas y registros, se pueden representar utilizando la única estructura de datos nativa de Lua, la tabla, que es esencialmente una matriz asociativa heterogénea .

Lua implementa un pequeño conjunto de características avanzadas, como funciones de primera clase , recolección de basura , cierres , llamadas recursivas , coerción (conversión automática entre valores de cadena y numéricos en tiempo de ejecución), corrutinas (multitarea cooperativa) y carga dinámica de módulos .

imprimir ( "¡Hola, mundo!" )

Imprimir "¡Hola, mundo!"

variable local

Estudiantes locales = 1000

-- Comentario de una sola línea --[[ Comentario de varias líneas --]]

función factorial ( n ) local x = 1 para i = 2 , n hacer x = x * i fin devolver x fin

Si condición entonces --fin del cuerpo de la instrucción

Si x ~= 10 , entonces imprime ( x ) fin

Si la condición entonces --cuerpo de la instrucción si no --cuerpo de la instrucción fin

Si x == 10, entonces imprime ( 10 ) ; de lo contrario, imprime ( x ) .

if condición then --cuerpo de la instrucción elseif condición then --cuerpo de la instrucción else -- opcional --opcional cuerpo de la instrucción predeterminado end

Si x == y, entonces imprime ( "x = y" ). Si no, si x == z , imprime ( "x = z" ). Si no , imprime opcionalmente ( "x no es igual a ninguna otra variable" ) .

--condición = verdaderomientras condición hacer --declaraciones finrepetir --instrucciones hasta que se cumpla la condiciónpara i = first , last , delta hacer --delta puede ser negativo, lo que permite que el bucle for cuente hacia atrás o hacia adelante --instrucciones --ejemplo: print(i) fin

para clave , valor en pares ( _G ) hacer imprimir ( clave , valor ) fin

cuadrícula local = { { 11 , 12 , 13 }, { 21 , 22 , 23 }, { 31 , 32 , 33 } }para y , fila en pares ( cuadrícula ) hacer para x , valor en pares ( fila ) hacer imprimir ( x , y , valor ) fin fin

hacer local oldprint = print -- Almacenar la función print actual como función oldprint print ( s ) --[[ Redefinir la función print. La función print habitual aún se puede usar  a través de oldprint. La nueva tiene solo un argumento.]] oldprint ( s == "foo" and "bar" or s ) end end

function addto ( x ) -- Devuelve una nueva función que suma x al argumento return function ( y ) --[[ Cuando nos referimos a la variable x, que está fuera del  ámbito actual y cuya vida útil sería más corta que la de esta  función anónima, Lua crea un cierre.]] return x + y end end fourplus = addto ( 4 ) print ( fourplus ( 3 )) -- Imprime 7--Esto también se puede lograr llamando a la función de la siguiente manera: print ( addto ( 4 )( 3 )) --[[ Esto se debe a que estamos llamando a la función devuelta por 'addto(4)' con el argumento '3' directamente.  Esto también ayuda a reducir el costo de datos y a mejorar el rendimiento si se llama de forma iterativa.]]

a_table = {} -- Crea una tabla nueva y vacía

a_table = { x = 10 } -- Crea una nueva tabla, con una entrada que asigna "x" al número 10. print ( a_table [ "x" ]) -- Imprime el valor asociado con la clave de cadena, en este caso 10. b_table = a_table b_table [ "x" ] = 20 -- El valor en la tabla se ha cambiado a 20. print ( b_table [ "x" ]) -- Imprime 20. print ( a_table [ "x" ]) -- También imprime 20, porque a_table y b_table se refieren a la misma tabla.

punto = { x = 10 , y = 20 } -- Crea una nueva tabla print ( punto [ "x" ]) -- Imprime 10 print ( punto . x ) -- Tiene exactamente el mismo significado que la línea anterior. La notación de punto, más fácil de leer, es solo azúcar sintáctico.

Punto = {}Punto.nuevo = función ( x , y ) return { x = x , y = y } -- return {["x"] = x, ["y"] = y } finPunto.set_x = función ( punto , x ) punto.x = x -- punto["x" ] = x ; fin

array = { "a" , "b" , "c" , "d" } -- Los índices se asignan automáticamente. print ( array [ 2 ]) -- Imprime "b". La indexación automática en Lua comienza en 1. print ( # array ) -- Imprime 4. # es el operador de longitud para tablas y cadenas. array [ 0 ] = "z" -- Cero es un índice válido. print ( # array ) -- Sigue imprimiendo 4, ya que los arrays de Lua están basados ​​en 1.

ExampleTable = { { 1 , 2 , 3 , 4 }, { 5 , 6 , 7 , 8 } } print ( ExampleTable [ 1 ][ 3 ]) -- Imprime "3" print ( ExampleTable [ 2 ][ 4 ]) -- Imprime "8"

function Point ( x , y ) -- Constructor de objeto "Point" return { x = x , y = y } -- Crea y devuelve un nuevo objeto (tabla) end array = { Point ( 10 , 20 ), Point ( 30 , 40 ), Point ( 50 , 60 ) } -- Crea un array de puntos -- array = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } }; print ( array [ 2 ]. y ) -- Imprime 40

fibs = { 1 , 1 } -- Valores iniciales para fibs[1] y fibs[2]. setmetatable ( fibs , { __index = function ( values ​​, n ) --[[__index es una función predefinida por Lua,  se llama si la clave "n" no existe.]] values ​​[ n ] = values ​​[ n - 1 ] + values ​​[ n - 2 ] -- Calcular y memorizar fibs[n]. return values ​​[ n ] end })

local Vector = {} local VectorMeta = { __index = Vector }función Vector.new ( x , y , z ) -- El constructor devuelve setmetatable ( { x = x , y = y , z = z } , VectorMeta ) finfunción Vector.magnitud ( self ) -- Otro método devuelve math.sqrt ( self.x ^ 2 + self.y ^ 2 + self.z ^ 2 ) fin​​​​​​local vec = Vector.new ( 0 , 1 , 0 ) -- Crea un vector print ( vec.magnitude ( vec ) ) -- Llama a un método (salida: 1) print ( vec.x ) -- Accede a una variable miembro ( salida : 0)

Vector local = {} Vector . __index = Vectorfunción Vector : new ( x , y , z ) -- El constructor -- Dado que la definición de la función utiliza dos puntos, -- su primer argumento es "self", que se refiere -- a "Vector" return setmetatable ({ x = x , y = y , z = z }, self ) endfunción Vector : magnitud () -- Otro método -- Referencia el objeto implícito usando self return math.sqrt ( self . x ^ 2 + self . y ^ 2 + self . z ^ 2 ) endlocal vec = Vector : new ( 0 , 1 , 0 ) -- Crea un vector print ( vec : magnitude ()) -- Llama a un método (salida: 1) print ( vec . x ) -- Accede a una variable miembro (salida: 0)

Vector local = {} Vector . __index = Vectorfunción Vector : new ( x , y , z ) -- El constructor -- Aquí, self se refiere al método "new" de la clase que llamemos. En una clase derivada, self será la clase derivada; en la clase Vector, self será Vector. return setmetatable ({ x = x , y = y , z = z }, self ) endfunción Vector : magnitud () -- Otro método -- Referencia el objeto implícito usando self return math.sqrt ( self . x ^ 2 + self . y ^ 2 + self . z ^ 2 ) end-- Ejemplo de herencia de pseudoclase local VectorMult = {} VectorMult . __index = VectorMult setmetatable ( VectorMult , Vector ) -- Hacer que VectorMult sea hijo de Vectorfunción VectorMult : multiplicar ( valor ) self.x = self.x * valor self.y = self.y * valor self.z = self.z * valor devolver self fin​​​​​​​​​​​​local vec = VectorMult : new ( 0 , 1 , 0 ) -- Crea un vector print ( vec : magnitude ()) -- Llama a un método (salida: 1) print ( vec . y ) -- Accede a una variable miembro (salida: 1) vec : multiply ( 2 ) -- Multiplica todos los componentes del vector por 2 print ( vec . y ) -- Accede al miembro de nuevo (salida: 2)

Los programas Lua no se interpretan directamente desde el archivo de texto Lua, sino que se compilan en bytecode, que luego se ejecuta en la máquina virtual (VM) de Lua. El proceso de compilación suele ser invisible para el usuario y se realiza durante la ejecución , especialmente cuando se utiliza un compilador de compilación justo a tiempo (JIT), pero puede realizarse sin conexión para aumentar el rendimiento de carga o reducir el consumo de memoria del entorno anfitrión al omitir el compilador. El bytecode de Lua también puede generarse y ejecutarse desde dentro de Lua, utilizando la dumpfunción de la biblioteca de cadenas y las load/loadstring/loadfilefunciones. La versión 5.5.0 de Lua está implementada en aproximadamente 32 000 líneas de código C. ^{[ 3 ]}

Al igual que la mayoría de las CPU, y a diferencia de la mayoría de las máquinas virtuales (que se basan en pilas ), la máquina virtual de Lua se basa en registros y, por lo tanto, se asemeja más al diseño de la mayoría del hardware. La arquitectura de registros evita la copia excesiva de valores y reduce el número total de instrucciones por función. La máquina virtual de Lua 5 es una de las primeras máquinas virtuales puras basadas en registros que tuvo un uso generalizado. ^{[ 16 ]} Parrot y Dalvik de Android son otras dos máquinas virtuales basadas en registros bien conocidas. La máquina virtual de PCScheme también se basaba en registros. ^{[ 17 ]}

Este ejemplo es el listado de código de bytes de la función factorial definida anteriormente (tal como lo muestra el luaccompilador 5.1): ^{[ 18 ]}

función <factorial.lua:1,7> (9 instrucciones, 36 bytes en 0x8063c60) 1 parámetro, 6 ranuras, 0 valores ascendentes, 6 variables locales, 2 constantes, 0 funciones 1 [2] CARGAR 1 -1 ; 1 2 [3] CARGAR 2 -2 ; 2 3 [3] MOVER 3 0 4 [3] CARGAR 4 -1 ; 1 5 [3] FORPREP 2 1 ; a 7 6 [4] MUL 1 1 5 7 [3] FORLOOP 2 -2 ; a 6 8 [6] RETORNO 1 2 9 [7] RETORNO 0 1

Lua está diseñado para integrarse en otras aplicaciones y proporciona una API en C para este fin. La API se divide en dos partes: el núcleo de Lua y la biblioteca auxiliar de Lua. ^{[ 19 ]} El diseño de la API de Lua elimina la necesidad de conteo manual de referencias (gestión) en el código C, a diferencia de la API de Python . La API, al igual que el lenguaje, es minimalista. Las funciones avanzadas las proporciona la biblioteca auxiliar, que consiste principalmente en macros de preprocesador que facilitan las operaciones complejas con tablas.

La API de Lua para C se basa en una pila . Lua proporciona funciones para insertar y extraer la mayoría de los tipos de datos simples de C (enteros, números de coma flotante, etc.) de la pila, así como funciones para manipular tablas a través de ella. La pila de Lua es algo diferente de una pila tradicional; por ejemplo, se puede indexar directamente. Los índices negativos indican desplazamientos desde la parte superior de la pila. Por ejemplo, -1 es la parte superior (el valor insertado más recientemente), mientras que los índices positivos indican desplazamientos desde la parte inferior (el valor más antiguo). La transferencia de datos entre funciones de C y Lua también se realiza mediante la pila. Para llamar a una función de Lua, los argumentos se insertan en la pila y luego lua_callse utiliza para llamar a la función propiamente dicha. Al escribir una función de C para ser llamada directamente desde Lua, los argumentos se leen de la pila.

Aquí hay un ejemplo de cómo llamar a una función Lua desde C:

#include <stdio.h> #include <lua.h> // Biblioteca principal de Lua (lua_*) #include <lauxlib.h> // Biblioteca auxiliar de Lua (luaL_*)int main ( void ) { // crea un estado Lua lua_State * L = luaL_newstate ();// Cargar y ejecutar una cadena if ( luaL_dostring ( L , "function foo (x,y) return x+y end" )) { lua_close ( L ); return -1 ; }// Inserta el valor de la variable global "foo" (la función definida anteriormente) // en la pila, seguido de los enteros 5 y 3 lua_getglobal ( L , "foo" ); lua_pushinteger ( L , 5 ); lua_pushinteger ( L , 3 ); lua_call ( L , 2 , 1 ); // Llama a una función con dos argumentos y un valor de retorno printf ( "Resultado: %d \n " , lua_tointeger ( L , -1 )); // Imprime el valor entero del elemento en la cima de la pila lua_pop ( L , 1 ); // Devuelve la pila a su estado original lua_close ( L ); // Cierra el estado de Lua return 0 ; }

Al ejecutar este ejemplo se obtiene:

$ cc -o example example.c -llua $ ./example Resultado: 8

La API de C también proporciona algunas tablas especiales, ubicadas en varios "pseudoíndices" en la pila de Lua. En LUA_GLOBALSINDEXversiones anteriores a Lua 5.2 ^{[ 20 ]} se encuentra la tabla globals, _Gdentro de Lua, que es el espacio de nombres principal . También hay un registro ubicado LUA_REGISTRYINDEXdonde los programas de C pueden almacenar valores de Lua para su posterior recuperación.

En el desarrollo de videojuegos , Lua se utiliza ampliamente como lenguaje de scripting , principalmente debido a su facilidad de integración, ejecución rápida y curva de aprendizaje corta . ^{[ 24 ]} Entre los juegos notables que utilizan Lua se incluyen Roblox , ^{[ 25 ]} Garry's Mod , World of Warcraft , Payday 2 , Project Zomboid , Phantasy Star Online 2 , Dota 2 , Crysis , ^{[ 26 ]} y muchos otros. Además, Lua se utiliza en software que no es de videojuegos, como Adobe Lightroom , Moho , iClone , Aerospike y algunos programas del sistema en FreeBSD y NetBSD , y se utiliza como lenguaje de scripting de plantillas en MediaWiki mediante la extensión Scribunto. ^{[ 27 ]}

En 2003, una encuesta realizada por GameDev.net mostró que Lua era el lenguaje de scripting más popular para la programación de videojuegos. ^{[ 28 ]} El 12 de enero de 2012, Lua fue anunciado como ganador del premio Front Line Award 2011 de la revista Game Developer en la categoría de Herramientas de Programación. ^{[ 29 ]}

Muchas aplicaciones que no son juegos también utilizan Lua para la extensibilidad, como LuaTeX , una implementación del lenguaje de configuración de tipos TeX ; Redis , una base de datos clave-valor ; ScyllaDB , un almacén de columnas anchas ; Neovim , un editor de texto; Nginx , un servidor web ; Wireshark , un analizador de paquetes de red; Discordia, una biblioteca API de Discord ; y Pure Data , un lenguaje de programación de audio visual (a través de la extensión pdlua).

• Comparación de lenguajes de programación
• Löve (marco de juego)

• Jerusalén, R. (2013). Programación en Lua (3ª  ed.). Lua.org. ISBN 978-85-903798-5-0.(La primera edición está disponible en línea ).
• Gutschmidt, T. (2003). Programación de juegos con Python, Lua y Ruby . Course Technology PTR. ISBN 978-1-59200-077-7.
• Schuytema, P.; Manyen, M. (2005). Desarrollo de juegos con Lua . Medios de Charles River. ISBN 978-1-58450-404-7.
• Jung, K.; Brown, A. (2007). Introducción a la programación en Lua . Wrox Press . ISBN 978-0-470-06917-2Archivado del original el 8 de julio de 2018. Consultado el 7 de julio de 2018 .
• Figueiredo, LH; Celes, W.; Jerusalénimschy, R., eds. (2008). Gemas de programación Lua . Lua.org. ISBN 978-85-903798-4-3.
• Takhteyev, Yuri (2012). Coding Places: Software Practice in a South American City . The MIT Press . ISBN 978-0-262-01807-4Archivado del original el 2 de noviembre de 2012.Los capítulos 6 y 7 están dedicados a Lua, mientras que otros analizan el software en Brasil de forma más general.
• Varma, Jayant (2012). Aprende Lua para el desarrollo de juegos para iOS . Apress . ISBN 978-1-4302-4662-6.
• Matheson, Ash (29 de abril de 2003). "Una introducción a Lua" . GameDev.net . Archivado del original el 18 de diciembre de 2012. Recuperado el 3 de enero de 2013 .
• Fieldhouse, Keith (16 de febrero de 2006). "Presentando Lua" . ONLamp.com . O'Reilly Media . Archivado del original el 12 de marzo de 2006. Recuperado el 28 de febrero de 2006 .
• Streicher, Martin (28 de abril de 2006). "Scripts integrables con Lua" . developerWorks . IBM . Archivado del original el 2 de julio de 2009. Recuperado el 7 de julio de 2018 .
• Quigley, Joseph (1 de junio de 2007). "Una mirada a Lua" . Linux Journal .
• Hamilton, Naomi (11 de septiembre de 2008). "El AZ de los lenguajes de programación: Lua" . Computerworld . IDG . Archivado del original el 8 de julio de 2018. Recuperado el 7 de julio de 2018 .Entrevista con Roberto Ierusalimschy.
• Jerusalén, Roberto; de Figueiredo, Luiz Henrique; Celes, Waldemar (12 de mayo de 2011). "Pasar una lengua por el ojo de una aguja" . Cola ACM . 9 (5): 20– 29. doi : 10.1145/1978862.1983083 . S2CID 19484689 . Cómo influyó la capacidad de integración de Lua en su diseño.
• Jerusalén, Roberto; de Figueiredo, Luiz Henrique; Celes, Waldemar (26 de octubre de 2018). «Una mirada al diseño de Lua» . Comunicaciones de la ACM . 61 (11): 114– 123. doi : 10.1145/3186277 . S2CID 53114923 . 
• Artículos y tesis sobre Lua

• Sitio web oficial
• Usuarios de Lua archivados el 16 de diciembre de 2010 en Wayback Machine , Comunidad
• Foro de Lua archivado el 28 de septiembre de 2021 en Wayback Machine.
• LuaDist
• Lua Rocks - Gestor de paquetes
• Proyectos en Lua