Lua

Материал из Википедии — свободной энциклопедии
Перейти к: навигация, поиск
Lua
Lua-logo-nolabel.svg
Класс языка

мультипарадигмальный: императивный, функциональный, объектно-ориентированный (прототипный), скриптовый, встраиваемый

Тип исполнения

интерпретируемый, JIT-компилируемый

Появился в

1993

Автор

Роберту Иерузалимски,
Валдемар Селиш,
Луиш Энрике ди Фигейреду

Расширение файлов

.lua

Выпуск

5.3.4 (12 января 2017 (2017-01-12))

Система типов

динамическая, строгая, «утиная»

Основные реализации:

Lua, LuaJIT, LLVM-Lua, LuaCLR, Nua, Lua Alchemy и др.[1]

Диалекты

MetaLua

Испытал влияние

Scheme, Снобол, Модула, Клу, C++

Повлиял на

JavaScript, Ruby, Io, GameMonkey, Squirrel, Dao, MiniD

Лицензия

лицензия MIT

ОС

кроссплатформенное программное обеспечение[2]

Сайт

lua.org

Lua (лу́а, с порт. — «луна»[3]) — скриптовый язык программирования, разработанный в подразделении Tecgraf (Computer Graphics Technology Group) Католического университета Рио-де-Жанейро (Бразилия). Интерпретатор языка является свободно распространяемым, с открытыми исходными текстами на языке Си.

По возможностям, идеологии и реализации язык ближе всего к JavaScript, однако Lua отличается более мощными и гораздо более гибкими конструкциями. Хотя Lua не содержит понятия класса и объекта в явном виде, механизмы объектно-ориентированного программирования, включая множественное наследование, легко реализуются с использованием метатаблиц, которые также отвечают за перегрузку операций и т. п. Реализуемая модель объектно-ориентированного программирования — прототипная (как и в JavaScript).

Язык широко используется для создания тиражируемого программного обеспечения (например, на нём написан графический интерфейс пакета Adobe Lightroom). Также получил известность как язык программирования уровней и расширений во многих играх (в том числе World of Warcraft) из-за удобства встраивания, скорости исполнения кода и лёгкости обучения[4][неавторитетный источник? 419 дней].

История[править | править код]

Lua разработана подразделением Tecgraf (группа технологий компьютерной графики) Католического университета Рио-де-Жанейро в Бразилии, история языка ведёт отсчёт с 1993 года. Авторы языка — Роберто Иерусалимский, Луиш Энрике ди Фигейреду (Luiz Henrique de Figueiredo) и Валдемар Селиш (Waldemar Celes). Lua распространяется свободно, с открытыми исходными текстами на языке Си.

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

Как пишет автор языка в The Evolution of Lua:[6]

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

Lua 1.0 была спроектирована таким образом, что её конструкторы объектов, тогда чуть отличающиеся от текущего лёгкого и гибкого стиля, включали в себя синтаксис языка SOL (отсюда название Lua: по-португальски sol — «солнце», lua — «луна»). Управляющие конструкции Lua в основном заимствованы из Modula (if, while, repeat/until), хотя на них также повлияли CLU (параллельное присваивание, множественное возвращаемое значение функции как более простая альтернатива вместо передачи параметров по ссылке или явных указателей), C++ («отличная идея объявлять локальные переменные лишь тогда, когда они нужны»), SNOBOL и AWK (ассоциативные массивы). Создатели Lua также признают, что единый вездесущий механизм структурирования данных в LISP и Scheme (связный список) оказал большое влияние на их решение о выборе таблиц в качестве основной структуры данных для Lua.[7]

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

Общая характеристика[править | править код]

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

Так, в Lua отсутствует явная поддержка наследования, однако оно легко реализуется с помощью метатаблиц.

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

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

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

Синтаксис[править | править код]

Синтаксис Lua в основном построен на основе поздних паскалеподобных языков, таких как Модула-2 или Оберон. Формат записи текста - свободный, команды в тексте программы разделяются любыми пробельными символами. Допускается, но не является обязательным применение точки с запятой для разделения операций.

Лексика[править | править код]

Основной алфавит языка — английский, в строковых литералах допускается использование символов других языков. Идентификаторы могут состоять из букв, цифр и знака подчёркивания, но не могут начинаться с цифры или совпадать с одним из ключевых слов. Руководство по языку не рекомендует использовать идентификаторы, начинающиеся с подчёркивания, так как такие идентификаторы используются для системных целей.

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

