Луа (язык программирования)

Два

Снимок экрана с кодом Lua из модуля Lua Википедии с использованием MediaWiki Scribunto. расширения
Парадигма	Мультипарадигмальность : скриптовая , императивная ( процедурная , прототипно-ориентированная , объектно-ориентированная ), функциональная , мета , рефлексивная.
Разработано	Роберто Иерусалимский Вальдемар Селес Луис Энрике де Фигейредо
Впервые появился	1993 год ( 1993 )
Стабильная версия	5.4.7   / 25 июня 2024 г ( 25 июня 2024 г. )
Дисциплина набора текста	Динамичный , сильный , уточный
Язык реализации	АНСИ С
ТЫ	Кросс-платформенный
Лицензия	С
Расширения имен файлов	.lua
Веб-сайт	www .два .org
Основные реализации
Луа , ЛуаЖИТ , ЛуаВела , MoonSharp , Лувит , LuaRT , Lua u
Диалекты
Metalua , Холостой ход , GSL Shell
Под влиянием
C++ , CLU , Модуль , Схема , СНОБОЛ
Под влиянием
GameMonkey , Io , JavaScript , Юля , MiniD, Красный , Кольцо , Руби , Белка , MoonScript, C--

Lua ( / ˈ l uː ə / LOO -ə ; от португальского : lua [ˈlu(w)ɐ] означает луна ) — легкий , высокоуровневый , многопарадигмальный язык программирования , предназначенный в основном для встроенного использования во встроенных приложениях. Lua является кроссплатформенным программным обеспечением поскольку интерпретатор скомпилированного , байт-кода написан на ANSI C , Lua имеет относительно простой интерфейс программирования приложений на языке C ( API ) для встраивания его в приложения.

Lua возник в 1993 году как язык расширения программных приложений для удовлетворения растущего в то время спроса на настройку. Он предоставлял базовые возможности большинства процедурных языков программирования, но более сложные или специфичные для предметной области функции не были включены; скорее, он включал механизмы расширения языка, позволяющие программистам реализовывать такие функции. Поскольку Lua задумывался как общий встраиваемый язык расширений, разработчики Lua сосредоточились на повышении его скорости , портативности , расширяемости и простоты использования при разработке.

История

Lua был создан в 1993 году Роберто Иерусалимским , Луисом Энрике де Фигейредо и Вальдемаром Селесом, членами группы технологий компьютерной графики (Tecgraf) Папского католического университета Рио-де-Жанейро в Бразилии .

С 1977 по 1992 год Бразилия проводила политику сильных торговых барьеров (называемых рыночными резервами) для компьютерного оборудования и программного обеспечения , полагая, что Бразилия может и должна производить собственное оборудование и программное обеспечение. В такой атмосфере клиенты Tecgraf не могли позволить себе ни политически, ни финансово покупать специализированное программное обеспечение за границей; В рамках рыночного резерва клиентам придется пройти сложный бюрократический процесс, чтобы доказать, что их потребности не могут быть удовлетворены бразильскими компаниями. Эти причины побудили Tecgraf реализовать необходимые базовые инструменты с нуля.

Предшественниками Lua были языки описания/конфигурации данных Simple Object Language (SOL) и язык ввода данных (DEL). Они были независимо разработаны в Tecgraf в 1992–1993 годах, чтобы добавить некоторую гибкость двум различным проектам (оба представляли собой интерактивные графические программы для инженерных приложений в компании Petrobras ). В SOL и DEL отсутствовали какие-либо структуры управления потоком данных, и Petrobras чувствовала растущую потребность добавить к ним полную мощь программирования.

В «Эволюции Lua» авторы языка написали:

В 1993 году единственным реальным претендентом был Tcl , который был специально разработан для внедрения в приложения. Однако Tcl имел незнакомый синтаксис, не обеспечивал хорошей поддержки описания данных и работал только на платформах Unix. Мы не рассматривали LISP или Scheme из-за их недружественного синтаксиса. Python все еще находился в зачаточном состоянии. В свободной атмосфере «сделай сам», царившей тогда в Tecgraf, было вполне естественно попытаться разработать собственный скриптовый язык... Поскольку многие потенциальные пользователи языка не были профессиональными программистами, в языке следует избегать загадочных синтаксис и семантика. Реализация нового языка должна быть легко переносимой, поскольку у клиентов Tecgraf была очень разнообразная коллекция компьютерных платформ. Наконец, поскольку мы ожидали, что в другие продукты Tecgraf также потребуется встроить язык сценариев, новый язык должен следовать примеру SOL и предоставляться в виде библиотеки с C API.

Lua 1.0 был разработан таким образом, что его конструкторы объектов, которые тогда немного отличались от нынешнего легкого и гибкого стиля, включали синтаксис описания данных SOL (отсюда и название Lua: Sol означает «Солнце» на португальском языке, а Lua означает "Луна"). Lua Синтаксис для управляющих структур в основном был заимствован из Modula ( if, while, repeat/ until), но также испытал влияние CLU (множественные присваивания и множественные возвраты из вызовов функций, как более простая альтернатива ссылочным параметрам или явным указателям ), C++ («изящная идея, позволяющая локальную переменную только там, где она нам нужна» объявлять ), SNOBOL и AWK ( ассоциативные массивы ). В статье, опубликованной в журнале Dr. Dobb's Journal , создатели Lua также заявляют, что LISP и Scheme с их единственным, вездесущим механизмом структуры данных ( списком ) оказали большое влияние на их решение разработать таблицу в качестве основной структуры данных Lua.

Lua Семантика со временем все больше подвергалась влиянию Scheme. особенно с введением анонимных функций и полной лексической области видимости . В новых версиях Lua было добавлено несколько функций.

Версии Lua до версии 5.0 выпускались под лицензией, аналогичной лицензии BSD . Начиная с версии 5.0, Lua лицензируется по лицензии MIT . Обе лицензии являются разрешительными лицензиями на свободное программное обеспечение и практически идентичны.

Функции

Lua обычно называют « мультипарадигмальным » языком, предоставляющим небольшой набор общих функций, которые можно расширить для решения различных типов задач. Lua не содержит явной поддержки наследования , но позволяет реализовать его с помощью метатаблиц . Точно так же Lua позволяет программистам реализовывать пространства имен , классы и другие связанные функции, используя реализацию одной таблицы; первоклассные функции позволяют использовать многие методы функционального программирования , а полная лексическая область видимости позволяет скрывать детализированную информацию, чтобы обеспечить соблюдение принципа наименьших привилегий .

В общем, Lua стремится предоставить простые и гибкие мета-функции , которые можно расширять по мере необходимости, а не предоставлять набор функций, специфичный для одной парадигмы программирования. В результате базовый язык является легким ; полный справочный интерпретатор всего около 247 КБ. занимает и легко адаптируется к широкому спектру применений.

Будучи динамически типизированным языком, предназначенным для использования в качестве языка расширения или языка сценариев , Lua достаточно компактен, чтобы соответствовать множеству хост-платформ. Он поддерживает лишь небольшое количество атомарных структур данных, таких как логические двойной точности значения, числа ( с плавающей запятой и 64-битные целые числа по умолчанию) и строки . Типичные структуры данных, такие как массивы , наборы , списки и записи, могут быть представлены с использованием единственной собственной структуры данных Lua — таблицы, которая по сути представляет собой гетерогенный ассоциативный массив .

Lua реализует небольшой набор расширенных функций, таких как первоклассные функции , сборка мусора , замыкания , правильные хвостовые вызовы , приведение (автоматическое преобразование между строковыми и числовыми значениями во время выполнения), сопрограммы (совместная многозадачность) и динамическая загрузка модулей .

Синтаксис

Классический «Привет, мир!» Программу можно записать следующим образом, с круглыми скобками или без них:

print("Hello, World!")

print "Hello, World!"

Комментарий в Lua начинается с двойного дефиса и продолжается до конца строки, аналогично Ada , Eiffel , Haskell , SQL и VHDL . Многострочные строки и комментарии выделяются двойными квадратными скобками.

-- Single line comment--[[Multi-line comment--]]

Функция факториала реализована в этом примере:

function factorial(n)  local x = 1  for i = 2, n do    x = x * i  end  return xend

Поток управления

В Lua есть один тип условной проверки: if then end с дополнительным else и elseif then Конструкции управления выполнением.

Общий if then end оператор требует всех трех ключевых слов:

if condition then	--statement bodyend

The else Ключевое слово может быть добавлено вместе с сопровождающим блоком операторов для управления выполнением, когда if состояние оценивается как false:

if condition then	--statement bodyelse	--statement bodyend

Выполнение также можно контролировать в соответствии с несколькими условиями с помощью elseif then ключевые слова:

if condition then	--statement bodyelseif condition then	--statement bodyelse -- optional	--optional default statement bodyend

В Lua есть четыре типа условных циклов: while петля , repeat цикл (аналогично do while цикл ), числовой for цикл и общий for петля.

--condition = truewhile condition do  --statementsendrepeat  --statementsuntil conditionfor i = first, last, delta do  --delta may be negative, allowing the for loop to count down or up  --statements  --example: print(i)end

Этот универсальный for цикл будет перебирать таблицу _G используя стандартную функцию итератора pairs, пока не вернется nil:

for key, value in pairs(_G) do  print(key, value)end

Циклы также могут быть вложенными (помещаться внутри другого цикла).

local grid = {  { 11, 12, 13 },  { 21, 22, 23 },  { 31, 32, 33 }}for y, row in pairs(grid) do  for x, value in pairs(row) do    print(x, y, value)  endend

Функции

Обработка функций в Lua как значений первого класса показана в следующем примере, где изменено поведение функции печати:

do  local oldprint = print  -- Store current print function as oldprint  function print(s)    --[[ Redefine print function. The usual print function can still be used      through oldprint. The new one has only one argument.]]    oldprint(s == "foo" and "bar" or s)  endend

Любые будущие вызовы print теперь будет маршрутизироваться через новую функцию, а из-за лексической области видимости Lua старая функция печати будет доступна только для новой, модифицированной печати.

Lua также поддерживает замыкания , как показано ниже:

function addto(x)  -- Return a new function that adds x to the argument  return function(y)    --[[ When we refer to the variable x, which is outside the current      scope and whose lifetime would be shorter than that of this anonymous      function, Lua creates a closure.]]    return x + y  endendfourplus = addto(4)print(fourplus(3)) -- Prints 7--This can also be achieved by calling the function in the following way:print(addto(4)(3))--[[ This is because we are calling the returned function from 'addto(4)' with the argument '3' directly.  This also helps to reduce data cost and up performance if being called iteratively.]]

Новое замыкание для переменной x создается каждый раз addto вызывается, так что каждая новая возвращаемая анонимная функция всегда будет иметь доступ к своей собственной x параметр. Закрытием управляет сборщик мусора Lua, как и любой другой объект.

Таблицы

Таблицы являются наиболее важными структурами данных (и, по замыслу, единственным встроенным составным типом данных ) в Lua и являются основой всех типов, создаваемых пользователем. Они представляют собой ассоциативные массивы с добавлением автоматического числового ключа и специального синтаксиса.

Таблица представляет собой набор пар ключей и данных, где на данные ссылается ключ; другими словами, это хешированный гетерогенный ассоциативный массив.

Таблицы создаются с помощью {} синтаксис конструктора.

a_table = {} -- Creates a new, empty table

Таблицы всегда передаются по ссылке (см . Вызов путем совместного использования ).

Ключ (индекс) может иметь любое значение, кроме nil и NaN , включая функции.

