Lua (язык программирования) - Lua (programming language)

Lua

Парадигма	Мультипарадигма: сценарии, императив (процедурный, на основе прототипа, объектно-ориентированный ), функциональный
Разработано	Роберто Иерусалимши Вальдемар Селес Луис Энрике де Фигейредо
Впервые появился	1993; 27 лет назад (1993)
Стабильный выпуск	5.4.1 / 9 октября 2020; 55 дней назад (2020-10-09)
Печатная дисциплина	Динамический, сильный, утка
Язык реализации	ANSI C
Операционные системы	Кроссплатформенность
Лицензия	Лицензия MIT
Расширения имени файла	.lua
Интернет сайт	www.lua.org
Главный реализации
Lua, LuaJIT, LuaVela
Диалекты
Metalua, Холостой ход, GSL Shell, Луау
Под влиянием
C ++, CLU, Modula, Схема, СНОБОЛ
Под влиянием
GameMonkey, Ио, JavaScript, Юля, MiniD, Красный, Кольцо,[1] Рубин, Белка, MoonScript, C--

Lua (/ˈлuə/ LOO-ə; от португальский: lua [ˈLu. (W) ɐ] смысл Луна )^[а] это легкий, высокий уровень, язык программирования с несколькими парадигмами предназначен в первую очередь для встроенное использование в приложениях.^[2] Lua - это кросс-платформенный, поскольку переводчик из составлен байт-код написано в ANSI C,^[3] и Lua имеет относительно простой C API встраивать его в приложения.^[4]

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

История

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

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

Предшественниками Lua были языки описания / конфигурации данных. СОЛЬ (Простой объектный язык) и DEL (язык ввода данных).^[6] Они были независимо разработаны в Tecgraf в 1992–1993 годах, чтобы добавить некоторую гибкость в два разных проекта (оба были интерактивными графическими программами для инженерных приложений в Petrobras Компания). В SOL и DEL отсутствовали какие-либо структуры управления потоком, и Petrobras чувствовала растущую потребность в добавлении к ним полной мощности программирования.

В Эволюция Lua, авторы языка написали:^[5]

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

Lua 1.0 был разработан таким образом, что его конструкторы объектов, немного отличавшиеся от текущего легкого и гибкого стиля, включали синтаксис описания данных SOL (отсюда и название Lua: Sol также Португальское слово для "Солнца", Lua слово для "Луны"). Lua синтаксис для управляющих структур в основном заимствовано из Modula (если, в то время как, повторение/до тех пор), но также испытали влияние CLU (несколько назначений и несколько возвратов из вызовов функций, как более простая альтернатива справочные параметры или явный указатели ), C ++ ("отличная идея разрешить локальная переменная быть объявленным только там, где нам это нужно "^[5]), СНОБОЛ и AWK (ассоциативные массивы ). В статье, опубликованной в Журнал доктора Добба, Создатели Lua также заявляют, что LISP и Схема с их единым, повсеместным механизмом структуры данных ( список ) оказали большое влияние на их решение разработать таблицу в качестве основной структуры данных Lua.^[7]

Lua семантика с течением времени находились под все большим влиянием Scheme,^[5] особенно с введением анонимные функции и полный лексическая область видимости. В новых версиях Lua добавлено несколько функций.

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

особенности

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

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

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

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

Синтаксис

Классический "Привет мир!" программа можно записать так:^[8]

Распечатать("Привет мир!")

или как:

Распечатать 'Привет мир!'

А комментарий в Lua начинается с двойногодефис и доходит до конца строки, аналогично Ада, Эйфель, Haskell, SQL и VHDL. Многострочные строки и комментарии заключаются в двойные квадратные скобки.

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

функция факториал(п)  местный Икс = 1  для я = 2, п делать    Икс = Икс * я  конец  вернуть Иксконец

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

Lua имеет четыре типа петли: the в то время как петля, то повторение петля (похожа на делать пока петля ) числовой для петля, а общий для петля.

--condition = trueв то время как состояние делать  --заявленияконецповторение  --заявлениядо тех пор состояниедля я = первый, последний, дельта делать  --delta может быть отрицательным, позволяя циклу for обратный или восходящий отсчет  --заявления  --пример: print (i)конец

Общий для цикл:

для ключ, ценность в пары(_Г) делать  Распечатать(ключ, ценность)конец

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

Вы также можете выполнить вложенный цикл, который является циклом внутри другого цикла.

