Для чего используется lua

Язык программирования Lua: возможности разработки для непрофессиональных программистов

Разработчиком этого языка является подразделение Tecgraf из Бразилии. Появился Lua в 1993 году. Авторами являются Роберту Иерузалимски, Вальдемар Селиш и Луиш Энрике ди Фигейреду. Язык имеет открытый код, то есть каждый желающий может внести свою лепту в его развитие. Важной особенностью создания этого языка является то, что он появился в Бразилии, стране, которая ни до этого ни после особенно не отличалась в плане разработки.

Прародителями Lua являются два языка разработки – SOL и DEL. Они также разработаны Tecgraf в период с 1992 по 1993 гг. Причем заказчиком выступала известная компания Petrobras. На сегодняшний день последней версией языка является 5.4.0. Обновление вышло летом 2020 года.

Как видно, Луа, наряду со многими современными языками программирования, имеет длительную историю. При этом, проводятся регулярные обновления, что говорит о том, что Lua пользуется популярностью в определенных кругах и имеет довольно серьезное сообщество.

Главная особенность Луа заключается в том, что он может использоваться как в качестве отдельного, так и встроенного скриптового языка. Уже в процессе создания разработчики поставили себе цель – сделать компактный и простой инструмент, который мог бы с легкостью работать в различных исполняющих средах и обеспечивать при этом должный уровень производительности.

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

Lua относится к языкам программирования ООП. Благодаря встроенным средствам параллельного программирования, разработчики могут создавать многопоточные приложения без обращения к внешним библиотекам или API. При этом, в языке эффективно реализованы возможности межъязыкового взаимодействия.

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

Связано это с тем, что Lua позволяет довольно легко запрограммировать поведение так называемых NPC (от англ. Non-playable characters). Также, с помощью этого языка программируются и другие персонажи, поведение которых можно впоследствии быстро менять, не оказывая влияния на движок.

Наиболее известным игровым продуктом, в котором применяется язык Lua является World of Warcraft. Здесь язык использовался при написании интерфейса. Также, Lua активно использовался и при создании других известных игровых шедевров, таких как Цивилизация 5, Crysis, Sim City, Far Cry, Stalker.

Помимо игрового применения, Луа также подходит для написания ботов для Телеграм, например. Также, Википедия планирует использовать данный язык разработки для встраивания в MediaWiki.

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

Источник

Встраиваемые языки: почему Lua?

Этот материал продолжает серию публикаций, основанных на докладах, которые мы сделали на конференции Games Gathering 2017 в декабре прошлого года. В одном из докладов была затронута тема выбора встраиваемого скриптового языка.

Что такое и зачем нужны скриптовые языки

Как уже упоминалось в предыдущем посте нашего блога, в нашей компании написан собственный движок. Сегодня речь пойдёт о том, чем мы руководствовались во время выбора скриптового языка для этого движка.

Таким образом, есть потребность в средстве для описания несложной, но всё-таки логики, без привлечения тяжёлой артиллерии программистов. Сделаем вывод — что такое для нас скриптовый язык? Это средство, которое позволит сделать разработку игр быстрее и дешевле.
Сразу возникает вопрос, а почему бы нам просто не использовать что-то вроде XML? Дело в том, что для наших целей нам часто нужны управляющие конструкции — ветвление и циклы, в то время как XML это декларативное описание.

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

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

Сформулируем требования к идеальному скриптовому языку.

Python

Python — динамический язык, который пользуется немалой популярностью. Он характеризуется достаточно пологой кривой обучения, его довольно просто выучить. Однако изучить его как следует уже не так-то просто. Как результат, хорошие Python-программисты встречаются редко и дорого стоят. Это противоречит нашему желанию ускорить и удешевить разработку игровой логики.

Python обладает широкими возможностями, отличается хорошей производительностью. Его проблемой является неконсистентная система библиотек. Ещё одна его проблема, которая играет для нас важную роль, заключается в том, что он, на самом деле, не является встраиваемым языком. Это язык, из которого удобно вызывать библиотеки, написанные на C или C++.

По поводу возможностей по встраиванию Python можно сказать, что, например, существует Maya, где используется именно Python. Но тот, кто видел изнутри плагины для Maya, написанные на Python, согласится с нами в том, что выглядят они не очень хорошо.

В итоге можно сказать, что Python, при всех его сильных сторонах, нам не подходит. Теперь рассмотрим JavaScript.