a_table = {x = 10}  -- Creates a new table, with one entry mapping "x" to the number 10.print(a_table["x"]) -- Prints the value associated with the string key, in this case 10.b_table = a_tableb_table["x"] = 20   -- The value in the table has been changed to 20.print(b_table["x"]) -- Prints 20.print(a_table["x"]) -- Also prints 20, because a_table and b_table both refer to the same table.

Таблица часто используется как структура (или запись ), используя строки в качестве ключей. Поскольку такое использование очень распространено, Lua имеет специальный синтаксис для доступа к таким полям.

point = { x = 10, y = 20 }   -- Create new tableprint(point["x"])            -- Prints 10print(point.x)               -- Has exactly the same meaning as line above. The easier-to-read dot notation is just syntactic sugar.

Используя таблицу для хранения связанных функций, она может выступать в качестве пространства имен.

Point = {}Point.new = function(x, y)  return {x = x, y = y}  --  return {["x"] = x, ["y"] = y}endPoint.set_x = function(point, x)  point.x = x  --  point["x"] = x;end

Таблицам автоматически присваивается числовой ключ, что позволяет использовать их в качестве типа данных массива . Первый автоматический индекс равен 1, а не 0, как во многих других языках программирования (хотя допускается явный индекс 0).

Цифровой ключ 1 отличается от строкового ключа "1".

array = { "a", "b", "c", "d" }   -- Indices are assigned automatically.print(array[2])                  -- Prints "b". Automatic indexing in Lua starts at 1.print(#array)                    -- Prints 4.  # is the length operator for tables and strings.array[0] = "z"                   -- Zero is a legal index.print(#array)                    -- Still prints 4, as Lua arrays are 1-based.

Длина стола t определяется как любой целочисленный индекс n такой, что t[n] не nil и t[n+1] является nil; более того, если t[1] является nil, n может быть нулевым. Для обычного массива с ненулевыми значениями от 1 до заданного n, его длина именно такая n, индекс его последнего значения. Если в массиве есть «дыры» (то есть нулевые значения между другими ненулевыми значениями), то #t может быть любым из индексов, который непосредственно предшествует nil value (то есть любое такое нулевое значение может считаться концом массива).

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

Таблица может представлять собой массив объектов.

function Point(x, y)        -- "Point" object constructor  return { x = x, y = y }   -- Creates and returns a new object (table)endarray = { Point(10, 20), Point(30, 40), Point(50, 60) }   -- Creates array of points                        -- array = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } };print(array[2].y)                                         -- Prints 40

Использование хэш-карты для эмуляции массива обычно медленнее, чем использование реального массива; однако таблицы Lua оптимизированы для использования в качестве массивов, чтобы избежать этой проблемы.

Метатаблицы

Расширяемая семантика — ключевая особенность Lua, а концепция метатаблиц обеспечивает мощную настройку таблиц. В следующем примере демонстрируется «бесконечная» таблица. Для любого n, fibs[n] даст n-е число Фибоначчи с использованием динамического программирования и мемоизации .

fibs = { 1, 1 }                                -- Initial values for fibs[1] and fibs[2].setmetatable(fibs, {  __index = function(values, n)                --[[__index is a function predefined by Lua,                                                    it is called if key "n" does not exist.]]    values[n] = values[n - 1] + values[n - 2]  -- Calculate and memoize fibs[n].    return values[n]  end})

Объектно-ориентированное программирование

Хотя в Lua нет встроенной концепции классов , объектно-ориентированное программирование можно эмулировать с помощью функций и таблиц. Объект формируется путем помещения методов и полей в таблицу. Наследование (как одиночное, так и множественное) можно реализовать с помощью метатаблиц , делегируя несуществующие методы и поля родительскому объекту.

В этих методах нет такого понятия, как «класс»; скорее, прототипы используются , подобные Self или JavaScript . Новые объекты создаются либо с помощью фабричного метода (который создает новые объекты с нуля), либо путем клонирования существующего объекта.