местный сетка = {  { 11, 12, 13 },  { 21, 22, 23 },  { 31, 32, 33 }}для у, ряд в ipairs(сетка) делать  для Икс, ценность в ipairs(ряд) делать    Распечатать(Икс, у, сетка[у][Икс])  конецконец

Функции

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

делать  местный старая печать = Распечатать  - Сохранить текущую функцию печати как oldprint  функция Распечатать(s)    - [[Переопределить функцию печати. Обычная функция печати все еще может быть использована      через oldprint. У нового только один аргумент.]]    старая печать(s == "фу" и "бар" или s)  конецконец

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

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

функция добавить в(Икс)  - Вернуть новую функцию, которая добавляет x к аргументу  вернуть функция(у)    - [= [Когда мы ссылаемся на переменную x, которая находится за пределами текущего      область и время жизни которого будет короче, чем у этого анонимного      функция, Lua создает закрытие.] =]    вернуть Икс + у  конецконецFourplus = добавить в(4)Распечатать(Fourplus(3))  - Отпечатки 7- Этого также можно добиться, вызвав функцию следующим образом:Распечатать(добавить в(4)(3))- [[Это потому, что мы вызываем возвращаемую функцию из addto (4) напрямую с аргументом «3».  Это также помогает снизить стоимость данных и повысить производительность при итеративном вызове.]]

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

Столы

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

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

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

стол = {} - Создает новую пустую таблицу

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

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

стол = {Икс = 10}  - Создает новую таблицу с одной записью, отображающей "x" на число 10.Распечатать(стол["Икс"]) - Печатает значение, связанное со строковым ключом, в данном случае 10.b_table = столb_table["Икс"] = 20   - Значение в таблице изменено на 20.Распечатать(b_table["Икс"]) - Печать 20.Распечатать(стол["Икс"]) - Также выводит 20, потому что a_table и b_table относятся к одной и той же таблице.

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

точка = { Икс = 10, у = 20 }   - Создать новую таблицуРаспечатать(точка["Икс"])            - Отпечатков 10Распечатать(точка.Икс)               - Имеет то же значение, что и строка выше. Более легкая для чтения запись с точкой - это просто синтаксический сахар.

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

Точка = {}Точка.новый = функция(Икс, у)  вернуть {Икс = Икс, у = у}  - вернуть {["x"] = x, ["y"] = y}конецТочка.set_x = функция(точка, Икс)  точка.Икс = Икс  - точка ["x"] = x;конец

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

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

