Lúa

Lúa
clase de idioma lenguaje de programación funcional , lenguaje de programación orientado a objetos , lenguaje de secuencias de comandos , lenguaje de programación multiparadigma , lenguaje de programación imperativo , lenguaje de programación procedimental , lenguaje deprogramación orientado a prototipos [d] , lenguaje de programación interpretado , lenguaje de programación compilado , software libre y formato de archivo
Apareció en 1993 [2]
Autor Roberto Jeruzalimski ,
Valdemar Selish,
Luis Enrique de Figueiredo
Desarrollador Roberto Jeruzalimsky [1]
extensión de archivo .lua[3] [4 ],.lunao.lunaire.anair
Liberar 5.4.4 (26 de enero de 2022)
sistema de tipos dinámico , fuerte , pato
sido influenciado C++ , Clu , Lenguaje de objetos simples [d] , DEL , Snobol , Modula , Modula-2 y Scheme
influenciado JavaScript
Licencia licencia MIT [5] [6]
Sitio web lua.org (  inglés) (  puerto)
sistema operativo multiplataforma [7]
 Archivos multimedia en Wikimedia Commons

Lua ( lua ,  port.  -  “luna” [8] ) es un lenguaje de programación de scripting desarrollado en la división Tecgraf ( Computer Graphics Technology Group ) de la Universidad Católica de Río de Janeiro ( Brasil ). El intérprete de lenguaje es un intérprete de lenguaje C gratuito y de código abierto .

En términos de ideología e implementación, el lenguaje Lua es el más cercano a JavaScript , en particular, también implementa el modelo de prototipo OOP , pero difiere en una sintaxis similar a la de Pascal y construcciones más poderosas y flexibles. Un rasgo característico de Lua es la implementación de una gran cantidad de entidades de software con un mínimo de medios sintácticos. Por lo tanto, todos los tipos de datos compuestos definidos por el usuario ( matrices , estructuras , conjuntos , colas , listas ) se implementan a través del mecanismo de tablas y los mecanismos de programación orientada a objetos , incluida la herencia múltiple  , utilizando metatablas , que también son responsables de sobrecargar las operaciones y un número de otras características.