JavaScript

JavaScript — это, без преувеличений, великий язык, который буквально захватил мир.

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

Если нам, для построения игрового движка, нужен какой-нибудь интерпретатор языка — мы можем найти множество таких интерпретаторов. В реальности же придётся выбирать из двух подобных проектов — V8 и WebKit. И тот и другой имеют достаточно большие размеры. Как результат, если речь идёт о настольных играх, можно было бы рискнуть и включить в игру весь интерпретатор, но в случае мобильных игр нас такой вариант не устраивает.

В компании SocialQuantum есть собственный интерпретатор JavaScript, который проходит 98% тестов, мы планируем перевести этот проект в разряд опенсорсных.

В результате оказывается, что JavaScript выглядит сильным кандидатом на роль встраиваемого языка, но нам он тоже не подходит.

Тут надо отметить, что когда заходит разговор о JavaScript, следующим обычно вспоминают Haxe. Но, на самом деле, о возможности использования этого языка в качестве встраиваемого говорить нет смысла, так как Haxe, по сути, является не столько языком, сколько транс-компилятором в другие языки. А это не то, что нам нужно.

Может быть, нас устроит ActionScript или какой-нибудь другой скриптовый язык?

ActionScript

Если формально проанализировать ActionScript на соответствие вышеозначенным требованиям, то может показаться, что идеальный скриптовый язык найден. На его стороне динамическая природа, популярность, лёгкость изучения, хорошие возможности, производительность, наличие библиотек, лёгкость встраивания. Этот язык любят и помнят в игровой индустрии, на нём написано огромное количество замечательных Flash-игр. Главная проблема ActionScript заключается в том, что язык этот почти мёртв. Поэтому нас он тоже не устраивает.

AngelScript, Squirrel и другие

Помимо ActionScript существует множество скриптовых языков, таких, как AngelScript, Squirrel и другие. Среди них можно найти такие, которые, формально, почти полностью удовлетворяют нашим требованиям, но обычно это — языки, которые привязаны к их разработчику, в них бывают какие-то застарелые проблемы, которые годами не исправляются. Они, скорее всего, не слишком популярны, недостаточно хорошо документированы, по ним мало учебных материалов, у них не очень большие сообщества. Одним из следствий такого положения дел является тот факт, что их сложно изучать — хотя бы потому, что не до конца ясно — что они собой представляют и как работают.

Как видно, идеального встраиваемого языка мы пока не нашли. Что если создать собственный язык?

Создание собственного языка

Вполне возможно, что язык, разработанный внутри компании, будет идеально соответствовать её нуждам и его будет легко изучать. Но, скорее всего, такой язык не станет популярным. У такого языка либо будет минимальное количество библиотек, либо их не будет вовсе. Кроме того, сложно поверить, что в современных условиях можно создать нечто такое, что будет работать лучше, что будет обладать большей производительностью и будет проще встраиваться чем что-то, что уже есть на рынке.

Есть компании, которые разрабатывают и используют собственные языки, среди них есть и успешные игроки игрового рынка, но, скорее всего, это — не очень хорошая идея.

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

Lua — встраиваемый язык, который выбрали мы

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

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

Например, вот как выглядит наша рабочая среда на основе IDE CLion от JetBrains. Здесь можно видеть созданный нами механизм автодополнения для Lua, который планируется сделать опенсорсным. Опенсорсным мы собираемся сделать и отладчик.

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

Возражения по поводу использования Lua

Lua предназначен для C а не для С++

Никто не спорит с тем, что Lua — отличный встраиваемый язык. Главное, что считают его минусом, заключается в том, что он создан для использования с языком C, а не C++. Из-за этого, пытаясь применить в Lua что-то такое, что есть в C++ и нет в C, мы сталкиваемся с проблемами. Однако тут надо понимать, что проблемы эти решало множество довольно умных людей. Среди средств, решающих проблемы встраивания Lua в C++-проекты, можно отметить такие, как Luabind, Luabridge, toLua++, SQLuaHost. Это — далеко не полный список. Они обладают разными достоинствами и недостатками, но, тем не менее, скорее всего, всё, что вам может потребоваться, уже реализовано в одном из этих решений.

Рассмотрим, например SQLuaHost. Это — биндинг, который сделан внутри компании SocialQuantum, и который планируется сделать опенсорсным. Это решение представляет наше видение того, как должен биндиться Lua. Поэтому, вполне возможно, что если вы не нашли то, что вам нужно в существующих биндерах, вы найдёте это в SQLuaHost.