массив = { "а", "б", "c", "d" }   - Индексы присваиваются автоматически.Распечатать(массив[2])                  - Отпечатки «b». Автоматическое индексирование в Lua начинается с 1.Распечатать(#массив)                    - Печатает 4. # - оператор длины для таблиц и строк.массив[0] = "z"                   - Ноль - это юридический индекс.Распечатать(#массив)                    - По-прежнему печатает 4, поскольку массивы Lua начинаются с 1.

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

ExampleTable ={  {1, 2, 3, 4},  {5, 6, 7, 8}}Распечатать(ExampleTable[1][3]) - Отпечатки «3»Распечатать(ExampleTable[2][4]) - Отпечатки «8»

Таблица может быть массивом объектов.

функция Точка(Икс, у)        - Конструктор объекта "Точка"  вернуть { Икс = Икс, у = у }   - Создает и возвращает новый объект (таблицу)конецмассив = { Точка(10, 20), Точка(30, 40), Точка(50, 60) }   - Создает массив точек                        - массив = {{x = 10, y = 20}, {x = 30, y = 40}, {x = 50, y = 60}};Распечатать(массив[2].у)                                         - Отпечатки 40

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

Метатаблицы

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

выдумки = { 1, 1 }                                - Начальные значения для fibs [1] и fibs [2].setmetatable(выдумки, {  __показатель = функция(ценности, п)                - [[__ index - это функция, предопределенная Lua,                                                    он вызывается, если ключ "n" не существует.]]    ценности[п] = ценности[п - 1] + ценности[п - 2]  - Вычислить и запомнить выдумки [n].    вернуть ценности[п]  конец})

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

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

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

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

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

местный Вектор = {}Вектор.__показатель = Векторфункция Вектор:новый(Икс, у, z)    - Конструктор  вернуть setmetatable({Икс = Икс, у = у, z = z}, Вектор)конецфункция Вектор:величина()     - Другой метод  - Ссылка на неявный объект, используя self  вернуть math.sqrt(я.Икс^2 + я.у^2 + я.z^2)конецместный vec = Вектор:новый(0, 1, 0) - Создайте векторРаспечатать(vec:величина())          - Вызвать метод (вывод: 1)Распечатать(vec.Икс)                    - Доступ к переменной-члену (вывод: 0)

Реализация

Программы Lua не интерпретированный непосредственно из текстового файла Lua, но составлен в байт-код, который затем запускается на Lua виртуальная машина. Процесс компиляции обычно невидим для пользователя и выполняется во время время выполнения, но это можно сделать в автономном режиме, чтобы повысить производительность загрузки или уменьшить объем памяти, занимаемый средой хоста, за счет исключения компилятора. Байт-код Lua также может быть создан и выполнен изнутри Lua, используя свалка функция из строковой библиотеки и загрузка / loadstring / loadfile функции. Lua версии 5.3.4 реализован примерно в 24 000 строк кода C.^[2][3]

Как и большинство процессоров, и в отличие от большинства виртуальных машин (которые на основе стека ), виртуальная машина Lua регистровый, и поэтому больше напоминает реальную конструкцию оборудования. Архитектура регистров позволяет избежать чрезмерного копирования значений и сократить общее количество инструкций на функцию. Виртуальная машина Lua 5 - одна из первых чистых виртуальных машин на основе регистров, получивших широкое распространение.^[12] Попугай и Android с Дальвик две другие известные виртуальные машины на основе регистров. Виртуальная машина PCScheme также была основана на регистрах.^[13]

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

function  (9 инструкций, 36 байтов в 0x8063c60) 1 параметр, 6 слотов, 0 повышающих значений, 6 локальных переменных, 2 константы, 0 функций 1 [2] LOADK 1 -1; 1 2 [3] LOADK 2 -2; 2 3 [3] ПЕРЕМЕЩЕНИЕ 3 0 4 [3] НАГРУЗКА 4 -1; 1 5 [3] FORPREP 2 1; на 7 6 [4] MUL 1 1 5 7 [3] FORLOOP 2 -2; на 6 8 [6] ВОЗВРАТ 1 2 9 [7] ВОЗВРАТ 0 1

C API

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

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

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

#включают <stdio.h>#включают  // основная библиотека Lua (lua_ *)#включают  // Вспомогательная библиотека Lua (luaL_ *)int основной(пустота){    // создаем состояние Lua    lua_State *L = luaL_newstate();    // загружаем и выполняем строку    если (luaL_dostring(L, "функция foo (x, y) возвращает x + y конец")) {        lua_close(L);        вернуть -1;    }    // вставляем значение глобального "foo" (функция, определенная выше)    // в стек, за которым следуют целые числа 5 и 3    lua_getglobal(L, "фу");    lua_pushinteger(L, 5);    lua_pushinteger(L, 3);    lua_call(L, 2, 1); // вызываем функцию с двумя аргументами и одним возвращаемым значением    printf("Результат:% d п", lua_tointeger(L, -1)); // выводим целочисленное значение элемента на вершину стека    lua_pop(L, 1); // возвращаем стек в исходное состояние    lua_close(L); // закрываем состояние Lua    вернуть 0;}

Выполнение этого примера дает:

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

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

Можно писать модули расширения с помощью Lua API. Модули расширения общие объекты который можно использовать для расширения функциональных возможностей интерпретатора, предоставляя собственные возможности сценариям Lua. Со стороны Lua такой модуль выглядит как таблица пространства имен, содержащая его функции и переменные. Скрипты Lua могут загружать модули расширения, используя требовать,^[15] точно так же, как модули, написанные на самом Lua. Растущая коллекция модулей, известных как горные породы доступны через система управления пакетами называется LuaRocks,^[17] в духе CPAN, RubyGems и Яйца питона. Предварительно написанный Lua привязки существуют для большинства популярных языков программирования, включая другие языки сценариев.^[18] Для C ++ существует ряд подходов на основе шаблонов и несколько генераторов автоматической привязки.

Приложения

В разработка видеоигр, Lua широко используется как язык сценариев от программисты, в основном из-за кажущейся легкости встраивания, быстрого выполнения и коротких кривая обучения.^[19] Он часто используется для управления объектами и элементами, которые игроки видят в игре.^[20]

В 2003 году опрос, проведенный GameDev.net, показал, что Lua был самым популярным языком сценариев для программирования игр.^[21] 12 января 2012 года Lua был объявлен победителем Front Line Award 2011 от журнала. Разработчик игр в категории Инструменты программирования.^[22]

Большое количество неигровых приложений также используют Lua для расширения, например LuaTeX, реализация TeX наборный язык, Redis, а база данных ключ-значение, Неовим, текстовый редактор и Nginx, а веб сервер.

Благодаря расширению Scribunto Lua доступен как язык сценариев на стороне сервера в MediaWiki программное обеспечение, которое поддерживает Википедия и другие вики.^{[23][24][циркулярная ссылка ]} Среди его применений - возможность интеграции данных из Викиданные в статьи,^[25] и питание автоматизированная система такси.

Языки, компилируемые в Lua

• Moonscript - это динамичный, пробел -чувствительный язык сценариев вдохновленный CoffeeScript, который компилирует в Lua. Это означает, что вместо использования делать и конец (или { и }) для разделения частей кода, которые он использует разрывы строк и стиль отступа.^[26][27][28] Заметным использованием MoonScript является сайт распространения видеоигр. Itch.io.
• Фенхель.^[28]
• Урна.^[28]
• Амулет ML.^[28]

Смотрите также

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

Заметки

использованная литература

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

• Иерусалимский Р. (2013). Программирование на Lua (3-е изд.). Lua.org. ISBN  978-85-903798-5-0. (Имеется 1-е изд. онлайн.)
• Гучмидт, Т. (2003). Программирование игр с помощью Python, Lua и Ruby. Курс Технологии PTR. ISBN  978-1-59200-077-7.
• Schuytema, P .; Маньен, М. (2005). Разработка игр с Lua. Чарльз Ривер Медиа. ISBN  978-1-58450-404-7.
• Юнг, К .; Браун, А. (2007). Начало программирования на Lua. Wrox Press. ISBN  978-0-470-06917-2. Архивировано из оригинал 8 июля 2018 г.. Получено 7 июля 2018.
• Figueiredo, L.H .; Celes, W .; Иерусалимский Р., ред. (2008). Жемчужины программирования Lua. Lua.org. ISBN  978-85-903798-4-3.
• Тахтеев, Юрий (2012). Coding Places: практика программного обеспечения в южноамериканском городе. MIT Press. ISBN  978-0-262-01807-4. Архивировано из оригинал 2 ноября 2012 г. Главы 6 и 7 посвящены Lua, в то время как другие рассматривают программное обеспечение в Бразилии более широко.
• Варма, Джаянт (2012). Изучите Lua для разработки игр для iOS. Apress. ISBN  978-1-4302-4662-6.
• Мэтисон, Эш (29 апреля 2003 г.). "Введение в Lua". GameDev.net. Архивировано из оригинал 18 декабря 2012 г.. Получено 3 января 2013.
• Филдхаус, Кейт (16 февраля 2006 г.). "Представляем Lua". ONLamp.com. O'Reilly Media. Архивировано из оригинал 12 марта 2006 г.. Получено 28 февраля 2006.
• Штрайхер, Мартин (28 апреля 2006 г.). «Встраиваемые сценарии с Lua». developerWorks. IBM.
• Куигли, Джозеф (1 июня 2007 г.). "Взгляд на Lua". Linux журнал.
• Гамильтон, Наоми (11 сентября 2008 г.). "Азбука языков программирования: Lua". Computerworld. IDG. Архивировано из оригинал 8 июля 2018 г.. Получено 7 июля 2018. Интервью с Роберто Иерусалимши.
• Иерусалимский, Роберто; де Фигейредо, Луис Энрике; Селес, Вальдемар (12 мая 2011 г.). «Прохождение языка через игольное ушко». Очередь ACM. 9 (5): 20–29. Дои:10.1145/1978862.1983083. S2CID  19484689. Архивировано из оригинал 8 июля 2018 г.. Получено 7 июля 2018. Как встраиваемость Lua повлияла на его дизайн.
• Иерусалимский, Роберто; де Фигейредо, Луис Энрике; Селес, Вальдемар (ноябрь 2018 г.). «Взгляд на дизайн Lua». Коммуникации ACM. 61 (11): 114–123. Дои:10.1145/3186277. S2CID  53114923.^{[постоянная мертвая ссылка ]}
• Статьи и тезисы Lua

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

• Официальный веб-сайт
• Пользователи Lua, Сообщество
• Проекты на Lua
• Форум Lua