Lua está destinado a usuarios que no son programadores profesionales, por lo que se presta mucha atención a la simplicidad del diseño y la facilidad de aprendizaje. El lenguaje es muy utilizado para crear software replicable (por ejemplo, en él está escrita la interfaz gráfica del paquete Adobe Lightroom ). También ganó prominencia como lenguaje de programación para niveles y extensiones en muchos juegos (incluido Garry's Mod ) [9] .

Historia

El lenguaje fue desarrollado por la división Tecgraf (grupo de tecnología de gráficos por computadora) de la Universidad Católica de Río de Janeiro en Brasil, la historia del lenguaje se remonta a 1993. Los autores de la lengua son Roberto Jeruzalimski , Luiz Henrique de Figueiredo y Waldemar Celes . Lua se distribuye libremente, de código abierto en lenguaje C.

Como señaló Luis Enrique de Figueiredo, Lua es el único lenguaje de programación desarrollado en un país en desarrollo que ha recibido reconocimiento mundial, lo que, en particular, se expresó en una invitación a la conferencia HOPL [10] .

Los padres históricos del lenguaje fueron los lenguajes de configuración y descripción de datos SOL (Simple Object Language) y DEL (Data-Entry Language) [11] , se desarrollaron de forma independiente en Tecgraf en 1992-1993 para agregar cierta flexibilidad a dos lenguajes separados. proyectos (ambos eran aplicaciones gráficas interactivas para necesidades de diseño en Petrobras ). SOL y DEL carecían de construcciones de control, y Petrobras sintió una creciente necesidad de agregarles una programación completa.

Como escribe el autor del lenguaje en The Evolution of Lua : [12]

En 1993, el único competidor real fue Tcl , que fue diseñado específicamente para integrarse en las aplicaciones. Sin embargo, Tcl tenía una sintaxis desconocida, carecía de un buen soporte de descripción de datos y solo se ejecutaba en plataformas Unix . No hemos considerado Lisp o Scheme debido a su sintaxis poco amigable. Python todavía estaba en su infancia. En la atmósfera de bricolaje que reinaba en Tecgraf en ese momento, era natural que decidiéramos desarrollar nuestro propio lenguaje de programación. Debido al hecho de que la mayoría de los usuarios no eran programadores profesionales, el lenguaje tenía que evitar la sintaxis y la semántica enrevesadas. La implementación del nuevo lenguaje tenía que ser fácilmente portable , ya que los clientes de Tecgraf disponían de plataformas muy diversas. Finalmente, dado que esperábamos que otros productos de Tecgraf también necesitaran un lenguaje de secuencias de comandos integrado, el nuevo lenguaje debería seguir el ejemplo de SOL y proporcionarse como una biblioteca con una API de C.

Lua 1.0 fue diseñado de tal manera que los constructores de objetos, ligeramente diferentes al estilo ligero y flexible actual, incluyeron la sintaxis del lenguaje SOL (de ahí el nombre Lua: en portugués sol  - "sol", lua  - "luna") . Las construcciones de control de Lua se toman en su mayoría de Modula-2 (if, while, repeat/until), aunque también están influenciadas por Clu ( asignación paralela , valor de retorno de función múltiple como una alternativa más simple a pasar parámetros por referencia o punteros explícitos ), C++ ("Es una gran idea declarar solo las variables locales cuando las necesite"), Snobol y awk ( matrices asociativas ). Los creadores de Lua también reconocen que el único mecanismo de estructuración de datos ubicuos en Lisp y Scheme ( lista enlazada ) fue una gran influencia en su decisión de elegir tablas como la estructura de datos principal para Lua [13] .

Las versiones de Lua hasta la 5.0 se lanzaron bajo una licencia similar a la licencia BSD . A partir de la versión 5.0, Lua se distribuye bajo la licencia MIT . Ambas licencias son permisivas y virtualmente idénticas.

Características generales

Lua está destinado a ser utilizado como un lenguaje de secuencias de comandos independiente o integrado en una aplicación. Originalmente fue diseñado para ser lo suficientemente simple y compacto para adaptarse a una variedad de plataformas y proporcionar un rendimiento aceptable. Asimismo, el diseño tuvo en cuenta los requisitos de facilidad de aprendizaje y la posibilidad de uso por parte de programadores no profesionales.

Lua es un lenguaje modular procedimental tipado dinámicamente con administración automática de memoria . Incluye elementos básicos para admitir estilos de programación funcional y de objetos . Por lo tanto, Lua puede llamarse un lenguaje multiparadigma . Las herramientas de programación paralela integradas le permiten escribir programas de subprocesos múltiples utilizando solo herramientas de lenguaje, sin consultar la API del sistema operativo o bibliotecas externas. Dado que el propósito principal de Lua es la integración, tiene una interoperabilidad entre lenguajes eficiente, enfocada principalmente en llamar a bibliotecas C y trabajar en un entorno C.

El lenguaje admite una pequeña cantidad de tipos de datos integrados: booleanos, números, cadenas, funciones, flujos. No hay estructuras de datos combinadas típicas como arreglos , conjuntos , listas y registros , en lugar de todos ellos, se usa una estructura básica de Lua, la tabla (ver más abajo). Un tipo separado userdataestá diseñado específicamente para programación de bajo nivel e intercambio de datos con código externo en otros idiomas. Las funciones en Lua son objetos de primera clase y se pueden asignar y pasar como parámetros. Se admiten cierres, es posible crear funciones de órdenes superiores. El sistema de objetos es prototípico, no hay soporte explícito para la herencia , pero se implementa fácilmente usando metatablas .

En general, Lua tiene como objetivo proporcionar metafunciones flexibles que se pueden ampliar según sea necesario, en lugar de proporcionar un conjunto de funciones específicas para un paradigma de programación en particular. Como resultado, el lenguaje subyacente es simple y fácilmente adaptable a la mayoría de las aplicaciones. Al proporcionar un conjunto mínimo de instalaciones básicas, Lua intenta lograr un equilibrio entre potencia y tamaño.

Sintaxis

La sintaxis de Lua se basa principalmente en lenguajes similares a Pascal tardío, como Modula-2 u Oberon . El formato de entrada de texto es libre, los comandos en el texto del programa están separados por caracteres de espacio en blanco. Se permite, pero no se requiere, usar un punto y coma para separar operaciones.

En una entrevista con Robert Jeruzalimski, comentó que la sintaxis de Lua era un compromiso que tenía que hacer para facilitar el aprendizaje del lenguaje a los programadores no profesionales. Describió la sintaxis como "bastante prolija", señalando que personalmente hubiera preferido una notación más concisa [10] .

Vocabulario

El alfabeto principal del idioma es el inglés, se pueden usar caracteres de otros idiomas en cadenas literales. Los identificadores pueden consistir en letras, números y guiones bajos, pero no pueden comenzar con un número ni coincidir con una de las palabras clave. La guía de idiomas no recomienda el uso de identificadores que comiencen con un guión bajo, ya que dichos identificadores se utilizan para fines del sistema.

El lenguaje distingue entre mayúsculas y minúsculas, todas las palabras clave están escritas en minúsculas, los identificadores que difieren solo en mayúsculas y minúsculas se consideran diferentes. Las siguientes 22 palabras clave no se pueden usar para nombres [14] :

and break do else elseif end false goto for function if in local nil not or repeat return then true before while

Comentarios

Los comentarios usan la siguiente sintaxis, similar a Ada , SQL y VHDL :

-- Un comentario simple de una sola línea en Lua comienza con un doble menos y continúa hasta el final de la línea. dim = { "uno" , "dos" , "tres" } -- Un comentario de línea no tiene que comenzar al principio de una línea -- puede seguir otras construcciones del lenguaje -- para explicarlo. --[[Un comentario de varias líneas comienza con dos corchetes de apertura consecutivos seguidos de dos menos y continúa a través de dos corchetes de cierre consecutivos. Como aquí: ]] -- Se puede obtener un efecto interesante combinando comentarios en línea y de varias líneas: --[[ Para descomentar el código a continuación, es suficiente agregar un espacio en esta línea entre signos menos y corchetes. for i=1,#dim do print(dim[i]) end -- Si se agrega un espacio entre los signos menos y los corchetes anteriores, entonces --]] -- aquí el final del comentario de varias líneas se convertirá en una linea normal

Tipos de datos

Lua es un lenguaje con definición implícita de tipos de datos dinámicos . Una variable de idioma puede contener valores de cualquier tipo. Todos los valores en Lua pueden almacenarse en variables, usarse como argumentos para llamadas a funciones y devolverse como resultado de su ejecución.

Hay ocho tipos principales en Lua:

  • cero (indefinido)
  • booleano (booleano)
  • número (numérico)
  • cadena _
  • función (función)
  • datos de usuario (datos de usuario)
  • hilo (hilo)
  • mesa (mesa)

nil  es el tipo de valor nil [valor vacío], cuya propiedad principal es ser diferente de todos los demás valores y denotar la ausencia de un valor utilizable.

El tipo booleano incluye los valores falso (falso) y verdadero (verdadero).

El tipo de número generalmente incluye números reales (doble). En las primeras versiones de Lua, los números enteros no estaban separados en un tipo separado; esta decisión está motivada por el hecho de que la representación real le permite representar con precisión una gama bastante amplia de números enteros. A partir de la versión 5.3, se ha añadido la posibilidad de definir explícitamente un formato de número entero o número real. La representación interna de los números se puede cambiar al construir el intérprete.

El tipo de cadena denota matrices de caracteres. Las cadenas Lua pueden contener cualquier carácter de 8 bits, incluido el cero ('\0'). Las cadenas son inmutables. Los literales de cadena se pueden escribir entre comillas simples o dobles, los caracteres de servicio se colocan en ellos en notación C estándar con una barra invertida al principio. Los literales de varias líneas están delimitados por dos corchetes consecutivos de apertura y dos de cierre consecutivos.

No hay compatibilidad con Unicode integrada en el lenguaje, aunque se permite el uso de caracteres UTF-8 en cadenas literales, y el propio sistema de representación UTF-8 le permite ingresar, generar y procesar parcialmente cadenas en esta codificación utilizando herramientas estándar del sistema. . Las versiones recientes de Lua incluyen la biblioteca utf8, que brinda soporte más avanzado para UTF-8, y existen bibliotecas de terceros que brindan herramientas para trabajar con cadenas Unicode en varias codificaciones.

Las funciones en Lua son objetos completos que se pueden asignar, pasar como parámetro a una función y devolver como uno de los valores. El tipo de subproceso tiene corrutinas, el tipo de datos de usuario está diseñado para representar datos externos recibidos o proporcionados desde/hacia código en otro lenguaje (principalmente C/C++).

Operaciones

Asignación El operador de asignación es el símbolo =. Al igual que los lenguajes de scripting como Perl , Python , Ruby e Icon , permite la asignación concurrente . En el caso más simple, esto le permite escribir expresiones como: x , y = y , x A diferencia de Go , por ejemplo, la asignación paralela en Lua es muy liberal, no requiere que la cantidad de variables coincida exactamente con la cantidad de valores. Si hay más valores que variables, entonces se descartan los últimos valores; si hay menos valores, las últimas variables de la lista obtienen el valor nulo. Comparaciones y operadores lógicos Operadores de comparación: <, >, <=, >=, ==, ~= (los dos últimos significan comparación para igualdad y para desigualdad, respectivamente). Las comparaciones de igualdad y desigualdad son aplicables a cualquier tipo de datos, otros, solo a cadenas y números. Operadores lógicos: and, or, not - "y", "o" y "no" lógicos, respectivamente, se pueden aplicar a valores de cualquier tipo y devolver verdadero o falso. En los parámetros de estas operaciones, los valores nil y false se consideran falsos, cualquier otro valor es verdadero. A diferencia de C y otros lenguajes, incluso un cero numérico (0) o una cadena vacía ("") representa un valor "verdadero" en términos de operadores lógicos. La evaluación de los operadores lógicos binarios se realiza tradicionalmente hasta que se determina el resultado, devolviendo como resultado la última subexpresión evaluada. Por lo tanto, pueden usarse como un operador ternario ?:en C: -- similar a r = (a < b)? f(a) : f(b); en C, r = ( a < b ) y f ( a ) o f ( b ) -- r obtendrá el valor de la función f() del menor de los dos valores a y b, -- siempre que f(a) no es nulo o falso. Operadores aritméticos + - suma; - - resta; * - multiplicación; / - división; - - menos unario ; % - resto de la división; ^ - exponenciación.

Todos los operadores aritméticos admiten operandos reales, dando resultados predecibles. Por ejemplo, x^0.5devuelve la raíz cuadrada de x, x^(-1/3) el recíproco de la raíz cúbica de x. El operador %está definido por: a % b = a - math.floor(a / b) * b, donde la función se math.floor()evalúa como la parte entera de su argumento. Para argumentos enteros, su resultado es bastante normal. Para un dividendo real, tenga en cuenta que la operación no realiza ningún redondeo o descarte adicional de la parte fraccionaria, por lo que el resultado conservará la parte fraccionaria del dividendo. Por ejemplo, math.pi % 2devolverá no 1, pero 1.1415926535898. Esta implementación proporciona algunas características adicionales. Por ejemplo, para truncar xa tres decimales, basta tomar la expresiónx - x % 0.001

Tablas

Una tabla en Lua es una matriz asociativa heterogénea dinámica , es decir, un conjunto de pares de " ". Las claves pueden ser valores de cualquier tipo Lua excepto . Las claves también pueden ser literales Lua (identificadores). Escribir en un elemento de tabla es equivalente a eliminar este elemento. ключ-значениеnilnil

Las tablas son el único tipo de datos compuestos en Lua. Son la base para todos los tipos de datos definidos por el usuario, como estructuras , matrices , conjuntos y otros:

-- Tabla general: vacía = {} -- Tabla vacía vacía [ 1 ] = "primero" -- Sumando elemento con índice entero vacío [ 3 ] = "segundo" -- Sumando elemento con índice entero vacío [ "tercero" ] = "tercero" -- Agregar elemento en el índice de cadena vacío [ 1 ] = nil -- Eliminar elemento de la tabla -- Matriz clásica: las cadenas se indexan de forma predeterminada con números enteros a partir de 1 días1 = { "Lunes" , "Martes" , "Miércoles" , "Jueves" , "Viernes" , "Sábado" , "Domingo" } -- Matriz con indexación arbitraria días2 = {[ 0 ] = "Domingo" , [ 1 ] = "Lunes" , [ 2 ] = "Martes" , [ 3 ] = "Miércoles" , [ 4 ] = "Jueves" , [ 5 ] = "Viernes" , [ 6 ] = "Sábado" } -- Registro (estructura) - los valores de varios tipos están indexados por literales person = { tabnum = 123342 , -- Número de personal fio = "Ivanov Stepan Vasilyevich" , -- Nombre completo post = "fabricante de herramientas" , -- Salario del puesto = 25800,45 , -- Salario sdate = "23/10/2013" , -- Fecha de contratación bdate = "08/08/1973" } -- Fecha de nacimiento pfio = persona . fio --Referencia al elemento de estructura. -- Los índices de conjuntos se utilizan para almacenar valores días laborables = {[ "Lunes" ] = verdadero , [ "Martes" ] = verdadero , [ "Miércoles" ] = verdadero , [ "Jueves" ] = verdadero , [ "Viernes" " ] = true } workDays [ "Saturday" ] = true -- Agregue el sábado a la cantidad de días hábiles workDays [ "Wednesday" ] = nil -- Ya no trabajamos los miércoles -- Compruebe si d es un día laborable if workDays [ d ] luego imprima ( d .. " - día laborable " ) else imprima ( d .. " - día libre " ) end

Los conjuntos múltiples (conjuntos que pueden contener más de una instancia del mismo elemento) se implementan de manera similar al último ejemplo, solo que los valores no son lógicos, sino enteros: contadores de la cantidad de elementos correspondientes en el conjunto. Las listas enlazadas se pueden representar como matrices de matrices de dos elementos que contienen un valor y una referencia al siguiente elemento. Los arreglos multidimensionales se pueden implementar como arreglos de arreglos. Las estructuras más complejas, como colas, gráficos, redes también se implementan sobre la base de tablas, el método de implementación específico está determinado por la tarea.

Cierres

Lua apoya el concepto de cierres , por ejemplo:

función makeaddfunc ( x ) -- Devuelve una nueva función anónima que agrega x a su argumento función de retorno ( y ) -- Cuando nos referimos a una variable x que está fuera del alcance actual -- y cuyo tiempo de vida es menor que el de esta función anónima - - - Lua crea un cierre. return x + y end end plustwo = makeaddfunc ( 2 ) -- es decir, plustwo = function(y) return 2 + y end print ( plustwo ( 5 )) -- Imprime 7

Cada vez que se llama makeaddfunc, se crea un nuevo cierre para la variable x, por lo que cada función anónima devuelta se referirá a su propio parámetro x. Como cualquier otro objeto Lua, el recolector de basura administra la vida útil de un cierre.

Medios y métodos de programación

Metatablas

El mecanismo metatable proporciona muchas de las características que ofrecen otros lenguajes al introducir mecanismos sintácticos separados. Las metatablas son, por estructura, tablas ordinarias de Lua, sujetas a todas las reglas y restricciones del lenguaje. Su peculiaridad radica en su aplicación. La metatabla almacena metadatos adicionales para tipos y objetos, es decir, información sobre los parámetros y funciones asociados con ellos. La información almacenada en metatablas es utilizada por el intérprete de Lua, su uso le permite cambiar o ampliar la funcionalidad de los objetos del programa.

Una metatabla en Lua se puede asociar con un valor de cualquier tipo. Los tipos de datos escalares (todos excepto los datos de usuario y las tablas) tienen metatablas comunes para cada tipo. Las tablas y valores de un tipo userdatatienen referencias de metatablas individuales en cada instancia. La modificación de metatablas de todos los tipos, excepto las tablas, solo se puede realizar a través de un código C externo. Solo las metatablas de las tablas son accesibles directamente desde Lua.

Una tabla Lua creada desde cero no tiene una metatabla (su referencia de metatabla es nula). Pero se puede crear una metatabla en cualquier momento u obtenerse de otra tabla. La función integrada getmetatable(t)devuelve la metatabla de la tabla t y la función setmetatable(t, m)establece la tabla t en la metatabla m.

Para las metatablas, se documenta un conjunto de campos que puede utilizar el intérprete de lenguaje. Para indicar el papel especial de estos campos, se ha adoptado una regla de denominación especial para ellos: sus identificadores comienzan con dos guiones bajos. Algunos de estos campos contienen información sobre propiedades específicas del objeto al que se refiere la metatabla. Por ejemplo, la opción __mode, cuando se da, puede hacer que una tabla sea débil , es decir, una tabla cuyas referencias a objetos sean todas referencias débiles . Pero los valores de la mayoría de los posibles campos de la metatabla son los llamados metamétodos , es decir, referencias a funciones que el intérprete llama bajo ciertas condiciones. La lógica general del uso de metamétodos por parte del intérprete es la siguiente: cuando el intérprete encuentra una operación en el programa que no está definida para el objeto operando, accede a la metatabla asociada con el operando, encuentra el metamétodo correspondiente y lo llama.

--[[ Crear operación de suma para tablas ]] -- Operandos t1 = { 1 , 2 , 3 } t2 = { 10 , 20 , 30 } -- Crear metatabla mt = {} -- Escribir metamétodo "__add" mt en metatabla . __add = function ( a , b ) local res = {} for k en pares ( a ) do res [ k ] = a [ k ] + b [ k ] end return res end -- Vincular metatable a la tabla t1 setmetatable ( t1 , mt ) -- La adición de tablas ahora es una operación válida t3 = t1 + t2 -- unir metatabla con t3 con metamétodo __tostring setmetatable ( t3 , { __tostring = función ( t ) local res = " \n " para _ , v en pares ( t ) do res = res .. tostring ( v ) .. "-" end return res .. " \n " end }) -- Esto imprimirá: "11-22-33-" para _ , v en ipairs ( t3 ) do io.write ( v , "," ) end print ( tostring ( t3 )) -- imprime "11,22,33,"

Lua admite metamétodos para todas las operaciones aritméticas y de comparación, por lo que se pueden usar para implementar la aritmética para cualquier objeto creado por el programador. Además de los estándar, puede usar los llamados metamétodos de "biblioteca", que no son compatibles con el núcleo del lenguaje, sino con bibliotecas específicas. En el ejemplo anterior, este es un metamétodo __tostringcompatible con la biblioteca de cadenas; este método convierte la tabla en una cadena.

El campo es del mayor interés __index. Se llama cuando el intérprete intenta leer un elemento de la tabla pero no lo encuentra. Un campo __indexpuede hacer referencia a una tabla oa un método. En el primer caso, el intérprete, al no encontrar el valor deseado en la tabla principal, lo buscará en la tabla __index. En el segundo, en lugar de acceder a la tabla, se llamará a este método. Al especificar tablas o metamétodos para un campo determinado, Lua puede implementar la herencia, ocultar datos de objetos, rastrear operaciones en datos de tablas y mucho más.

Programación orientada a objetos

La base para OOP en Lua son las tablas. En principio, una tabla es un objeto en el sentido de programación orientada a objetos, ya que puede tener campos nombrados con identificadores y almacenar valores arbitrarios (propiedades del objeto) y funciones para implementar el comportamiento del objeto (métodos del objeto) en estos campos. Parte del azúcar sintáctico proporcionado por Lua hace que la descripción y el manejo de objetos sean más familiares para los programadores con experiencia en lenguajes OOP tradicionales. No existe el concepto de " clase " en Lua, por lo tanto, se describe un objeto separado y todos los campos y métodos se refieren específicamente a él. Las propiedades se describen de manera similar a los elementos de la tabla con claves de identificación, los métodos se describen como campos de función. Al igual que el clásico Oberon, la descripción de los métodos incluye una indicación explícita en el primer parámetro del llamado "receptor", un parámetro que, cuando se llama a un método, se refiere al objeto para el que se llama. Pero además de la referencia estándar a un campo de tabla, a través de un punto, que requiere especificar explícitamente el destinatario en la llamada al método, Lua admite una sintaxis adicional: cuando el encabezado del método se escribe en forma " Объект:метод" en la llamada o descripción del método , entonces no se especifica el destinatario. Al mismo tiempo, en el cuerpo del método, todavía está disponible con el nombre self:

-- Objeto Cuenta = { -- Objeto "cuenta" id , nombre , saldo = 0 , -- propiedades del objeto: número, nombre, saldo crédito = función ( self , v ) -- método "gasto" - descripción dentro del objeto con explícito especificando el destinatario si self . balance < v luego error "Saldo insuficiente" end self . equilibrio = uno mismo . saldo - v fin } función Cuenta : debet ( v ) -- método "entrante" - descripción abreviada externa (no se especifica uno mismo) self . equilibrio = uno mismo . saldo + v fin cuenta _ debet ( Cuenta , 10000 ) -- llamada al método - versión larga Cuenta : credit ( 5000 ) -- llamada al método - versión corta

La herencia, incluida la herencia múltiple, se implementa mediante metatablas y metamétodos. Además, utilizando metamétodos, puede implementar la ocultación de datos y el acceso controlado a los campos de la tabla-objeto. Si compara este enfoque con otros lenguajes, donde todo lo anterior se implementa utilizando herramientas de lenguaje especiales, puede ver que la implementación de Lua es más complicada y requiere una codificación más cuidadosa, pero brinda más flexibilidad y simplifica el intérprete.

Ejemplos de código

Programa clásico " ¡Hola, mundo!" » en Lua se ve así:

imprimir ( "¡Hola mundo!" )

Factorial  es un ejemplo de una función recursiva :

función factorial ( n ) si n == 0 entonces devuelve 1 si no devuelve n * factorial ( n - 1 ) fin fin

Bucle con contador :

for i = 1 , 5 do -- fin de instrucciones/operaciones

Trabajar con funciones como objetos de primera clase se demuestra en el siguiente ejemplo, que modifica el comportamiento de la función de impresión:

do local oldprint = print -- Guarda la función de impresión actual como oldprint function print ( s ) -- Redefine la función de impresión if s == "foo" then oldprint ( "bar" ) else oldprint ( s ) end end end

Cualquier llamada futura printahora se redirigirá a la nueva función y, gracias al soporte de Lua para el contexto léxico , solo se podrá acceder a la función de impresión anterior a través de la nueva función de impresión modificada. Lua también admite cierres , como se describe anteriormente en la sección relacionada.

Una característica clave de Lua es su semántica extensible, y el mecanismo metatable ofrece muchas posibilidades para personalizar el comportamiento único de las tablas Lua. El siguiente ejemplo muestra una tabla "infinita". Para any dará el -ésimo número de Fibonacci usando memoization . fibs[n]

fibs = { 1 , 1 } -- Valores iniciales para fibs[1] y fibs[2]. setmetatable ( fibs , { __index = function ( nombre , n ) -- Llamar a la función si fibs[n] no existe. name [ n ] = nombre [ n - 1 ] + name [ n - 2 ] -- Calcular y memorizar fibs [n] .return nombre [ n ] fin })

Lua también le permite usar operadores lógicos andpara oringresar construcciones ternarias , como en C# , por ejemplo, o para referirse a uno de los objetos existentes.

do local num = tonumber ( io.read ()) -- Escribe en una variable la información ingresada desde la consola y conviértela a un tipo entero print ( num == 1 y "Ingresaste el número correcto" o "Ingresaste el número incorrecto" ) -- Si la variable num es igual a 1, entonces el texto después de y se mostrará en la consola, en todos los demás casos después de o end

Acceder a una tabla existente y obtener el valor en el primer índice:

do local tbl = nil local tbl2 = { 1 } print ( ( tbl o tbl2 )[ 1 ] ) -- Se imprimirá el número 1 porque la tabla tbl2 tiene este valor al final del índice 1

Llamar a una función desde una de las tablas existentes:

hacer local tbl = nil local tbl2 = {} tbl2 . HacerAlgo = function () print ( "Hacer algo" ) end ( tbl o tbl2 ). hacer algo () fin

Implementación

Como muchos lenguajes de programación interpretados , la implementación de Lua tiene un compilador separado del lenguaje fuente al código de bytes ejecutable y una máquina virtual para ejecutar el código de bytes generado. Además, el código de bytes no son los comandos de la máquina de pila, sino los comandos de un determinado procesador virtual con varios registros, lo que aumenta la eficiencia de ejecución. La máquina virtual Lua estándar utiliza asignación de memoria con recolección de elementos no utilizados (similar a Java o .NET).

Lua usa un grupo de una sola cadena , lo que reduce la sobrecarga de memoria del almacenamiento de cadenas.

Para tareas de tiempo crítico, hay un compilador JIT - Lua  - LuaJIT [15] . También se ha desarrollado el compilador llvm-lua [16] , que genera código para la máquina virtual LLVM , lo que brinda la posibilidad de compilación posterior en código máquina muy eficiente para procesadores de diversas arquitecturas.

Uso

Actualmente se usa en varios proyectos en los que se requiere construir un lenguaje de programación de secuencias de comandos bastante rápido y fácil de aprender ; por ejemplo, en el desarrollo de juegos , donde Lua se usa a menudo como una capa entre el motor del juego y los datos para la secuencia de comandos. el comportamiento y la interacción de los objetos. Por su compacidad, también es aplicable en dispositivos portátiles, en particular, una de las calculadoras gráficas de Texas Instruments utiliza un lenguaje en lugar del BASIC , tradicional para esta clase de dispositivos .

Juegos

LucasArts fue el primero en introducir el lenguaje Lua en el desarrollo de juegos de computadora, comenzando con el juego Grim Fandango [17] . Los autores del lenguaje en su informe en la conferencia HOPLRecordemos que en enero de 1997 recibieron un mensaje de Bret Mogilefsky, el principal desarrollador de Grim Fandango, donde escribía que después de leer sobre el lenguaje en un artículo de 1996 en Dr. Dobb's Journal , planea reemplazar su lenguaje de scripting casero SCUMM con Lua [18] . Como resultado, creó el motor de juego GrimE , que también se usa en una misión posterior de LucasArts: Escape from Monkey Island .

En 2003, una encuesta de GameDev.net clasificó a Lua como el lenguaje de secuencias de comandos más popular para el desarrollo de juegos [9] .

Un ejemplo de un juego programado con Lua es World of Warcraft [19] [20] . Los niveles del juego de rompecabezas Enigma [21] se describen en el idioma lua .

Hay varios motores de juegos gratuitos disponibles, programables en Lua, como Defold [22][ significado del hecho? ] , el motor arcade LÖVE [23] [24] , el diseñador de juegos Novashell [25] y el INSTEAD [ 26 ] orientado a misiones (principalmente basado en texto ) .

También se utiliza en el simulador de vuelo X-Plane, en el motor de rayos X para STALKER [27] .

Para el popular juego Minecraft se han creado modificaciones de ComputerCraft y su análogo más avanzado OpenComputers, que añaden ordenadores programados en el lenguaje Lua [28] .

El famoso juego Garry's Mod está programado y también admite modificaciones escritas en Lua.

El equipo de Croteam (desarrolladores de Serious Sam y The Talos Principle ) ha estado usando Lua en el scripting desde Serious Engine 3.5 [29] .

Para el juego GTA: San Andreas , las modificaciones se crean escritas en el lenguaje Lua y son compatibles con el complemento Moonloader. [30] Multi Theft Auto también es compatible con secuencias de comandos Lua.

La plataforma de juegos Roblox utiliza Lua como lenguaje de codificación de juegos y gestión del entorno del juego [31] .

El mod Ficsit-Networks ha sido creado por la comunidad de juegos Satisfactory , que permite programar cualquier acción en el lenguaje Lua [32] .

Factorio usa Lua para crear mods. [33] [34]

El juego Dual Universe se utiliza para la mecánica del juego y la programación de bloques de juegos

LuaTeX

El tipo de computadora LuaTeX , una versión extendida de pdfTeX , usa Lua como su lenguaje de secuencias de comandos incorporado [35] .

RPM

El administrador de paquetes RPM contiene un intérprete Lua incorporado [36] .

ID

Hay al menos dos entornos de desarrollo "nativos" para Lua, estos son:

  • ZeroBrane Studio [37]  es un entorno de desarrollo multiplataforma escrito en Lua.
  • Decoda  es un entorno de desarrollo de Windows escrito en C++ con amplias capacidades de depuración para secuencias de comandos Lua, incluidas las aplicaciones en ejecución. Para 2018, la última versión del entorno data de 2014 y tiene el estado de una versión beta.

Además, Lua es compatible con algunos IDE universales, en particular:

  • geany
  • Herramientas de desarrollo de Lua [38] para el entorno Eclipse
  • Complemento EmmyLua para el entorno IntelliJ IDEA , también equipado con verificación de sintaxis sobre la marcha y un sistema avanzado de anotaciones de tipo [39]

Había un módulo de soporte de Lua para el entorno de NetBeans , pero se suspendió en 2013 y solo está disponible para NetBeans 7.4 y versiones anteriores. El complemento no es compatible con NetBeans 8.

Véase también

  • Lista de aplicaciones que usan Lua

Notas

  1. ↑ 1 2 https://www.lua.org/authors.html
  2. ↑ Lua: sobre
  3. ↑ Manual de referencia de Lua 5.1 - 2019.
  4. ↑ Una mirada al diseño de Lua  - [ Nueva York] : Association for Computing Machinery , 2018. - ISSN 0001-0782 ; 1557-7317
  5. ↑ https://www.lua.org/license.html
  6. ↑ The lua Open Source Project en Open Hub: Página de licencias - 2006.
  7. ↑ https://www.lua.org/about.html
  8. ↑ Acerca de Lua . Lua.org. Consultado el 19 de junio de 2013. Archivado desde el original el 26 de diciembre de 2018.
  9. ↑ 1 2 ¿Qué lenguaje usas para las secuencias de comandos en tu motor de juegos? GameDev.net - Resultados de la encuesta
  10. ↑ 1 2 Biancuzzi, Warden, 2011 , p. 216.
  11. ↑ La evolución de un lenguaje de extensión: una historia de Lua (2001). Consultado el 24 de agosto de 2016. Archivado desde el original el 14 de octubre de 2017.
  12. ↑ HOPL, 2007 , pág. 2–1–2–26.
  13. ↑ Lua: un lenguaje integrado extensible. Unos pocos metamecanismos reemplazan una gran cantidad de funciones  (diciembre de 1996), págs. 26–33. Archivado desde el original el 20 de octubre de 2014. Consultado el 20 de septiembre de 2014.
  14. ↑ Manual de referencia de Lua 5.1 . Consultado el 5 de noviembre de 2019. Archivado desde el original el 15 de noviembre de 2013.
  15. ↑ El proyecto LuaJIT . Consultado el 18 de mayo de 2009. Archivado desde el original el 16 de abril de 2009.
  16. ↑ llvm-lua. Compilador JIT/Static para Lua usando LLVM en el backend. . Consultado el 21 de enero de 2009. Archivado desde el original el 22 de enero de 2009.
  17. ↑ Bret Mogilefsky. Lua en Grim Fandango . Consultado el 9 de diciembre de 2011. Archivado desde el original el 4 de febrero de 2012.
  18. ↑ HOPL, 2007 , pág. once.
  19. ↑ Paul Emmerich. Comenzando Lua con complementos de World of Warcraft. - Apress , julio de 2009. - ISBN 1430223715 .
  20. ↑ James Whitehead II, Bryan McLemore y Matthew Orlando. Programación de World of Warcraft . - Wiley , mayo de 2008. - ISBN 0470229810 .
  21. ↑ Tom Gutschmidt. cap. 8. La comunidad de juegos de Lua → Motores de juegos // Programación de juegos con Python, Lua y Ruby . - Premier Press, 2003. - 472 p. - ISBN 1-59200-079-7 .
  22. ↑ Manual de desarrollo del juego Defold: Lua en Defold . Desarrollar el motor del juego. Consultado el 2 de marzo de 2017. Archivado desde el original el 3 de marzo de 2017.
  23. ↑ Dj Walker-Morgan. La guía H Speed ​​​​to Lua → Desarrollo con Lua . La H (17 de abril de 2012). Consultado el 26 de febrero de 2015. Archivado desde el original el 26 de febrero de 2015.
  24. ↑ Darmie Akinlaja. LÖVE para la programación de juegos Lua. — Packt, 2013. — 106 p. — ISBN 978-1-78216-160-8 .
  25. ↑ Alan Thorne. Capítulo 8. Novashell y juegos 2D // Desarrollo de juegos multiplataforma . - Jones & Bartlett Learning, 2008. -  Pág. 225-264 . — 421 pág. — ISBN 978-1-59822-056-8 .
  26. ↑ Piotr Kosykh. EN LUGAR: Cómo comenzó todo  // IFPrint.org. - 18 de marzo de 2013. - Emisión. 1 . — ISSN 2307-535X . Archivado desde el original el 26 de febrero de 2015.
  27. ↑ Ronnie Tucker. Revista Full Circle #90: LA REVISTA INDEPENDIENTE PARA LA COMUNIDAD UBUNTU LINUX . — Revista Full Circle, 2014-10-31. - 50 s.
  28. ↑ Mateo Monk, Simon Monk. ComputerCraft: Programación de Lua en Minecraft . - Plataforma de publicación independiente CreateSpace, 2013-01-28. — 58 s. — ISBN 9781481927659 .
  29. ↑ Zero_Cool. Historia de la tecnología: motor serio | historia | Prueba de GPU . gamegpu.com. Consultado el 10 de abril de 2016. Archivado desde el original el 20 de abril de 2016.
  30. ↑ Favoritos - Lua - ASI - MoonLoader  (ruso) , BlastHack - Cheating as Art . Archivado desde el original el 29 de enero de 2018. Consultado el 28 de enero de 2018.
  31. ↑ Aprende Roblox | Codificación y Scripts . desarrollador.roblox.com Consultado el 23 de agosto de 2019. Archivado desde el original el 23 de agosto de 2019.
  32. ↑ FicsIt-Networks ::  Documentación de modificación satisfactoria . docs.fixit.aplicación . Recuperado: 24 de marzo de 2022.
  33. ↑ Modding-Factorio Wiki . wiki.factorio.com . Consultado el 1 de junio de 2022. Archivado desde el original el 1 de junio de 2022.
  34. ↑ Documentos API | factorio . lua-api.factorio.com . Consultado el 1 de junio de 2022. Archivado desde el original el 18 de mayo de 2022.
  35. ↑ CTAN : Paquete luatex  . Consultado el 6 de febrero de 2019. Archivado desde el original el 7 de febrero de 2019.
  36. ↑ Lua en RPM  . Consultado el 11 de febrero de 2019. Archivado desde el original el 24 de junio de 2018.
  37. ↑ ZeroBrane Studio - Lua IDE/editor/depurador para Windows, Mac OSX y Linux . Consultado el 31 de julio de 2013. Archivado desde el original el 18 de enero de 2016.
  38. ↑ Herramientas de desarrollo de Lua . Consultado el 14 de febrero de 2012. Archivado desde el original el 9 de febrero de 2012.
  39. ↑ EmmyLua ::  Repositorio de complementos de JetBrains . Repositorio de complementos de JetBrains. Fecha de acceso: 26 de febrero de 2018. Archivado desde el original el 27 de febrero de 2018.

Literatura

  • Roberto Jerusalén. Programación en lenguaje Lua. - 3ra edición.- DMK, 2014. - ISBN 9785940747673 . (original: Roberto Ierusalimschy. Programación en Lua. - 3ra ed.. - 2012. - ISBN 9788590379850 . )
  • Ian Dees. Lua // Siete idiomas más en siete semanas. Lenguajes que dan forma al futuro / Bruce Tate, Fred Daoud, Jack Moffitt, Ian Dees. - La estantería pragmática, 2015. - P. 1-48. — 320 s. — ISBN 978-1941222157 .
  • Mario Kasuba. Libro de cocina de desarrollo de juegos Lua. - Editorial Packt, 2015. - 402 p. — ISBN 978-1849515504 .
  • David Joven. Juego de aprendizaje Programación de IA con Lua. - Packt Publishing, 2014. - 352 p. — ISBN 978-1783281336 .
  • Jayant Varma. Aprenda Lua para el desarrollo de juegos iOS . - Apress, 2012. - 410 p. — ISBN 9781430246626 .
  • Kurt Jung, Aaron Brown. Comenzando con la Programación Lua . - John Wiley & Sons, 2011. - 675 p. - (Programador a Programador). — ISBN 9781118079119 .
historia del lenguaje
  • R. Ierusalimschy, LH de Figueiredo, W. Celes. La evolución de Lua  // Actas de ACM HOPL III. 2-1–2-26. — 2007.
  • Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes. La evolución de un lenguaje de extensión: una historia de Lua . Reimpresión de Actas del V Simposio Brasileño de Lenguajes de Programación (2001) B-14–B-28. Consultado el 9 de diciembre de 2011. Archivado desde el original el 4 de febrero de 2012.
  • Federico Biancuzzi, Shane Warden. Capítulo 7. Lua // Pioneros de la programación. Conversaciones con los creadores de los principales lenguajes de programación = Masterminds of Programming: Conversaciones con los creadores de los principales lenguajes de programación. - Símbolo, 2011. - S. 211-230. — 608 pág. - 1500 copias.  — ISBN 9785932861707 .
  • Entrevista con Robert Yeruzalimsky para Computerworld sobre el idioma Lua

Véase también

  • Ardilla  : lenguaje de programación basado en Lua

Enlaces

Lua en ruso

Traducciones de manuales Artículos y reseñas
 Lúa
compiladoresFrameworks y DLLPuertos y distribucionesIDEAplicaciones
 Lenguajes de programación