В Lua 22 ключевых слова.

Комментарии[править | править код]

Для комментариев используется следующий синтаксис, близкий к языкам Ada, SQL и VHDL:

-- Простой однострочный комментарий в Lua начинаются с двойного дефиса и продолжается до конца строки.

dim = { "one", "two", "three" } -- Строчный комментарий не обязан начинаться с начала строки, 
                                -- он может следовать за другими языковыми конструкциями,
                                -- поясняя их.

--[[Многострочный комментарий начинается с идущих подряд за двумя минусами двух открывающихся квадратных скобок
  и продолжается до двух подряд закрывающихся квадратных скобок. Как здесь: ]] 

-- Интересный эффект можно получить сочетанием строчных и многострочных комментариев: 

--[[ Чтобы раскомментировать код ниже, достаточно добавить в этой строке пробел между минусами и скобками.
for i=1,#dim do
  print(dim[i])
end
-- Если выше между минусами и скобками будет добавлен пробел, то 
--]] -- здесь конец многострочного комментария превратится в обычный строчный

Типы данных[править | править код]

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

В Lua восемь основных типов:

  • nil (неопределенный)
  • boolean (логический)
  • number (числовой)
  • string (строковый)
  • function (функция)
  • userdata (пользовательские данные)
  • thread (поток)
  • table (таблица)

nil — это тип значения nil [пустое значение], главное свойство которого — отличаться от всех остальных значений и обозначать отсутствие пригодного значения. К типу boolean относятся значения false (ложь) и true (истина).

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

Тип string обозначает массивы символов. Строки Lua могут содержать любые 8-битные символы, включая ноль ('\0'). Строки неизменяемы. Строковые литералы могут записываться в одинарных или двойных кавычках, служебные символы помещаются в них в стандартной для C нотации с ведущим обратным слэшем. Многострочные литералы ограничиваются двумя подряд открывающимися и двумя подряд закрывающимися квадратными скобками.

Встроенная в язык поддержка Юникода отсутствует, хотя допускается использование символов UTF-8 в строковых литералах, а сама система представления UTF-8 позволяет вводить, выводить и частично обрабатывать строки в этой кодировке стандартными системными средствами. В последние версии Lua входит библиотека utf8, обеспечивающая более развитую поддержку UTF-8, существуют также библиотеки сторонних разработчиков, предоставляющие средства работы с Юникод-строками в различных кодировках.

Функции в Lua являются полноправными объектами, допускающими присваивание, передачу в функцию в параметре и возврат из функции как одного из значений. Тип thread имеют сопрограммы, тип userdata предназначен для представления внешних данных, полученных или предоставляемых из/в код на другом языке (главным образом, на C/C++).

Операции[править | править код]

Присваивание
Оператором присваивания служит символ =. Подобно таким скриптовым языкам, как Perl, Python, Ruby и Icon, допускает параллельное присваивание. В простейшем случае это позволяет писать выражения вида:
  x, y = y, x
В отличие, например, от языка Go, параллельное присваивание в Lua очень либерально, оно не требует точного соответствия числа переменных числу значений. Если значений больше, чем переменных, то последние значения отбрасываются, если значений меньше — последние переменные в списке получают значение nil.
Сравнения и логические операторы
Операторы сравнения: <, >, <=, >=, ==, ~= (последние два означают, соответственно, сравнение на равенство и на неравенство). Сравнения на равенство и неравенство применимы к любым типам данных, прочие — только к строкам и числам.
Логические операторы: and, or, not — логические «и», «или» и «не», соответственно, могут применяться к значениям любых типов и возвращают true либо false. В параметрах этих операция значения nil и false считаются ложными, любые другие значения — истинными. В отличие от C и ряда других языков, даже числовой нуль (0) или пустая строка ("") с точки зрения логических операторов представляют значение «истина». Вычисление бинарных логических операторов традиционно выполняется до тех пор, пока результат не будет определён, причём в качестве результата возвращается последнее вычисленное подвыражение. Поэтому их можно использовать как тернарный оператор ?: в языке Си:
-- аналогично r = ( a < b)? f(a) : f(b); в Си, 
r = ( a < b ) and f(a) or f(b)
-- r получит значение функции f() от меньшего из двух значений: a и b,
-- при условии, что f(a) не равно nil или false.
Арифметические операторы
+ — сложение;
- — вычитание;
* — умножение;
/ — деление;
- — унарный минус;
% — остаток от деления;
^ — возведение в степень.