Создание базового векторного объекта:

local Vector = {}local VectorMeta = { __index = Vector}function Vector.new(x, y, z)    -- The constructor  return setmetatable({x = x, y = y, z = z}, VectorMeta)endfunction Vector.magnitude(self)     -- Another method  return math.sqrt(self.x^2 + self.y^2 + self.z^2)endlocal vec = Vector.new(0, 1, 0) -- Create a vectorprint(vec.magnitude(vec))       -- Call a method (output: 1)print(vec.x)                    -- Access a member variable (output: 0)

Здесь, setmetatable сообщает Lua искать элемент в Vector таблице, если ее нет в vec стол. vec.magnitude, что эквивалентно vec["magnitude"], впервые смотрит в vec стол для magnitude элемент. vec таблица не имеет magnitude элемент, но его метатаблица делегирует Vector стол для magnitude элемент, когда он не найден в vec стол.

Lua предоставляет некоторый синтаксический сахар для облегчения объектной ориентации. Чтобы объявить функции-члены внутри таблицы прототипов, можно использовать function table:func(args), что эквивалентно function table.func(self, args). При вызове методов класса также используется двоеточие: object:func(args) эквивалентно object.func(object, args).

Имея это в виду, вот соответствующий класс с : синтаксический сахар:

local Vector = {}Vector.__index = Vectorfunction Vector:new(x, y, z)    -- The constructor  -- Since the function definition uses a colon,   -- its first argument is "self" which refers  -- to "Vector"  return setmetatable({x = x, y = y, z = z}, self)endfunction Vector:magnitude()     -- Another method  -- Reference the implicit object using self  return math.sqrt(self.x^2 + self.y^2 + self.z^2)endlocal vec = Vector:new(0, 1, 0) -- Create a vectorprint(vec:magnitude())          -- Call a method (output: 1)print(vec.x)                    -- Access a member variable (output: 0)

Наследование

Lua поддерживает использование метатаблиц для наследования классов Lua. В этом примере мы разрешаем векторам умножать свои значения на константу в производном классе.

local Vector = {}Vector.__index = Vectorfunction Vector:new(x, y, z)    -- The constructor  -- Here, self refers to whatever class's "new"  -- method we call.  In a derived class, self will  -- be the derived class; in the Vector class, self  -- will be Vector  return setmetatable({x = x, y = y, z = z}, self)endfunction Vector:magnitude()     -- Another method  -- Reference the implicit object using self  return math.sqrt(self.x^2 + self.y^2 + self.z^2)end-- Example of class inheritancelocal VectorMult = {}VectorMult.__index = VectorMultsetmetatable(VectorMult, Vector) -- Make VectorMult a child of Vectorfunction VectorMult:multiply(value)   self.x = self.x * value  self.y = self.y * value  self.z = self.z * value  return selfendlocal vec = VectorMult:new(0, 1, 0) -- Create a vectorprint(vec:magnitude())          -- Call a method (output: 1)print(vec.y)                    -- Access a member variable (output: 1)vec:multiply(2)                 -- Multiply all components of vector by 2print(vec.y)                    -- Access member again (output: 2)

Lua также поддерживает множественное наследование ; __index может быть функцией или таблицей. перегрузка операторов Также возможна ; Метатаблицы Lua могут содержать такие элементы, как __add, __sub и так далее.

Выполнение

Программы Lua не интерпретируются непосредственно из текстового файла Lua, а компилируются в байт-код, который затем запускается на виртуальной машине Lua (VM). Процесс компиляции обычно невидим для пользователя и выполняется во время выполнения , особенно когда используется JIT -компилятор, но его можно выполнять и в автономном режиме, чтобы повысить производительность загрузки или уменьшить объем памяти, занимаемой компилятором. среду хоста, исключив компилятор. Байт-код Lua также можно создать и выполнить изнутри Lua, используя команду dump функция из библиотеки строк и load/loadstring/loadfile функции. Lua версии 5.3.4 реализован примерно в 24 000 строк кода C.