Lua — это медленно

Нам часто приходится сталкиваться с мнением, в соответствии с которым Lua — это очень медленный язык. Во-первых — это не так. Lua — это стековая машина, и там, на самом деле, просто нечему тормозить. К тому же надо понимать, что в скриптовый язык мы обычно отдаём игровую логику, бизнес-логику, а не какие-то действительно тяжёлые вещи. В результате, если Lua-скрипты заставляют игру тормозить, то проблема, возможно, кроется в неоптимальном биндинге или в нерациональном использовании каких-то функция языка. Мы, например, проводили синтетические тесты, на которых LuaJIT работает быстрее, чем Mono. При этом никто не мешает писать примерно такой вот неоптимальный код:

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

Lua подходит только для маленьких проектов

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

При этом зачастую на Lua какие-то маленькие модули пишутся быстро, а в игровой индустрии «быстрее» — значит «дешевле».

Другие аргументы против Lua

Критикуя Lua, говорят о том, что язык это древний, что он, что называется, «из коробки», не поддерживает ООП, что нумерация элементов в его таблицах начинается не с 0, как можно было бы ожидать от любого приличного языка, а с 1.

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

Итоги

Подведём итоги. Если ваша задача — с минимальными усилиями обзавестись встраиваемым языком — возьмите Lua. В то же время, если у вас есть время и ресурсы на разработку собственного языка или собственных биндингов — опять же — обратите внимание на Lua. Почему и в первом и во втором случаях мы рекомендуем Lua?

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

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

Источник

lua — практическое применение?

Луа, будучи, очень простым и компактным языком — легко встраиваться. Включаете пару десятков чистых сишных файлов в проект — и вуаля — у вас встроеный язык. Еще, настраиваемость — по большому счету, в плане библиотек, луа это скорее скелет языка, чем полноценный язык програмирования. Иногда при встраивание вообще выкидвают большую часть (или всю) «стандартную» библиотеку, заменяя ее специализированной под домейн, фактически создавая специализированный язык. Еще один плюс — компактность. Я как-то давно, проверял возможность запускать луа-интерпретатор в качестве отладочного модуля на встроенном чипе (я не говорю про смартфоны, а про «жесткий» embedded). Так вот, виртуальная машина луа (правда почти без библиотек и без интерпретатора, кормить ей надо было уже байткод) занимала 15кб (!) RISC кода. Оказалось, что вполне реально запустить было на том железе, хотя в конце эту идею зарубили как слишком сумашедшую («интепретатор в нашем RT?!»). Идем дальше, Луа можно использовать в качестве декларативного языка, но с «плюшкой» в виде динамичности и читаемости человеком, в отличии скажем от статических декларативных систем, например XML. Я как-то делал декларативную систему описания автоматических тестов на луа, получилось по-моему, неплохо. 🙂 А из более простых примеров такого применения — это файлы конфигурации. Простые файлы var=value легко распарсить вручную, на зато на луа можо сделать вот так:
width = 100
height = width*1.2
positions[0] =

Причем реализуется буквально в пару строчек со стороны хоста — инициализовать луа, запарсить и выполнить скрип, считать получившиеся глобальные переменные, все.

Вообщем давайте просуммируем: если нужен легко встраиваемый, компактный, настраиваемый и быстрый скриптовый язык, чтобы расширить функциональность вашей программе — луа отлично для это подходит. Но если нужный полноценный самостоятельный язык, c богатой библиотекой и возможность писать приложения от начала до конца, то лучше посмотреть в сторону «серьёзных» собратьев, скажем Пайтона (Perl, Ruby, whatever). Их, кстати, тоже можно встроить в качество скриптового языка, просто это далеко не всегда оправданно там, где можно ограничится луа.

ЗЫ: JavaScript в чем-то похож на луа тем, что он тоже почти никогда не используется как «самостоятельный» язык.

Странная мотивация. Игры Движки игр требуют быстроты — вот движки игр и пишут на C/C++/etc. Логика игр не требует быстроты, но требует чтоб её мог писать непрограммист — вот и Lua, который не обязательно быстрый.

Источник

Национальная библиотека им. Н. Э. Баумана
Bauman National Library

Персональные инструменты

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

Lua