Все арифметические операторы поддерживают вещественные операторы, давая предсказуемый результат. Так, x^0.5 возвращает квадратный корень из x, x^(-1/3) — значение, обратное кубическому корню из x. Оператор % определяется выражением: a % b = a - math.floor(a / b) * b, где функция math.floor() вычисляет целую часть своего аргумента. Для целых аргументов его результат вполне обычен. Для вещественного делимого нужно учитывать, что операция не производит никаких дополнительных округлений или отбрасывания дробной части, поэтому результат сохранит дробную часть делимого. Например, math.pi % 2 вернёт не 1, а 1.1415926535898. Такая реализация даёт некоторые дополнительные возможности. Например, для усечения x до трёх знаков после запятой достаточно взять выражение x - x % 0.001

Таблицы[править | править код]

Таблица в Lua — это динамический гетерогенный ассоциативный массив, то есть множество пар «ключ-значение». Ключами могут быть значения любых типов Lua, кроме nil. Ключи также могут быть литералами (идентификаторами) Lua. Запись nil в элемент таблицы равносильна удалению данного элемента.

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

-- Таблица общего вида:
empty = {} -- Пустая таблица
empty[1] = "первый"        -- Добавление элемента с целым индексом
empty[3] = "второй"        -- Добавление элемента с целым индексом
empty["третий"] = "третий" -- Добавление элемента со строковым индексом
empty[1] = nil             -- Удаление элемента из таблицы  

-- Классический массив - строки индексируются по умолчанию целыми числами, начиная с 1
days1 = {"понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"}

-- Массив с произвольной индексацией
days2 = {[0]="воскресенье", [1]="понедельник", [2]="вторник", [3]="среда", [4]="четверг", [5]="пятница", [6]="суббота"}

-- Запись (структура) - значения различных типов индексируются литералами
person = {tabnum = 123342,                   -- Табельный номер
          fio = "Иванов Степан Васильевич",  -- Ф.И.О.
          post = "слесарь-инструментальщик", -- Должность
          salary = 25800.45,                 -- Оклад
          sdate = "23.10.2013",              -- Дата приёма на работу
          bdate = "08.08.1973"}              -- Дата рождения 

pfio = person.fio --Обращение к элементу структуры.

-- Множество - индексы используются для хранения значений
workDays = {["понедельник"]=true, ["вторник"]=true, ["среда"]=true, ["четверг"]=true, ["пятница"]=true}
workDays["суббота"] = true -- Добавление субботы в число рабочих дней
workDays["среда"] = nil    -- По средам больше не работаем

-- Проверка, является ли d рабочим днём
if workDays[d] then 
  print (d.." - рабочий день")
else
  print (d.." - выходной день")
end

Мультимножества (множества, которые могут содержать более одного экземпляра одного и того же элемента) реализуются аналогично последнему примеру, только в качестве значений используются не логические, а целые — счётчики числа соответствующих элементов в множестве. Связанные списки могут быть представлены как массивы двухэлементных массивов, хранящих значение и ссылку на следующий элемент. Многомерные массивы могут быть реализованы как массивы массивов. Более сложные структуры, такие как очереди, графы, сети также реализуются на основе таблиц, конкретный способ реализации определяется задачей.

Замыкания[править | править код]

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

function makeaddfunc(x)
  -- Возвращает новую анонимную функцию, которая добавляет x к аргументу
  return function(y)
    -- Когда мы ссылаемся на переменную x, которая вне текущей области,
    -- и время жизни которой меньше, чем этой анонимной функции, 
    -- Lua создаёт замыкание.
    return x + y
  end
end
plustwo = makeaddfunc(2)
print(plustwo(5)) -- Выводит 7

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

Примеры кода[править | править код]

Классическая программа «Hello, world!» на Lua выглядит так:

print("Hello World!")

Факториал — пример рекурсивной функции:

function factorial(n)
  if n == 0 then
    return 1
  else
    return n * factorial(n - 1)
  end
end

Цикл со счётчиком:

for i = 1,5 do
     -- Statements
end

Работа с функциями как с объектами первого класса демонстрируется в следующем примере, в котором модифицируется поведение функции print:

do
  local oldprint = print   -- Сохраняем текущую функцию print как oldprint
  function print(s)        -- Переопределяем функцию print
    if s == "foo" then
      oldprint("bar")
    else
      oldprint(s)
    end
  end
end

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

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

fibs = { 1, 1 } -- Первоначальные значения для fibs[1] и fibs[2].
setmetatable(fibs, { 
  __index = function(name, n)            -- Вызов функции, если fibs[n] не существует.
    name[n] = name[n - 1] + name[n - 2]  -- Расчёт и мемоизация fibs[n].
    return name[n]                       
  end
})

Реализация[править | править код]

Как и многие интерпретируемые языки программирования, реализация Lua имеет отдельно компилятор с исходного языка в исполняемый байт-код и виртуальную машину для исполнения сгенерированного байт-кода. Причём байт-код — это не команды стековой машины, а команды некоего виртуального процессора с несколькими регистрами, что повышает эффективность исполнения. В стандартной виртуальной машине Lua используется распределение памяти со сборкой мусора (аналогично Java или .NET).

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

Для задач, критичных по времени, имеется JIT-компилятор Lua — LuaJIT[8]. Также разработан компилятор llvm-lua[9], генерирующий код для виртуальной машины LLVM, предоставляющей возможность последующей компиляции в очень эффективный машинный код для процессоров различной архитектуры.

Использование[править | править код]

В настоящее время используется в различных проектах, где требуется встроить достаточно быстрый и нетрудный в освоении скриптовый язык программирования — например, в разработке игр, где Lua часто используется в качестве прослойки между игровым движком и данными для написания сценариев поведения/взаимодействия объектов.

Игры[править | править код]

Первыми в разработку компьютерных игр язык Lua внедрила компания LucasArts, начиная с игры Grim Fandango[10]. Авторы языка в своём докладе на конференции HOPL (англ.) вспоминают, что в январе 1997 они получили сообщение от Брета Могилефски, главного разработчика Grim Fandango, где он писал, что, прочитав о языке в статье 1996 года в Dr. Dobb’s Journal, он планирует заменить используемый ими самодельный скриптовый язык SCUMM на Lua[11]. В результате им был создан игровой движок GrimE, используемый также более поздним квестом от LucasArts — Escape from Monkey Island.

В 2003 году в результате опроса на сайте GameDev.net Lua был признан самым популярным скриптовым языком для разработки игр[12].

Примером игры, программируемой с помощью Lua, является World of Warcraft[13][14]. На языке Lua описываются уровни игры-головоломки Enigma[15].

Доступен ряд свободных игровых движков, программируемых на Lua, таких, как Defold[16], аркадный движок LÖVE[17][18], игровой конструктор Novashell[19] и ориентированный на квесты (преимущественно — текстовые) INSTEAD[20].

Также используется в авиасимуляторе X-Plane, в движке X-Ray для S.T.A.L.K.E.R[21].

Для популярной игры Minecraft созданы модификации ComputerCraft и его более совершенный аналог OpenComputers, которые добавляют компьютеры, программируемые на языке Lua[22].

Достаточно известная игра Garry's Mod программируется, а также поддерживает модификации написанные на Lua.

Команда Croteam (разработчики Serious Sam и The Talos Principle) используют Lua в скриптах начиная с версии Serious Engine 3.5[23].

IDE[править | править код]

Существует как минимум две «родные» среды разработки для Lua. Это:

  • ZeroBrane Studio[24] — мультиплатформенная среда разработки, написанная на самом Lua.
  • Decoda — среда разработки под Windows, написанная на C++, с богатыми возможностями отладки Lua-скриптов, в том числе в работающих приложениях. На 2018 год последний выпуск среды датируется 2014 годом и имеет статус beta-версии.

Кроме того, Lua поддерживается некоторыми универсальными IDE, в частности:

Существовал модуль поддержки Lua для среды NetBeans, но его развитие прекратилось в 2013 году и он доступен только для версии NetBeans 7.4 и более ранних. В NetBeans 8 плагин не поддерживается.