Как и большинство процессоров и в отличие от большинства виртуальных машин (которые основаны на стеке ), виртуальная машина Lua основана на регистрах и, следовательно, больше напоминает конструкцию большинства аппаратных средств. Архитектура регистров позволяет избежать чрезмерного копирования значений и уменьшает общее количество инструкций на функцию. Виртуальная машина Lua 5 — одна из первых чистых виртуальных машин на основе регистров, получивших широкое распространение. Parrot и Android от Dalvik — две другие известные виртуальные машины на основе регистров. Виртуальная машина PCScheme также была основана на регистрах.

Этот пример представляет собой листинг байт-кода функции факториала, определенной выше (как показано в luac 5.1 компилятор):

function <factorial.lua:1,7> (9 instructions, 36 bytes at 0x8063c60)1 param, 6 slots, 0 upvalues, 6 locals, 2 constants, 0 functions	1	[2]	LOADK    	1 -1	; 1	2	[3]	LOADK    	2 -2	; 2	3	[3]	MOVE     	3 0	4	[3]	LOADK    	4 -1	; 1	5	[3]	FORPREP  	2 1	; to 7	6	[4]	MUL      	1 1 5	7	[3]	FORLOOP  	2 -2	; to 6	8	[6]	RETURN   	1 2	9	[7]	RETURN   	0 1

C API

Lua предназначен для встраивания в другие приложения и для этой цели предоставляет C API . API разделен на две части: ядро ​​Lua и вспомогательную библиотеку Lua. Конструкция Lua API устраняет необходимость ручного подсчета (управления) ссылок в коде C, в отличие от Python API . API, как и язык, минималистичный. Расширенные функции предоставляются вспомогательной библиотекой, состоящей в основном из препроцессора макросов , помогающих выполнять сложные операции с таблицами.

API Lua C основан на стеке . Lua предоставляет функции для отправки и извлечения самых простых типов данных C (целые числа, числа с плавающей запятой и т. д.) в стек и из него, а также функции для управления таблицами через стек. Стек Lua несколько отличается от традиционного стека; например, стек можно индексировать напрямую. Отрицательные индексы указывают на смещение от вершины стека. Например, −1 — это верхнее значение (последнее введенное значение), а положительные индексы указывают на смещение от нижнего (самое старое значение). Маршалинг данных между функциями C и Lua также выполняется с использованием стека. Чтобы вызвать функцию Lua, аргументы помещаются в стек, а затем lua_call используется для вызова фактической функции. При написании функции C для прямого вызова из Lua аргументы считываются из стека.

Вот пример вызова функции Lua из C:

#include <stdio.h>#include <lua.h> // Lua main library (lua_*)#include <lauxlib.h> // Lua auxiliary library (luaL_*)int main(void){    // create a Lua state    lua_State *L = luaL_newstate();    // load and execute a string    if (luaL_dostring(L, "function foo (x,y) return x+y end")) {        lua_close(L);        return -1;    }    // push value of global "foo" (the function defined above)    // to the stack, followed by integers 5 and 3    lua_getglobal(L, "foo");    lua_pushinteger(L, 5);    lua_pushinteger(L, 3);    lua_call(L, 2, 1); // call a function with two arguments and one return value    printf("Result: %d\n", lua_tointeger(L, -1)); // print integer value of item at stack top    lua_pop(L, 1); // return stack to original state    lua_close(L); // close Lua state    return 0;}

Запуск этого примера дает:

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

C API также предоставляет несколько специальных таблиц, расположенных в различных «псевдоиндексах» стека Lua. В LUA_GLOBALSINDEX до Lua 5.2 это таблица глобальных переменных, _G изнутри Lua, который является основным пространством имен . Также существует реестр, расположенный по адресу LUA_REGISTRYINDEX где программы C могут хранить значения Lua для последующего извлечения.

