Lua ( / ˈ l uː ə / LOO -ə ; del portugués : lua [ˈlu(w)ɐ] que significa luna ) es un lenguaje de programación multiparadigma , liviano y de alto nivel diseñado principalmente para uso integrado en aplicaciones. [3] Lua es multiplataforma , ya que el intérprete del código de bytes compilado está escrito en ANSI C , [4] y Lua tiene una API C relativamente simple para integrarlo en las aplicaciones. [5]
Lua se originó en 1993 como un lenguaje para extender aplicaciones de software para satisfacer la creciente demanda de personalización en ese momento. Proporcionó las funciones básicas de la mayoría de los lenguajes de programación procedimentales , pero no se incluyeron características más complicadas o específicas de un dominio ; más bien, incluía mecanismos para extender el lenguaje, permitiendo a los programadores implementar tales características. Como Lua estaba destinado a ser un lenguaje de extensión integrable general, los diseñadores de Lua se centraron en mejorar su velocidad , portabilidad , extensibilidad y facilidad de uso en el desarrollo.
Lua fue creada en 1993 por Roberto Ierusalimschy , Luiz Henrique de Figueiredo y Waldemar Celes, miembros del Grupo de Tecnología de Computación Gráfica (Tecgraf) de la Pontificia Universidad Católica de Río de Janeiro , en Brasil .
Desde 1977 hasta 1992, Brasil tuvo una política de fuertes barreras comerciales (llamadas reserva de mercado) para hardware y software de computadora, creyendo que Brasil podía y debía producir su propio hardware y software. En esa atmósfera, los clientes de Tecgraf no podían darse el lujo, ni política ni financieramente, de comprar software personalizado en el extranjero; Bajo la reserva de mercado, los clientes tendrían que pasar por un complicado proceso burocrático para demostrar que las empresas brasileñas no pueden satisfacer sus necesidades. Esas razones llevaron a Tecgraf a implementar las herramientas básicas que necesitaba desde cero. [6] [ cita necesaria ]
Los predecesores de Lua fueron los lenguajes de configuración/descripción de datos SOL (lenguaje de objeto simple) y DEL (lenguaje de entrada de datos). [7] Se habían desarrollado de forma independiente en Tecgraf en 1992-1993 para agregar cierta flexibilidad a dos proyectos diferentes (ambos eran programas gráficos interactivos para aplicaciones de ingeniería en la empresa Petrobras ). Había una falta de estructuras de control de flujo en SOL y DEL, y Petrobras sintió una creciente necesidad de agregarles pleno poder de programación.
En La evolución de Lua , los autores del lenguaje escribieron: [6]
En 1993, el único contendiente real era Tcl , que había sido diseñado explícitamente para integrarse en aplicaciones. Sin embargo, Tcl tenía una sintaxis desconocida, no ofrecía un buen soporte para la descripción de datos y solo se ejecutaba en plataformas Unix. No consideramos LISP ni Scheme debido a su sintaxis poco amigable. Python todavía estaba en su infancia. En la atmósfera libre y de "hágalo usted mismo" que entonces reinaba en Tecgraf, era bastante natural que intentáramos desarrollar nuestro propio lenguaje de programación... Debido a que muchos usuarios potenciales del lenguaje no eran programadores profesionales, el lenguaje debería evitar las expresiones crípticas. sintaxis y semántica. La implementación del nuevo lenguaje debería ser altamente portátil, porque los clientes de Tecgraf tenían una colección muy diversa de plataformas informáticas. Finalmente, dado que esperábamos que otros productos de Tecgraf también necesitaran incorporar un lenguaje de programación, el nuevo lenguaje debería seguir el ejemplo de SOL y proporcionarse como una biblioteca con una API 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 estructuras de control se tomó prestada principalmente de Modula ( if, while, repeat/ until), pero también recibió influencia de CLU (múltiples asignaciones y múltiples retornos de llamadas a funciones, como una alternativa más simple a los parámetros de referencia o punteros explícitos ), C++ ("idea genial de permitir que una variable local sea declarada sólo donde la necesitamos" [6] ), SNOBOL y AWK ( arrays asociativos ). En un artículo publicado en Dr. Dobb's Journal , los creadores de Lua también afirman que LISP y Scheme con su único y ubicuo mecanismo de estructura de datos (la lista ) fueron una influencia importante en su decisión de desarrollar la tabla como la estructura de datos primaria de Lua. [8]
La semántica de Lua se ha visto cada vez más influenciada por Scheme a lo largo del tiempo, [6] especialmente con la introducción de funciones anónimas y alcance léxico completo . Se agregaron varias funciones en las nuevas versiones de Lua.
Las versiones de Lua anteriores a la versión 5.0 se lanzaron bajo una licencia similar a la licencia BSD . A partir de la versión 5.0, Lua tiene la licencia MIT . Ambas son licencias de software libre permisivas y son casi idénticas.
Lua se describe comúnmente como un lenguaje " multiparadigma ", que proporciona un pequeño conjunto de características generales que pueden ampliarse para adaptarse a diferentes tipos de problemas. Lua no contiene soporte explícito para la herencia , pero permite implementarla con metatablas . De manera similar, 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 programación funcional y el alcance léxico completo permite ocultar información detallada para hacer cumplir el principio de privilegio mínimo .
En general, Lua se esfuerza por proporcionar metafunciones simples y flexibles que puedan ampliarse según sea necesario, en lugar de proporcionar un conjunto de funciones específicas para un paradigma de programación. Como resultado, el lenguaje base es ligero ; el intérprete de referencia completo tiene sólo unos 247 kB compilados [4] y se adapta fácilmente a una amplia gama de aplicaciones.
Como lenguaje escrito dinámicamente destinado a ser utilizado como lenguaje de extensión o lenguaje de secuencias de comandos , Lua es lo suficientemente compacto como para caber en una variedad de plataformas de host. Solo admite una pequeña cantidad de estructuras de datos atómicos, como valores booleanos , números ( coma flotante de doble precisión y enteros de 64 bits de forma predeterminada) y cadenas . Las estructuras de datos típicas, como matrices , conjuntos , listas y registros, se pueden representar utilizando la estructura de datos nativa única 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 de cola adecuadas , coerción (conversión automática entre valores de cadenas y números en tiempo de ejecución), corrutinas (multitarea cooperativa) y carga dinámica de módulos .
El clásico "¡Hola mundo!" El programa se puede escribir de la siguiente manera, con o sin paréntesis: [9] [a]
imprimir ( "¡Hola mundo!" )imprime "¡Hola mundo!"Un comentario en Lua comienza con un guión doble y llega hasta el final de la línea, similar a Ada , Eiffel , Haskell , SQL y VHDL . Las cadenas de varias líneas y los comentarios están adornados con corchetes dobles.
-- Comentario de una sola línea --[[ Comentario de varias líneas ]]La función factorial se implementa como una función en este ejemplo:
función factorial ( n ) local x = 1 para i = 2 , n hacer x = x * i end return x endLua tiene un tipo de prueba condicional : con construcciones de control de ejecución y if then endopcionales .elseelseif then
La if then enddeclaración genérica requiere las tres palabras clave:
si la condición entonces --final del cuerpo de la declaraciónLa elsepalabra clave se puede agregar con un bloque de declaración adjunto para controlar la ejecución cuando la ifcondición se evalúa como false:
si la condición entonces --cuerpo de la declaración else --fin del cuerpo de la declaraciónLa ejecución también se puede controlar según múltiples condiciones utilizando las elseif thenpalabras clave:
si la condición entonces --cuerpo de la declaración elseif condición entonces --cuerpo de la declaración else -- opcional --opcional final del cuerpo de la declaración predeterminadaLua tiene cuatro tipos de bucles condicionales: el whilebucle , el repeatbucle (similar a un do whilebucle ), el forbucle numérico y el forbucle genérico.
--condición = verdaderomientras que la condición lo hace: las declaraciones terminanrepetir --declaraciones hasta la condiciónfor i = primero , último , delta do --delta puede ser negativo, permitiendo que el bucle for cuente hacia atrás o hacia arriba --declaraciones --ejemplo: print(i) endEste forbucle genérico iteraría sobre la tabla _Gusando la función iteradora estándar pairs, hasta que devuelva nil:
para clave , valor en pares ( _G ) imprime ( clave , valor ) fin Los bucles también se pueden anidar (colocarlos dentro de otro bucle).
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 ) imprimir ( x , y , valor ) fin fin El tratamiento que hace Lua de las funciones como valores de primera clase se muestra en el siguiente ejemplo, donde se modifica el comportamiento de la función de impresión:
do local oldprint = print - Almacenar la función de impresión actual como función de impresión antigua print ( s ) --[[ Redefinir la función de impresión. La función de impresión habitual todavía se puede utilizar a través de la impresión antigua. El nuevo tiene solo un argumento.]] oldprint ( s == "foo" y "bar" or s ) end endCualquier llamada futura a printahora se enrutará a través de la nueva función y, debido al alcance léxico de Lua , la antigua función de impresión solo será accesible mediante la nueva impresión modificada.
Lua también admite cierres , como se demuestra a continuación:
function addto ( x ) -- Devuelve una nueva función que agrega x al argumento return function ( y ) --[[ Cuando nos referimos a la variable x, que está fuera del alcance 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 desde 'addto(4)' con el argumento ' 3' directamente. Esto también ayuda a reducir el costo de los datos y aumentar el rendimiento si se llama de forma iterativa.]]xCada vez que se llama se crea un nuevo cierre para la variable addto, de modo que cada nueva función anónima devuelta siempre accederá a su propio xparámetro. El cierre lo gestiona el recolector de basura de Lua, como cualquier otro objeto.
Las tablas son las estructuras de datos más importantes (y, por diseño, el único tipo de datos compuestos integrado ) en Lua y son la base de todos los tipos creados por el usuario. Son matrices asociativas con adición de clave numérica automática y sintaxis especial.
Una tabla es una colección de pares de claves y datos, donde se hace referencia a los datos por clave; en otras palabras, es una matriz asociativa heterogénea con hash .
Las tablas se crean utilizando la {}sintaxis del constructor.
a_table = {} : crea una tabla nueva y vacíaLas tablas siempre se pasan por referencia (ver Llamada compartiendo ).
Una clave (índice) puede tener cualquier valor excepto nilNaN , incluidas las funciones.
a_table = { x = 10 } - Crea una nueva tabla, con una entrada asignando "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 hacen referencia a la misma tabla. Una tabla se utiliza a menudo como estructura (o registro ) utilizando cadenas como claves. Debido a que este uso es muy común, Lua presenta una sintaxis especial para acceder a dichos campos. [11]
point = { x = 10 , y = 20 } - Crea una nueva tabla print ( point [ "x" ]) - Imprime 10 print ( point . x ) - Tiene exactamente el mismo significado que la línea anterior. La notación de puntos más fácil de leer es simplemente azúcar sintáctica.Al utilizar una tabla para almacenar funciones relacionadas, puede actuar como un espacio de nombres.
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; finA las tablas se les asigna automáticamente una clave numérica, lo que permite utilizarlas como un tipo de datos de matriz . El primer índice automático es 1 en lugar de 0 como ocurre con muchos otros lenguajes de programación (aunque se permite un índice explícito de 0).
Una clave numérica 1es distinta de una clave de cadena "1".
array = { "a" , "b" , "c" , "d" } : los índices se asignan automáticamente. print ( matriz [ 2 ]) - Imprime "b". La indexación automática en Lua comienza en 1. print ( # matriz ) : imprime 4. # es el operador de longitud para tablas y cadenas. array [ 0 ] = "z" - Cero es un índice legal. print ( # array ) : todavía imprime 4, ya que las matrices Lua están basadas en 1.La longitud de una tabla tse define como cualquier índice entero ntal que t[n]no sea nily t[n+1]sea nil; además, si t[1]es nil, npuede ser cero. Para una matriz regular, con valores distintos de nulos de 1 a un determinado n, su longitud es exactamente esa n, el índice de su último valor. Si la matriz tiene "huecos" (es decir, valores nulos entre otros valores no nulos), entonces #tpuede ser cualquiera de los índices que precede directamente a un nilvalor (es decir, puede considerar cualquier valor nulo como el final de la matriz). ). [12]
Tabla de ejemplo = { { 1 , 2 , 3 , 4 }, { 5 , 6 , 7 , 8 } } print ( Tabla de ejemplo [ 1 ][ 3 ]) -- Imprime "3" print ( Tabla de ejemplo [ 2 ][ 4 ]) - - Imprime "8"Una tabla puede ser una matriz de objetos.
función Punto ( x , y ) - Constructor de objetos "Punto" return { x = x , y = y } - Crea y devuelve un nuevo objeto (tabla) end array = { Punto ( 10 , 20 ), Punto ( 30 , 40 ), Punto ( 50 , 60 ) } - Crea una matriz de puntos - matriz = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } }; print ( matriz [ 2 ]. y ) - Imprime 40Usar un mapa hash para emular una matriz normalmente es más lento que usar una matriz real; sin embargo, las tablas de Lua están optimizadas para su uso como matrices para ayudar a evitar este problema. [13]
La semántica extensible es una característica clave de Lua y el concepto de metatabla permite una poderosa personalización de las tablas. El siguiente ejemplo demuestra una tabla "infinita". Para cualquiera n, fibs[n]dará el n-ésimo número de Fibonacci usando programación dinámica y memorización .
fibs = { 1 , 1 } - Valores iniciales para fibs[1] y fibs[2]. setmetatable ( fibs , { __index = función ( valores , n ) --[[__index es una función predefinida por Lua, se llama si la clave "n" no existe.]] valores [ n ] = valores [ n - 1 ] + valores [ n - 2 ] - Calcular y memorizar fibs[n]. valores de retorno [ n ] fin }) Aunque Lua no tiene un concepto incorporado de clases , la programación orientada a objetos se puede emular utilizando funciones y tablas. Un objeto se forma poniendo métodos y campos en una tabla. La herencia (tanto única como múltiple) se puede implementar con metatablas , delegando métodos y campos inexistentes a un objeto principal.
No existe el concepto de "clase" con estas técnicas; más bien, se utilizan prototipos , similares a Self o JavaScript . Los nuevos objetos se crean con un método de fábrica (que construye nuevos objetos desde cero) o clonando un objeto existente.
Creando un objeto vectorial básico :
Vector local = {} VectorMeta local = { __index = Vector } función vectorial . new ( x , y , z ) -- El constructor devuelve setmetatable ({ x = x , y = y , z = z }, VectorMeta ) endfunción vectorial . magnitud ( self ) -- Otro método return math.sqrt ( self . x ^ 2 + self . y ^ 2 + self . z ^ 2 ) end vec local = Vector . new ( 0 , 1 , 0 ) -- Crear un vector print ( vec . magnitud ( vec )) -- Llamar a un método (salida: 1) print ( vec . x ) -- Acceder a una variable miembro (salida: 0)Aquí, setmetatablele dice a Lua que busque un elemento en la Vectortabla si no está presente en la vectabla. , que equivale a , primero busca el elemento en la tabla. La tabla no tiene un elemento, pero su metatabla delega en la tabla el elemento cuando no se encuentra en la tabla.vec.magnitudevec["magnitude"]vecmagnitudevecmagnitudeVectormagnitudevec
Lua proporciona algo de azúcar sintáctico para facilitar la orientación a objetos. Para declarar funciones miembro dentro de una tabla prototipo, se puede usar , que equivale a . Llamar a métodos de clase también utiliza los dos puntos: es equivalente a .function table:func(args)function table.func(self, args)object:func(args)object.func(object, args)
Teniendo esto en cuenta, aquí hay una clase correspondiente con :azúcar sintáctico:
Vector local = {} Vector . __índice = Vectorfunción Vector : nuevo ( 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 ) finfunction Vector : magnitud () - Otro método - Hacer referencia al objeto implícito usando self return math.sqrt ( self . x ^ 2 + self . y ^ 2 + self . z ^ 2 ) end vec local = Vector : nuevo ( 0 , 1 , 0 ) - Crear un vector print ( vec : magnitud ()) - Llamar a un método (salida: 1) print ( vec . x ) - Acceder a una variable miembro (salida : 0)Lua admite el uso de metatablas para otorgar herencia de clases a Lua. [14] En este ejemplo, permitimos que los vectores tengan sus valores multiplicados por una constante en una clase derivada.
Vector local = {} Vector . __índice = VectorFunción Vector : nuevo ( x , y , z ) - El constructor . Aquí, self se refiere al método "nuevo" de cualquier clase que llamemos. En una clase derivada, yo será la clase derivada; en la clase Vector, self -- será Vector return setmetatable ({ x = x , y = y , z = z }, self ) endfunction Vector : magnitud () - Otro método - Hacer referencia al objeto implícito usando self return math.sqrt ( self . x ^ 2 + self . y ^ 2 + self . z ^ 2 ) end- Ejemplo de herencia de clases local VectorMult = {} VectorMult . __index = VectorMult setmetatable ( VectorMult , Vector ) - Hacer que VectorMult sea hijo de Vectorfunción VectorMult : multiplicar ( valor ) uno mismo . x = yo . x * valorarse a uno mismo . y = yo . y * valorarse a uno mismo . z = yo . z * valor retorno auto finallocal vec = VectorMult : new ( 0 , 1 , 0 ) - Crear un vector print ( vec : magnitud ()) - Llamar a un método (salida: 1) print ( vec . y ) - Acceder a una variable miembro (salida : 1) vec : multiplicar ( 2 ) -- Multiplica todos los componentes del vector por 2 print ( vec . y ) -- Acceder al miembro nuevamente (salida: 2)Lua también admite herencia múltiple ; __indexPuede ser una función o una tabla. [15] También se puede sobrecargar al operador ; Las metatablas de Lua pueden tener elementos como __add, __subetc. [dieciséis]
Los programas Lua no se interpretan directamente a partir del archivo textual Lua, sino que se compilan en un código de bytes, que luego se ejecuta en la máquina virtual Lua . El proceso de compilación suele ser invisible para el usuario y se realiza durante el tiempo de ejecución , especialmente cuando se utiliza un compilador JIT , pero se puede realizar sin conexión para aumentar el rendimiento de carga o reducir la huella de memoria del entorno host omitiendo el compilador. El código de bytes de Lua también se puede producir y ejecutar desde Lua, utilizando la dumpfunción de la biblioteca de cadenas y las load/loadstring/loadfilefunciones. La versión 5.3.4 de Lua está implementada en aproximadamente 24.000 líneas de código C. [3] [4]
Como la mayoría de las CPU, y a diferencia de la mayoría de las máquinas virtuales (que están basadas en pilas ), Lua VM está basada en registros y, por lo tanto, se parece más a un diseño de hardware real. La arquitectura de registro 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 tiene un uso amplio. [17] Parrot y Dalvik de Android son otras dos máquinas virtuales basadas en registros muy conocidas. La máquina virtual de PCScheme también estaba basada en registros. [18]
Este ejemplo es el listado de código de bytes de la función factorial definida anteriormente (como se muestra en el luaccompilador 5.1): [19]
función <factorial.lua:1,7> (9 instrucciones, 36 bytes en 0x8063c60)1 parámetro, 6 ranuras, 0 valores ascendentes, 6 locales, 2 constantes, 0 funciones1 [2] CARGAR 1 -1 ; 12 [3] CARGAR 2 -2 ; 23 [3] MOVER 3 04 [3] CARGAR 4 -1 ; 15 [3] PARA PREPARAR 2 1 ; a 76 [4] MUL 1 1 57 [3] BUCLE FOR 2 -2 ; a 68 [6] VOLVER 1 29 [7] VOLVER 0 1
Lua está pensado para integrarse en otras aplicaciones y proporciona una API C para este propósito. La API se divide en dos partes: el núcleo de Lua y la biblioteca auxiliar de Lua. [20] El diseño de la API de Lua elimina la necesidad de gestión manual de referencias en código C, a diferencia de la API de Python . La API, al igual que el lenguaje, es minimalista. La biblioteca auxiliar proporciona funcionalidad avanzada, que consta principalmente de macros de preprocesador que ayudan con operaciones complejas de tablas.
La API de Lua C está basada en pilas . Lua proporciona funciones para enviar y extraer los tipos de datos C más simples (enteros, flotantes, etc.) hacia y desde la pila, así como funciones para manipular tablas a través de la pila. La pila Lua es algo diferente de una pila tradicional; la pila se puede indexar directamente, por ejemplo. Los índices negativos indican desplazamientos desde la parte superior de la pila. Por ejemplo, −1 es el valor superior (valor empujado más recientemente), mientras que los índices positivos indican desplazamientos desde la parte inferior (valor más antiguo). La clasificación de datos entre funciones C y Lua también se realiza utilizando la pila. Para llamar a una función Lua, los argumentos se colocan en la pila y luego lua_callse usan para llamar a la función real. Al escribir una función C para llamarla 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 (); // carga y ejecuta una cadena if ( luaL_dostring ( L , "función foo (x,y) return x+y end" )) { lua_close ( L ); devolver -1 ; } // empuja el valor de "foo" global (la función definida anteriormente) // a la pila, seguido de los números 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 parte superior de la pila lua_pop ( L , 1 ); // devolver la pila al estado original lua_close ( L ); // cerrar el estado de Lua return 0 ; } Al ejecutar este ejemplo se obtiene:
$ cc -o ejemplo ejemplo.c -llua $ ./ejemplo Resultado: 8La API de C también proporciona algunas tablas especiales, ubicadas en varios "pseudoíndices" en la pila de Lua. Antes LUA_GLOBALSINDEXde Lua 5.2 [21] estaba la tabla global, _Gdentro de Lua, que era el espacio de nombres principal . También hay un registro ubicado en LUA_REGISTRYINDEXdonde los programas C pueden almacenar valores de Lua para su posterior recuperación.
Además de los módulos de biblioteca estándar (núcleo), es posible escribir extensiones utilizando la API de Lua. Los módulos de extensión son objetos compartidos que se pueden utilizar para ampliar la funcionalidad del intérprete proporcionando funciones nativas a los scripts Lua. Los scripts de Lua pueden cargar módulos de extensión usando require, [20] al igual que los módulos escritos en el propio Lua, o con package.loadlib. [22] Cuando se carga una biblioteca C a través de Lua, buscará la función y la llamará, lo que actúa como cualquier función C invocable desde Lua y generalmente devuelve una tabla llena de métodos. Una colección cada vez mayor de módulos conocidos como rocas está disponible a través de un sistema de gestión de paquetes llamado LuaRocks , [23] en el espíritu de CPAN , RubyGems y Python egg . Existen enlaces Lua preescritos para los lenguajes de programación más populares, incluidos otros lenguajes de secuencias de comandos. [24] Para C++, existen varios enfoques basados en plantillas y algunos generadores de enlaces automáticos.require('foo')luaopen_foo
En el desarrollo de videojuegos , los programadores utilizan ampliamente Lua como lenguaje de secuencias de comandos , principalmente debido a su percibida facilidad de integración, ejecución rápida y curva de aprendizaje corta . [25] Los juegos notables que usan Lua incluyen Roblox , [26] Garry's Mod , World of Warcraft , Payday 2 , Phantasy Star Online 2 , Dota 2 , Crysis , [27] y muchos otros. Algunos juegos que no son compatibles de forma nativa con la programación o secuencias de comandos Lua tienen esta funcionalidad agregada mediante mods, como lo hace ComputerCraft para Minecraft . Además, Lua también se utiliza en software que no es de videojuegos, como Adobe Lightroom , Moho , iClone , Aerospike y cierto software de sistema en FreeBSD y NetBSD , y se utiliza como lenguaje de scripting de plantilla en MediaWiki usando la extensión Scribunto. [28]
En 2003, una encuesta realizada por GameDev.net mostró que Lua era el lenguaje de programación más popular para la programación de juegos. [29] El 12 de enero de 2012, Lua fue anunciado como ganador del premio Front Line 2011 de la revista Game Developer en la categoría Herramientas de programación. [30]
Una gran cantidad de aplicaciones que no son juegos también utilizan Lua para la extensibilidad, como LuaTeX , una implementación del lenguaje de composición tipográfica TeX, Redis , una base de datos clave-valor , ScyllaDB , un almacén de columnas anchas , Neovim , un editor de texto, Nginx , un servidor web , y Wireshark , un analizador de paquetes de red.
A través de la extensión Scribunto, Lua está disponible como lenguaje de programación del lado del servidor en el software MediaWiki que impulsa Wikipedia y otros wikis. [31] Entre sus usos se encuentran permitir la integración de datos de Wikidata en artículos, [32] y alimentar el sistema automatizado taxobox .
doend{}Además, la comunidad de usuarios de Lua proporciona algunos parches potentes además de la implementación de C de referencia. [44]
{{cite web}}: CS1 maint: bot: original URL status unknown (link)
Noticias de Wikinoticias
Libros de texto de Wikilibros
Recursos de Wikiversidad.svg/1280px-Free_and_open-source_software_logo_(2009).svg.png){kind=logo}