Примечания[править | править код]

  1. Lua Implementations (англ.). Lua-users wiki. Проверено 18 мая 2009. Архивировано 24 августа 2011 года.
  2. 1 2 https://www.lua.org/about.html
  3. About Lua. Lua.org. Проверено 19 июня 2013.
  4. Why is Lua considered a game language?. Stack Overflow. Проверено 23 апреля 2010. Архивировано 20 августа 2013 года.
  5. The evolution of an extension language: a history of Lua (2001). Проверено 24 августа 2016.
  6. HOPL, 2007, p. 2–1–2–26.
  7. Lua: an Extensible Embedded Language. A few metamechanisms replace a host of features (December 1996), стр. 26–33.
  8. The LuaJIT Project
  9. llvm-lua. JIT/Static compiler for Lua using LLVM on the backend.
  10. Bret Mogilefsky. Lua in Grim Fandango. Проверено 9 декабря 2011. Архивировано 4 февраля 2012 года.
  11. HOPL, 2007, с. 11.
  12. Which language do you use for scripting in your game engine?. GameDev.net — Poll Results
  13. Paul Emmerich. Beginning Lua with World of Warcraft Add-ons. — Apress, July 2009. — ISBN 1430223715.
  14. James Whitehead II, Bryan McLemore, and Matthew Orlando. World of Warcraft Programming. — Wiley, May 2008. — ISBN 0470229810.
  15. Tom Gutschmidt. Ch. 8. The Lua Game Community → Game Engines // Game Programming with Python, Lua, and Ruby. — Premier Press, 2003. — 472 p. — ISBN 1-59200-079-7.
  16. Defold game development manual - Lua in Defold. Defold game engine. Проверено 2 марта 2017.
  17. Dj Walker-Morgan. The H Speed Guide to Lua → Developing with Lua. The H (17 April 2012). Проверено 26 февраля 2015.
  18. Darmie Akinlaja. LÖVE for Lua Game Programming. — Packt, 2013. — 106 p. — ISBN 978-1-78216-160-8.
  19. Alan Thorn. Chapter 8. Novashell and 2D Games // Cross Platform Game Development. — Jones & Bartlett Learning, 2008. — P. 225-264. — 421 p. — ISBN 978-1-59822-056-8.
  20. Пётр Косых INSTEAD: Как все начиналось // IFPrint.org. — Март 18, 2013. — Вып. 1. — ISSN 2307-535X.
  21. Ronnie Tucker. Full Circle Magazine #90: THE INDEPENDENT MAGAZINE FOR THE UBUNTU LINUX COMMUNITY. — Full Circle Magazine, 2014-10-31. — 50 с.
  22. Matthew Monk, Simon Monk. ComputerCraft: Lua Programming in Minecraft. — CreateSpace Independent Publishing Platform, 2013-01-28. — 58 с. — ISBN 9781481927659.
  23. Zero_Cool. История технологий - Serious Engine | History | Тест GPU. gamegpu.com. Проверено 10 апреля 2016.
  24. ZeroBrane Studio — Lua IDE/editor/debugger for Windows, Mac OSX, and Linux
  25. Lua Development Tools

Литература[править | править код]

  • Роберто Иерузалимски. Программирование на языке Lua. — 3-е изд.. — ДМК, 2014. — ISBN 9785940747673. (оригинал: Roberto Ierusalimschy. Programming in Lua. — 3-nd ed.. — 2012. — ISBN 9788590379850.)
  • Ian Dees. Lua // Seven More Languages in Seven Weeks. Languages That Are Shaping the Future / Bruce Tate, Fred Daoud, Jack Moffitt, Ian Dees. — The Pragmatic Bookshelf, 2015. — С. 1-48. — 320 с. — ISBN 978-1941222157.
  • Mário Kašuba. Lua Game Development Cookbook. — Packt Publishing, 2015. — 402 с. — ISBN 978-1849515504.
  • David Young. Learning Game AI Programming with Lua. — Packt Publishing, 2014. — 352 с. — ISBN 978-1783281336.
  • Jayant Varma. Learn Lua for iOS Game Development. — Apress, 2012. — 410 с. — ISBN 9781430246626.
  • Kurt Jung, Aaron Brown. Beginning Lua Programming. — John Wiley & Sons, 2011. — 675 с. — (Programmer to Programmer). — ISBN 9781118079119.
История языка

Ссылки[править | править код]

Lua-проекты
  • Kepler Project team — Платформа веб-разработки под Lua (англ.)
  • LuaGL — интерфейс к OpenGL для Lua 5.1
  • LuaFAR — движок Lua-плагинов и скриптов для файлового менеджера

Lua на русском[править | править код]

Переводы руководств
Статьи и обзоры