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

Два

Снимок экрана с кодом Lua из модуля Lua Википедии с использованием MediaWiki Scribunto. расширения
Парадигма	Мультипарадигмальность : скриптовая , императивная ( процедурная , на основе прототипов , объектно-ориентированная ), функциональная , мета , рефлексивная.
Разработано	Роберто Иерусалимский Вальдемар Селес Луис Энрике де Фигейредо
Впервые появился	1993 год ( 1993 )
Стабильная версия	5.4.6   / 14 мая 2023 г ( 14 мая 2023 г. )
Дисциплина набора текста	Динамичный , слабый , дак
Язык реализации	АНСИ С
ТЫ	Кросс-платформенный
Лицензия	МОЯ лицензия
Расширения имен файлов	.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 является кроссплатформенным , поскольку интерпретатор скомпилированного C байт-кода написан на ANSI , а у Lua есть относительно простой C API для встраивания его в приложения.

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

История

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

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

Предшественниками Lua были языки описания/конфигурации данных 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 x
end

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

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

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

if condition then
	--statement body
end

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

if condition then
	--statement body
else
	--statement body
end

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

if condition then
	--statement body
elseif condition then
	--statement body
else -- optional
	--optional default statement body
end

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

--condition = true

while condition do
  --statements
end

repeat
  --statements
until condition

for 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)
  end
end

Функции

Обработка функций в 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)
  end
end

Любые будущие вызовы 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
  end
end
fourplus = 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_table
b_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 table
print(point["x"])            -- Prints 10
print(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}
end

Point.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)
end
array = { 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)
end

function Vector.magnitude(self)     -- Another method
  return math.sqrt(self.x^2 + self.y^2 + self.z^2)
end

local vec = Vector.new(0, 1, 0) -- Create a vector
print(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 = Vector

function 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)
end

function Vector:magnitude()     -- Another method
  -- Reference the implicit object using self
  return math.sqrt(self.x^2 + self.y^2 + self.z^2)
end

local vec = Vector:new(0, 1, 0) -- Create a vector
print(vec:magnitude())          -- Call a method (output: 1)
print(vec.x)                    -- Access a member variable (output: 0)

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

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

local Vector = {}
Vector.__index = Vector

function 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)
end

function 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 inheritance
local VectorMult = {}
VectorMult.__index = VectorMult
setmetatable(VectorMult, Vector) -- Make VectorMult a child of Vector

function VectorMult:multiply(value) 
  self.x = self.x * value
  self.y = self.y * value
  self.z = self.z * value
  return self
end

local vec = VectorMult:new(0, 1, 0) -- Create a vector
print(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 2
print(vec.y)                    -- Access member again (output: 2)

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

Реализация

Программы Lua не интерпретируются напрямую из текстового файла Lua, а компилируются в байт-код, который затем запускается на виртуальной машине Lua . Процесс компиляции обычно невидим для пользователя и выполняется во время выполнения , особенно когда используется 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. Конструкция API Lua устраняет необходимость ручного управления ссылками в коде 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
$ ./example
Result: 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 , язык 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