Модули

Помимо модулей стандартной библиотеки (ядра), можно писать расширения с использованием Lua API. Модули расширения — это общие объекты , которые можно использовать для расширения функций интерпретатора путем предоставления собственных возможностей сценариям Lua. Скрипты Lua могут загружать модули расширения, используя require, точно так же, как модули, написанные на самом Lua или с помощью package.loadlib. Когда библиотека C загружается через require('foo') Lua будет искать функцию luaopen_foo и вызвать ее, которая действует как любая функция C, вызываемая из Lua, и обычно возвращает таблицу, заполненную методами. Растущий набор модулей, называемых Rocks доступен через систему управления пакетами LuaRocks , . в духе CPAN , RubyGems и Python egg . Lua Предварительно написанные привязки существуют для большинства популярных языков программирования, включая другие языки сценариев. Для C++ существует ряд подходов на основе шаблонов и несколько автоматических генераторов привязок.

Приложения

Основная статья: Список приложений, использующих Lua

В разработке видеоигр Lua широко используется в качестве языка сценариев , в основном из-за его кажущейся простоты внедрения, быстрого выполнения и короткой кривой обучения . Известные игры, использующие Lua, включают Roblox , Garry's Mod , World of Warcraft , Payday 2 , Phantasy Star Online 2 , Dota 2 , Crysis , и многие другие. В некоторые игры, которые изначально не поддерживают программирование или сценарии Lua, эта функция добавляется модами, как это делает ComputerCraft для Minecraft . Кроме того, Lua используется в программном обеспечении, не связанном с видеоиграми, таком как Adobe Lightroom , Moho , iClone , Aerospike и некоторых системных программах во FreeBSD и NetBSD , а также используется в качестве языка сценариев шаблонов в MediaWiki с использованием расширения Scribunto.

В 2003 году опрос, проведенный GameDev.net, показал, что Lua является самым популярным языком сценариев для программирования игр. 12 января 2012 года Lua был объявлен победителем премии Front Line Award 2011 журнала Game Developer в категории «Инструменты программирования».

Многие неигровые приложения также используют Lua для расширения, такие как LuaTeX , реализация TeX языка набора текста , Redis , база данных «ключ-значение» , ScyllaDB , хранилище с широкими столбцами , Neovim , текстовый редактор, Nginx , веб-сервер и Wireshark — анализатор сетевых пакетов.

Благодаря расширению Scribunto Lua доступен в качестве серверного языка сценариев в программном обеспечении MediaWiki , на котором работает Arc.Ask3.Ru и другие вики. Среди его применений — возможность интеграции данных из Викиданных в статьи, и питание автоматизированной системы Taxobox .

Производные языки

Языки, которые компилируются в Lua

• MoonScript — это динамический , к пробелам, чувствительный язык сценариев вдохновленный CoffeeScript , который скомпилирован в Lua. Это означает, что вместо использования do и end (или { и }) для разделения разделов кода используются разрывы строк и стиль отступов . является сайт распространения видеоигр Itch.io. Заметным примером использования MoonScript
• Haxe поддерживает компиляцию в некоторые цели Lua, включая Lua 5.1-5.3 и LuaJIT 2.0 и 2.1.
• Фенхель — диалект Лиспа, ориентированный на Lua.
• Urn — диалект Лиспа, построенный на Lua.
• Amulet, ML -подобный функциональный язык программирования , компилятор которого генерирует файлы Lua.

Диалекты

• LuaJIT — своевременный компилятор Lua 5.1.
• Lua u , разработанная Roblox Corporation , производная от Lua 5.1 с постепенной типизацией , дополнительными функциями и ориентацией на производительность.
• Ravi, язык Lua 5.3 с поддержкой JIT и дополнительной статической типизацией. JIT руководствуется информацией о типе.
• Shine — ответвление LuaJIT со множеством расширений, включая систему модулей и систему макросов.
• Glua, модифицированная версия, встроенная в игру Garry's Mod в качестве языка сценариев.
• Бирюзовый — статически типизированный диалект Lua, написанный на Lua.