Парадигма	мультипарадигмальный: императивный, функциональный, прототипно-ориентированный, скриптовый, встраиваемый
Спроектировано	Роберту Иерузалимски, Валдемар Селиш, Луиш Энрике ди Фигейреду
Первый появившийся	1993
Печать дисциплины	динамическая, строгая, «утиная»
Расширение файла	.lua
Главная реализация
Lua, LuaJIT, LLVM-Lua, LuaCLR, Nua, Lua Alchemy
Диалект
MetaLua
Под влиянием
Scheme, Снобол, Модула, Клу, C++
Влияние
Io, GameMonkey, Squirrel, Dao, MiniD

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

Содержание

История создания

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

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

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

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

Инструменты

Автономный интерпретатор (также называемый lua.c по имени файла исходного кода, или просто lua по исполняемому файлу) представляет собой небольшую программу, позволяющую прямое использование Lua. Когда интерпретатор загружает файл, он игнорирует первую строку, если она начинается со «знака числа» («#»). Эта особенность позволяет использовать Lua как интерпретатор скриптов в Unix-системах. Если вы предваряете свой код строкой вида

(при условии, что автономный интерпретатор расположен в /usr/local/bin ), или

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

загрузит файл a.lua, затем выполнит присваивание x = 10, и, наконец, предоставит командную строку для ввода.

Основные принципы

Лексические соглашения

Именами (идентификаторами) в Lua могут быть любые строки из букв, цифр и символа подчеркивания, не начинающиеся с цифры. Следующие ключевые слова зарезервированы и не могут быть использованы в именах:

and	break	do	else	elseif
end	false	for	function	if
in	local	nil	not	or
repeat	return	then	true	until
while

Lua является языком, чувствительным к регистру символов: and – ключевое слово, тогда как And и AND– два разных допустимых идентификатора. По соглашению, имена, начинающиеся с символа подчеркивания и записанные в верхнем регистре (например _VERSION), зарезервированы для использования в качестве внутренних глобальных переменных, используемых Lua. Литеральные строки должны быть заключены в одинарные или двойные кавычки и могут содержать С-подобные escape-поледовательности.

Типы и переменные

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

Переменные типа table, function, thread и userdata не содержат самих данных, в них хранятся только ссылки на соответствующий объект.

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

Операторы

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

Ниже перечислены основные операции:

При сравнении на равенство не производится преобразование типов. Объекты разных типов всегда считаются различными. При вычислении значения используется короткая схема — второй аргумент вычисляется только если это необходимо. Действует следующая таблица приоритетов и ассоциативности операций:

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

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

Операторы можно (но не обязательно) разделять символом ‘;’.

Ниже перечислены основные операторы:

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

Функции

Определение функции — это исполняемое выражение (конструктор функции), результатом вычисления которого является объект типа функция:

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

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

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

Если функция принимает единственный аргумент и трактует его как таблицу, элементы которой индексируются именами формальных параметров функции, то в этом случае фактически реализуется вызов механизм поименованных аргументов:

Мета-таблицы

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

Lua определяет следующие события:

Примеры использования мета-таблиц

В следующем примере мета-таблицы используются для назначения значения по умолчанию для отсутствующих элементов таблицы:

Вот более нетривиальное решение, которое не использует отдельной мета-таблицы для каждого умалчиваемого значения:

Мета-метод __index этой мета-таблицы перехватывает обращения к отсутствующим полям таблицы и возвращает значение, сохраненное в самой таблице по индексу key.

Пакеты

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

Также можно делать все функции локальными и отдельно формировать таблицу экспортируемых функций:

Классы и объекты

Конструкция tbl:func() (при объявлении функции и при ее вызове) предоставляет основные возможности, позволяющие работать с таблицей как с объектом. Основная проблема состоит в порождении многих объектов, имеющих сходное поведение т.е. порожденных от одного класса:

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

Функция object() создает объект заданного класса — таблицу, у которой в качестве мета-таблицы установлен заданный класс. Во втором аргументе может быть передана таблица, содержащая проинициализированные поля объекта.

Стандартные библиотеки

Стандартные Lua библтотеки содержат часто используемые функции, которые выполняются непосредственно в C API. Некоторые из этих функций предоставляют важные сервисы языка (например, type и getmetatable ); другие обеспечивают доступ к «внешним» сервисам (например, ввод/вывод); частично они реализованы на Lua, однако часто используемые и имеющие критическое время выполнения, реализованы на C (например, sort ).

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

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

Источник