Lua
Lua (лу́а, с порт. — «луна»[9]) — скриптовый язык программирования, разработанный в подразделении Tecgraf (Computer Graphics Technology Group) Католического университета Рио-де-Жанейро[англ.] (Бразилия). Интерпретатор языка является свободно распространяемым, с открытым исходным кодом на языке программирования Си. По идеологии и реализации язык Lua ближе всего к JavaScript, в частности, он также реализует прототипную модель ООП, но отличается Паскале-подобным синтаксисом и более мощными и гибкими конструкциями. Характерной особенностью Lua является реализация большого числа программных сущностей минимумом синтаксических средств. Так, все составные пользовательские типы данных (массивы, структуры, множества, очереди, списки) реализуются через механизм таблиц, а механизмы объектно-ориентированного программирования, включая множественное наследование — с использованием метатаблиц, которые также отвечают за перегрузку операций и ряд других возможностей. Lua предназначен для пользователей, не являющихся профессиональными программистами, вследствие чего большое внимание уделено простоте дизайна и лёгкости обучения. Язык широко используется для создания тиражируемого программного обеспечения (например, на нём написан графический интерфейс пакета Adobe Lightroom). Также получил известность как язык программирования уровней и расширений во многих играх[10], в том числе Garry’s Mod, Roblox, Minetest. ИсторияЯзык разработан подразделением Tecgraf (группа технологий компьютерной графики) Католического университета Рио-де-Жанейро в Бразилии, история языка ведёт отсчёт с 1993 года. Авторы языка — Роберту Иерузалимски, Луиш Энрике ди Фигейреду (Luiz Henrique de Figueiredo) и Валдемар Селиш (Waldemar Celes). Lua распространяется свободно, с открытым исходным кодом на языке Си. Как отметил Луиш Энрике ди Фигейреду, Lua — единственный язык программирования, разработанный в развивающейся стране и получивший всемирное признание, которое, в частности, выразилось в приглашении на конференцию HOPL[англ.][11]. Историческими родителями языка были языки конфигурирования и описания данных SOL (Simple Object Language) и DEL (Data-Entry Language)[12], они были независимо разработаны в Tecgraf в 1992—1993 годах для добавления некоторой гибкости в два отдельных проекта (оба были интерактивными графическими приложениями для конструкторских нужд в компании Petrobras). В SOL и DEL отсутствовали какие-либо управляющие конструкции, и Petrobras чувствовал растущую необходимость в добавлении к ним полноценного программирования. Как пишет автор языка в The Evolution of Lua:[13]
Lua 1.0 была спроектирован таким образом, что конструкторы объектов, тогда чуть отличавшиеся от текущего лёгкого и гибкого стиля, включали в себя синтаксис языка SOL (отсюда название Lua: по-португальски sol — «солнце», lua — «луна»). Управляющие конструкции Lua в основном заимствованы из Модулы-2 (if, while, repeat/until), хотя на них также повлияли Клу (параллельное присваивание, множественное возвращаемое значение функции как более простая альтернатива вместо передачи параметров по ссылке или явных указателей), C++ («отличная идея объявлять локальные переменные лишь тогда, когда они нужны»), Снобол и awk (ассоциативные массивы). Создатели Lua также признают, что единый вездесущий механизм структурирования данных в Лиспе и Scheme (связный список) оказал большое влияние на их решение о выборе таблиц в качестве основной структуры данных для Lua[14]. Версии Lua вплоть до 5.0 выпускались под лицензией, подобной лицензии BSD. Начиная с версии 5.0 и выше Lua распространяется под лицензией MIT. Обе лицензии являются разрешительными и практически идентичны. Общая характеристикаЯзык предназначен для использования в качестве отдельного либо встроенного в приложение скриптового языка. Он изначально создавался достаточно простым и компактным, чтобы поместиться на различных платформах и обеспечить приемлемую производительность. Также при проектировании учитывались требования простоты обучения и возможности использования не профессиональными программистами. Lua — это процедурный динамически типизированный модульный язык с автоматическим управлением памятью. Включает базовые элементы для поддержки функционального и объектного стилей программирования. Таким образом, язык можно cчитать мультипарадигменным. Встроенные средства параллельного программирования позволяют писать многопоточные программы только средствами языка, не обращаясь к API операционной системы или внешним библиотекам. Так как основным назначением Lua является встраивание, он имеет эффективные средства межъязыкового взаимодействия, ориентированные, главным образом, на вызов библиотек Си и на работу в Си-окружении. Язык поддерживает небольшое количество встроенных типов данных: логические значения, числа, строки, функции, потоки. Типичные комбинированные структуры данных, такие как массивы, наборы, списки и записи, отсутствуют, вместо всех их используется одна базовая структура Lua — таблица (см. ниже). Отдельный тип Вообще, Lua стремится обеспечить гибкие метафункции, которые могут быть расширены по мере необходимости, а не поставлять набор функций, специфичных для конкретной парадигмы программирования. Как результат, основа языка проста и легко адаптируема к большинству приложений. Предоставляя минимальный набор базовых средств, Lua пытается найти баланс между мощностью и размером. СинтаксисСинтаксис Lua в основном построен на основе поздних Паскале-подобных языков, таких как Модула-2 или Оберон. Формат записи текста — свободный, команды в тексте программы разделяются любыми пробельными символами. Допускается, но не является обязательным применение точки с запятой для разделения операций. В одном из интервью Роберту Иерузалимски заметил, что синтаксис Lua — это компромиссное решение, которое он был вынужден принять, чтобы упростить освоение языка непрофессиональными программистами. Он охарактеризовал этот синтаксис как «довольно многословный», отметив, что лично для себя предпочёл бы более краткую нотацию[11]. ЛексикаОсновным алфавитом языка является английский, и в строковых литералах допускаются знаки других языков, идентификаторы которых могут состоять из букв, цифр и знаков подчеркивания, но они не могут начинаться с цифры или совпадать с одним из ключевых слов. В языковом руководстве не рекомендуется использовать идентификаторы, начинающиеся со знака подчеркивания, поскольку такие идентификаторы используются в систематических целях. Язык регистрозависимый, все ключевые слова пишутся в нижнем регистре, идентификаторы, различающиеся только регистром букв, считаются различными. Следующие 22 ключевых слова не могут быть использованы для имён[15]: and break do else elseif
end false goto for function
if in local nil not
or repeat return then true
until while
КомментарииДля комментариев используется синтаксис, аналогичный реализованному в Аде, SQL и VHDL: -- Простой однострочный комментарий в Lua начинается с двойного минуса и продолжается до конца строки.
dim = { "one", "two", "three" } -- Строчный комментарий не обязан начинаться с начала строки,
-- он может следовать за другими языковыми конструкциями,
-- поясняя их.
--[[Многострочный комментарий начинается с идущих подряд за двумя минусами двух открывающихся квадратных скобок
и продолжается до двух подряд закрывающихся квадратных скобок. Как здесь: ]]
-- Интересный эффект можно получить сочетанием строчных и многострочных комментариев:
--[[ Чтобы раскомментировать код ниже, достаточно добавить в этой строке пробел между минусами и скобками.
for i=1,#dim do
print(dim[i])
end
-- Если выше между минусами и скобками будет добавлен пробел, то
--]] -- здесь конец многострочного комментария превратится в обычный строчный
Типы данныхLua представляет собой язык с неявным динамическим определением типов данных. Переменная языка может содержать значения любого типа. Все значения в Lua могут храниться в переменных, использоваться в качестве аргументов при вызове функций и возвращаться в виде результата их выполнения. В Lua восемь основных типов:
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++). Операции
-- аналогично r = ( a < b)? f(a) : f(b); в Си,
r = ( a < b ) and f(a) or f(b)
-- r получит значение функции f() от меньшего из двух значений: a и b,
-- при условии, что f(a) не равно nil или false.
Все арифметические операторы поддерживают вещественные операнды, давая предсказуемый результат. Так, ТаблицыТаблица в Lua — это динамический гетерогенный ассоциативный массив, то есть множество пар « Таблицы являются единственным в 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) -- т.е plustwo = function(y) return 2 + y end
print(plustwo(5)) -- Выводит 7
Каждый раз, когда вызывается Средства и методы программированияМетатаблицыМеханизм метатаблиц обеспечивает многие возможности, в других языках предоставляемые за счёт введения отдельных синтаксических механизмов. Метатаблицы по структуре являются обычными таблицами Luа, подчиняющимися всем правилам и ограничениям языка. Особенность их состоит в применении. Метатаблица хранит дополнительные метаданные типов и объектов, то есть информацию о параметрах и функциях, связанных с ними. Сведения, хранящиеся в метатаблицах, используются интерпретатором Lua, их использование позволяет изменить или расширить функциональность программных объектов. Метатаблица в Lua может быть связана со значением любого типа. Скалярные типы данных (все, кроме userdata и таблиц) имеют общие метатаблицы для каждого типа. Таблицы и значения типа Созданная «с нуля» таблица Lua не имеет метатаблицы (её ссылка на метатаблицу равна nil). Но метатаблица для неё может быть в любой момент создана либо получена от другой таблицы. Встроенная функция Для метатаблиц документирован набор полей, которые могут использоваться интерпретатором языка. Для указания на особую роль этих полей для них принято специальное правило именования: их идентификаторы начинаются с двух подчёркиваний. Некоторые из таких полей содержат информацию о специфических свойствах объекта, к которому относится метатаблица. Например, параметр --[[ Создание операции сложения для таблиц ]]
-- Операнды
t1 = {1,2,3}
t2 = {10,20,30}
-- Создание метатаблицы
mt = {}
-- Запись в метатаблицу метаметода "__add"
mt.__add = function(a, b)
local res = {}
for k in pairs(a) do res[k] = a[k] + b[k] end
return res
end
-- Привязка метатаблицы к таблице t1
setmetatable(t1, mt)
-- Теперь сложение таблиц - корректная операция
t3 = t1 + t2
-- соединяем с t3 метатаблицу с метаметодом __tostring
setmetatable(t3, {__tostring=function(t)
local res = "\n"
for _,v in pairs(t) do
res = res .. tostring(v) .. "-"
end
return res.."\n"
end})
-- В результате будет выведено: "11-22-33-"
for _,v in ipairs(t3) do
io.write (v,",")
end
print(tostring(t3)) -- выведет "11,22,33,"
В Lua поддерживаются метаметоды для всех арифметических операций и операций сравнения, так что с их помощью можно реализовать арифметику для любых объектов, созданных программистом. Помимо стандартных, можно использовать так называемые «библиотечные» метаметоды, которые поддерживаются не ядром языка, а конкретными библиотеками. В примере выше это метаметод Наибольший интерес представляет поле Объектно-ориентированное программированиеОсновой для ООП в Lua являются таблицы. В принципе, таблица и есть объект в ООП-смысле, так как она может иметь поля, именованные с помощью идентификаторов, и хранить в этих полях произвольные значения (свойства объекта) и функции для реализации поведения объекта (методы объекта). Некоторый синтаксический сахар, предоставляемый Lua, делает описание и обращение с объектами более привычным для программистов, имеющих опыт работы с традиционными ООП-языками. Понятия «класса» в Lua нет, поэтому описывается отдельный объект и все поля и методы относятся именно к нему. Свойства описываются аналогично элементам таблицы с ключами-идентификаторами, методы — как поля-функции. Подобно классическому Оберону, описание методов включает явное указание в первом параметре так называемого «получателя» — параметра, который при вызове метода ссылается на объект, для которого он вызван. Но, помимо стандартного обращения к полю таблицы через точку, которое требует и в вызове метода явно указывать получателя, Lua поддерживает дополнительный синтаксис: когда в вызове или описании метода его заголовок записываются в виде « -- Объект
Account = { -- Объект "счёт"
id, name, balance=0, -- свойства объекта: номер, название, баланс
credit = function (self, v) -- метод "расход" - описание внутри объекта с явным указанием получателя
if self.balance < v then error "Недостаточно денег на счёте" end
self.balance = self.balance - v
end
}
function Account:debet(v) -- метод "приход" - внешнее сокращённое описание (self не указывается)
self.balance = self.balance + v
end
Account.debet(Account, 10000) -- вызов метода - полный вариант
Account:credit(5000) -- вызов метода - сокращённый вариант
Наследование, в том числе множественное, реализуется с помощью метатаблиц и метаметодов. Также с помощью метаметодов можно реализовать сокрытие данных и контролируемый доступ к полям таблицы-объекта. Если сравнивать данный подход с другими языками, где всё вышеперечисленное реализуется с помощью специальных языковых средств, то можно заметить, что реализация 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
-- инструкции/операции
end
Работа с функциями как с объектами первого класса демонстрируется в следующем примере, в котором модифицируется поведение функции print: do
local oldprint = print -- Сохраняем текущую функцию print как oldprint
function print(s) -- Переопределяем функцию print
if s == "foo" then
oldprint("bar")
else
oldprint(s)
end
end
end
Любой будущий вызов Ключевой особенностью Lua является расширяемая семантика, механизм метатаблиц даёт большие возможности по настройке уникального поведения для таблиц Lua. В следующем примере демонстрируется «бесконечная» таблица. Для любого 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 позволяет использовать логические операторы do
local num = tonumber(io.read()) -- Записывание в переменную введённой из консоли информации и преобразование её к целочисленному типу
print(num == 1 and "Вы ввели правильное число" or "Вы ввели неправильное число") -- Если переменная num равняется 1, тогда в консоли выведится текст после and, во всех остальных случаях после or
end
Обращение к существующей таблице и получение значения по первому индексу: do
local tbl = nil
local tbl2 = {1}
print( (tbl or tbl2)[1] ) -- Выведится число 1, так как в таблице tbl2 на индексе 1 присвоено это значение
end
Вызов функции из одной из существующих таблиц: do
local tbl = nil
local tbl2 = {}
tbl2.DoSomething = function() print("Делать что-то") end
(tbl or tbl2).DoSomething()
end
РеализацияКак и многие интерпретируемые языки программирования, реализация Lua имеет отдельно компилятор с исходного языка в исполняемый байт-код и виртуальную машину для исполнения сгенерированного байт-кода. Причём байт-код — это не команды стековой машины, а команды некоего виртуального процессора с несколькими регистрами, что повышает эффективность исполнения. В стандартной виртуальной машине Lua используется распределение памяти со сборкой мусора (аналогично Java или .NET). Lua использует единый строковый пул, что позволяет снизить расходы памяти на хранение строк. Для задач, критичных по времени, имеется JIT-компилятор Lua — LuaJIT[16]. Также разработан компилятор llvm-lua[17], генерирующий код для виртуальной машины LLVM, предоставляющей возможность последующей компиляции в очень эффективный машинный код для процессоров различной архитектуры. ИспользованиеВ настоящее время используется в различных проектах, где требуется встроить достаточно быстрый и нетрудный в освоении скриптовый язык программирования — например, в разработке игр, где Lua часто используется в качестве прослойки между игровым движком и данными для написания сценариев поведения и взаимодействия объектов. Благодаря компактности применим и в портативных устройствах, в частности, один из графических микрокалькуляторов Texas Instruments, а именно, TI-Nspire CX, использует язык LUA помимо традиционного для такого класса устройств Бейсика. ИгрыПервыми в разработку компьютерных игр язык Lua внедрила компания LucasArts начиная с игры Grim Fandango[18]. Авторы языка в своём докладе на конференции HOPL[англ.] вспоминают, что в январе 1997 они получили сообщение от Брета Могилефски, главного разработчика Grim Fandango, где он писал, что, прочитав о языке в статье 1996 года в Dr. Dobb’s Journal, он планирует заменить используемый ими самодельный скриптовый язык SCUMM на Lua[19]. В результате им был создан игровой движок GrimE, используемый также более поздним квестом от LucasArts — Escape from Monkey Island. В 2003 году в результате опроса на сайте GameDev.net Lua был признан самым популярным скриптовым языком для разработки игр[10]. Примером игры, программируемой с помощью Lua, является World of Warcraft[20][21]. На языке Lua описываются уровни игры-головоломки Enigma[22]. Доступен ряд свободных игровых движков, программируемых на Lua, таких, как Defold[23][неавторитетный источник][значимость факта?], аркадный движок LÖVE[24][25], игровой конструктор Novashell[26] и ориентированный на квесты (преимущественно — текстовые) INSTEAD[27]. Также используется в авиасимуляторе X-Plane, в движке X-Ray для S.T.A.L.K.E.R[28]. Для популярной игры Minecraft созданы модификации ComputerCraft и его более совершенный аналог OpenComputers, которые добавляют компьютеры, программируемые на языке Lua[29]. Известная игра Garry's Mod программируется, а также поддерживает модификации, написанные на Lua. Команда Croteam (разработчики Serious Sam и The Talos Principle) использует Lua в скриптах начиная с версии Serious Engine 3.5[30]. Для игры GTA: San Andreas создаются модификации, написанные на языке Lua и поддерживаемые плагином Moonloader.[31] Также игра Multi Theft Auto поддерживает программирование скриптов на языке Lua. Игровая платформа Roblox использует Lua в качестве языка кодирования игр и управления игровой средой[32]. Сообществом игры Satisfactory создан мод Ficsit-Networks, дающий возможность программировать какие-либо действия на языке Lua[33]. В игре Factorio используется Lua для создания модов.[34][35] В игре Dual Universe используется для внутри игровой механики и программирования игровых блоков[значимость?] LuaTeXПрограмма компьютерной вёрстки LuaTeX, расширенная версия pdfTeX, использует Lua как встроенный скриптовый язык[36]. RPMПакетный менеджер RPM содержит встроенный интерпретатор Lua[37]. IDEСуществует как минимум две «родные» среды разработки для Lua:
Кроме того, Lua поддерживается некоторыми универсальными IDE, в частности:
Существовал модуль поддержки Lua для среды NetBeans, но его развитие прекратилось в 2013 году и он доступен только для версии NetBeans 7.4 и более ранних. В NetBeans 8 плагин не поддерживается. См. также
Примечания
Литература
История языка
Ссылки
Lua на русскомПереводы руководств
Статьи и обзоры
|