Кроме того, сообщество пользователей Lua предоставляет некоторые исправления мощности поверх эталонной реализации C.

См. также

• Сравнение языков программирования

Дальнейшее чтение

• Иерусалимский, Р. (2013). Программирование на Lua (3-е изд.). Луа.орг. ISBN  978-85-903798-5-0 . (Первое издание доступно в Интернете .)
• Гутшмидт, Т. (2003). Программирование игр на Python, Lua и Ruby . Курс Технологии ПТР. ISBN  978-1-59200-077-7 .
• Шуйтема, П.; Нью, М. (2005). Разработка игр на Lua . Чарльз Ривер Медиа. ISBN  978-1-58450-404-7 .
• Юнг, К.; Браун, А. (2007). Начало программирования на Lua . Врокс Пресс . ISBN  978-0-470-06917-2 . Архивировано из оригинала 8 июля 2018 года . Проверено 7 июля 2018 г.
• Фигейредо, ЛХ; Ревнивый, В.; Иерусалимский Р., ред. (2008). Жемчужины Lua-программирования . Луа.орг. ISBN  978-85-903798-4-3 .
• Тахтеев, Юрий (2012). Места кодирования: практика разработки программного обеспечения в южноамериканском городе . Массачусетский технологический институт Пресс . ISBN  978-0-262-01807-4 . Архивировано из оригинала 2 ноября 2012 года. Главы 6 и 7 посвящены Lua, а другие рассматривают программное обеспечение в Бразилии в более широком смысле.
• Варма, Джаянт (2012). Изучите Lua для разработки игр для iOS . Апресс . ISBN  978-1-4302-4662-6 .
• Мэтисон, Эш (29 апреля 2003 г.). «Введение в Lua» . GameDev.net . Архивировано из оригинала 18 декабря 2012 года . Проверено 3 января 2013 г.
• Филдхаус, Кейт (16 февраля 2006 г.). «Знакомство с Луа» . ONLamp.com . О'Рейли Медиа . Архивировано из оригинала 12 марта 2006 года . Проверено 28 февраля 2006 г.
• Штрайхер, Мартин (28 апреля 2006 г.). «Встраиваемые сценарии с помощью Lua» . РазработчикWorks . ИБМ . Архивировано из оригинала 2 июля 2009 года . Проверено 7 июля 2018 г.
• Куигли, Джозеф (1 июня 2007 г.). «Взгляд на Луа» . Linux-журнал .
• Гамильтон, Наоми (11 сентября 2008 г.). «А-Я языков программирования: Lua» . Компьютерный мир . ИДГ . Архивировано из оригинала 8 июля 2018 года . Проверено 7 июля 2018 г. Интервью с Роберто Иерусалимским.
• Иерусалимский, Роберто; де Фигейредо, Луис Энрике; Селес, Вальдемар (12 мая 2011 г.). «Пропуская язык через игольное ушко» . Очередь АКМ . 9 (5): 20–29. дои : 10.1145/1978862.1983083 . S2CID   19484689 . Как встраиваемость Lua повлияла на его дизайн.
• Иерусалимский, Роберто; де Фигейредо, Луис Энрике; Селес, Вальдемар (ноябрь 2018 г.). «Взгляд на дизайн Lua» . Коммуникации АКМ . 61 (11): 114–123. дои : 10.1145/3186277 . S2CID   53114923 .
• Статьи и диссертации по Lua

Внешние ссылки

• Официальный сайт
• Пользователи Lua. Архивировано 16 декабря 2010 г. на Wayback Machine , Сообщество.
• Форум Lua. Архивировано 28 сентября 2021 г. на Wayback Machine.
• Из ЛуаД
• Lua Rocks — Менеджер пакетов
• Проекты на Lua