Программа lua что это

Программа lua что это

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

5.2.2 (27 марта 2013)

Io , Squirrel , MiniD

Lua ([лу́а], порт. «луна» ) — язык программирования, разработанный подразделением Tecgraf свободно распространяемым, с открытыми исходными текстами на объектно-ориентированного программирования, включая World of Warcraft ) из-за удобства встраивания, скорости исполнения кода и лёгкости обучения. [2]

• 1 История
• 2 Некоторые возможности

• 2.1 Параллельное присваивание
• 2.2 Типы

• 2.2.1 Таблицы
• 2.2.2 Замыкания

• 4.1 Игры

• 7.1 Lua на русском

История

Lua разработан подразделением Tecgraf (группа технологий компьютерной графики) Католического университета Рио-де-Жанейро в Бразилии, история языка ведёт отсчёт с 1993 года.

Нет, это не «просто игрушка»

Roblox — одна из лучших платформ, чтобы стартовать в программировании! Запишите ребёнка на бесплатный урок в Skysmart Pro — расскажем, какие мощные игры и проекты он может создавать

Язык Lua в практическом применении — mplua: интерпретатор, редактор и отладчик

Пройти урок

Что такое язык программирования

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

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

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

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

Язык программирования передаёт конкретные задачи, инструкции, которые нужно выполнить. Человек создаёт алгоритм для компьютера, а компьютер, в свою очередь, их выполняет. Вне зависимости от программного обеспечения. Язык программирования — это некоторое связующее звено для того, чтобы человек смог объяснить компьютеру, что нужно делать.

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

История создания языка программирования Lua

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

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

Для чего нужен язык Lua? Обзор языка программирования LUA.

Из-за политической позиции Бразилии члены общества не могли свободно пользоваться специальным программным обеспечением, прибывшим из других стран. Такое положение вынудило Tecgraf придумывать новые инструменты с самого начала.

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

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

Далее узнаем, какие задачи стало решать проще с языком программирования Lua, а с какими трудностями пришлось столкнуться — обсудим преимущества и недостатки Lua в современном варианте.

Достоинства языка Lua

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

1. Портируемость. Как мы уже писали, при разработке языка создатели ориентировались на то, чтобы его можно было легко портировать на множество платформ. И у них это отлично получилось. Портировать программу, написанную на Lua, можно на разное программное обеспечение и с полным сохранением функционала. То есть, Lua — легко интерпретируемый язык на различные операционные системы.
2. Интегрирование с C/С++. Такая интеграция позволяет минимизировать недостатки C/C++ и приумножить их преимущества. Lua представляет собой продукт, который нейтрализует минусы C: низкую степень независимости от аппаратного обеспечения, отсутствие качественных динамических структур, слабую, сложную работу тестирования и отладки. Но при этом сохраняет главные преимущества C: высокое быстродействие, взаимодействие с различным программным обеспечением и низкоуровневые операции.
3. Простота синтаксиса. Создавая этот язык, разработчики ориентировались на рядового пользователя, который сможет без особых проблем разобраться в синтаксисе и начать создавать программы. Знаний английского будет достаточно для того, чтобы примерно понять, для чего нужны элементы кода.
4. Скорость. Lua нельзя назвать чрезмерно быстрым, но интеграция с С позволяет в некоторых тестах обгонять другие скриптовые языки программирования.
5. Информация. Разработчики внимательно относятся к пользователям, которые кодят на Lua, поэтому на его официальном сайте можно найти ответы на популярные вопросы. А если не удастся, вам поможет развитое сообщество разработчиков.
6. Библиотеки и их добавление. В Lua есть много библиотек, которые позволяют решать большинство задач пользователя. Но если и этого вам мало, можно добавлять свои библиотеки. Более того, они могут быть написаны на языке C, то есть знание языка C позволит расширить функционал Lua и уже полностью использовать его преимущества. Иными словами, Lua — расширяемый язык программирования: мы можем изменять семантику, чтобы создавать программы было проще.

Бесплатные занятия по английскому с носителем

Занимайтесь по 15 минут в день. Осваивайте английскую грамматику и лексику. Сделайте язык частью жизни.

Записаться на интенсив

Недостатки языка Lua

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

1. Lua зависим от других языков. Это небольшой язык, поэтому он во многом зависит от того языка, вместе с которым используется. Например, с C или C++.
2. Необходимо знать дополнительные языки, чтобы лучше ориентироваться в синтаксисе. Исходники Lua написаны на С. А значит, без опыта работы с языком C будет сложнее разобраться в Lua.
3. Lua — небольшой язык. Работать с глобальными проектами на Lua достаточно затруднительно. Этот язык больше подходит для создания небольших проектов.
4. Стиль программирования отличается от привычного. У Lua есть свои особенности, непривычные рядовому программисту. Например, нумерация таблиц начинается не с 0, как это принято в большинстве языков, а с 1.

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

В каких программах используют Lua

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

К случаям частого использования Lua можно отнести моды в Minecraft и программу Roblox Studio, где этот язык помогает разрабатывать различные проекты. Например, в Майнкрафт благодаря модификациям ComputerCraft и ComputerCraftEdu добавляют специального робота, которого мы можем запрограммировать. Такой робот может многое делать по алгоритмам: копать шахту, строить дом, уничтожать монстров или строить големов. Мы сможем даже поиграть с нашим роботом в игру «Камень, ножницы, бумага»! И всё это благодаря языку программирования Lua.

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

Lua в Roblox Studio

Если эти модификации в Майнкрафт выполняют скорее ознакомительную функцию и позволяют поближе узнать язык Lua, то в случае с Roblox Studio всё работает по-другому. Благодаря этому языку здесь можно создавать полноценные плейсы, в которые будут играть тысячи игроков!

Что такое Roblox Studio

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

Разработчики Roblox предлагают специальный движок для создания игр — Roblox Studio, который подходит под любое программное обеспечение. Все проекты, которые создают на этом движке, можно будет опубликовать в самом Roblox, и тогда десятки тысяч игроков смогут оценить ваш проект. А в разработке вам поможет язык программирования Lua. Именно он позволит написать скрипты, чтобы создать ловушки, или, например, запрограммировать машину в игре.

Скрипт — набор строк кода, которые выполняют конкретную задачу

Мы разберём более подробно код Lua на примере паркура с различными блоками — ловушками.

Скрипт в Roblox: ловушка

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

Подробно разберём скрипт для создания такой ловушки.

1. В первой строчке создадим локальную переменнуюpart1 — в ней будет храниться наш блок, который станет ловушкой.
2. Дальше мы создаём локальную функцию hide и прописываем, что будет происходить, когда мы её вызываем. Наш блок меняет цвет на красный, а свойство CanCollide, то есть возможность наступать на этот блок, мы убираем.
3. Дальше мы прописываем локальную функцию seem, где изменяем цвет на зеленый и добавляем возможность наступать на этот блок.
4. Последними строчками мы прописываем цикл с условием, который будет работать бесконечно благодаря условию true.
5. Внутри этого цикла мы с некоторой периодичностью вызываем ранее описанные функции.

Такой достаточно незамысловатый код на Lua позволяет нам сделать интересную ловушку для нашей игры.

Скрипт в Roblox: опасный парт

Разберём еще один скрипт и создадим опасный строительный блок в Roblox. Он называется парт.

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

Скрипт в Roblox: трамплин

Следующий парт не менее интересный и позволяет нашему персонажу взбираться на возвышенности.

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

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

А в этом вам обязательно помогут наши курсы программирования, где опытные преподаватели научат разбираться даже в самом трудном коде и создавать множество уникальных игр. Увидимся на первом уроке!

В Minecraft можно больше, чем просто играть

Нескучное программирование, используем творческий потенциал на максимум, создадим свои собственные трехмерные миры и игры, изучим основы кодирования и логики. А там рукой подать до IT

Пройти бесплатный урок

Преподаватель компьютерных курсов

Источник: skysmart.ru

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

В большом многообразии языков программирования отдельное место занимает Lua. Этот скриптовый язык разработки имеет свободно распространяемый интерпретатор. По своей идеологии, Lua больше всего похож на JavaScript. Однако в отличие от последнего, у Луа представлены более гибкие конструкции.

Немного истории

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

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

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

Особенности языка программирования Lua

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

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

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

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

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

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

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

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

Источник: progkids.com

Программа lua что это

Lua (от португальского “луна”) — облегченный скриптовый язык c расширяемой семантикой.

Lua был создан и поддерживается представителями Pontifical Catholic University Рио-де-Жанейро. У него нет официального стандарта, и стандартом считается описание в руководстве пользователя.

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

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

• синтаксис структур управления логикой программы — из Modula;
• семантику более поздних версий — из Scheme;
• концепцию локальных переменных — из C++;
• концепцию наличия единственной встроенной структуры данных, используемой несколькими способами — из Lisp;
• использование ассоциативных массивов — из SNOBOL;
• множественные присвоения и возвраты из функций — из CLU etc.

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

Lua поддерживает логические, числовые (по умолчанию — числа с плавающей точкой двойной точности) и строковые атомарные типы данных. Единственным “родным” сложным типом данных является таблица — гетерогенный ассоциативный массив, позволяющий использовать разные типы данных для разных пар ключей и значений. Функции являются объектами первого класса, т.е. ими можно манипулировать точно так же, как переменными, передавать и получать как аргументы и т.д.

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

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

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

Элементы синтаксиса:

Комментарий до конца строки Комментарии, которые могут быть вложенными Регистрозависимость Присваивание значения переменной Группировка выражений Блок Равенство Неравенство Сравнение Определение функции Вызов функции Вызов функции без параметров Последовательность Если — то Если — то — иначе Цикл с предусловием Цикл с постусловием Цикл for — next для диапазона целых чисел с инкрементом на 1 Цикл for — next для диапазона целых чисел с декрементом на 1

—

—[[ . ]]

да

=

( . )

do . end

==

~=

< >=

function f(p1, p2) . end

f(a, b, . )

f()

; или конец строки

if condition then . end

if condition then . else . end

WHILE condition DO . end

repeat . until condition

for i = 1, 10 do . end

for i = 10, 1, -1 do . end

Источник: progopedia.ru

Lua за 60 минут

Я сентиментальный программист. Иногда я влюбляюсь в языки программирования, и тогда я могу говорить о них часами. Одним из этих часов я поделюсь с вами.

Lua? Что это?

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

Зачем?

Lua может вам пригодится:

* если вы геймер (плагины для World of Warcraft и множества других игр)
* если вы пишете игры (очень часто в играх движок пишут на C/C++, а AI — на Lua)
* если вы системный программист (на Lua можно писать плагины для nmap, wireshark, nginx и других утилит)
* если вы embedded-разработчик (Lua очень быстрый, компактный и требует очень мало ресурсов)

Что надо для того, чтобы читать дальше?

1. Научитесь программировать. Хотя бы немного. Не важно на каком языке.
2. Установите Lua. Для этого либо скачайте здесь версию 5.2 (http://www.lua.org/download.html), либо ищите ее в репозиториях. Версия 5.1 тоже пойдет, но знайте, что она очень старая.

Все примеры из статьи запускайте в терминале командой наподобие «lua file.lua».

Первые впечатления

Lua — язык с динамической типизацией (переменные получают типы «на лету» в зависимости от присвоенных значений). Писать на нем можно как в императивном, так и в объектно-ориентированном или функциональном стиле (даже если вы не знаете как это — ничего страшного, продолжайте читать). Вот Hello world на Lua:

— my first lua app: hello.lua print «hello world»; print(«goodbye world»)

Что уже можно сказать о языке:

* однострочные комментарии начинаются с двух дефисов «—»
* скобки и точки-с-запятыми можно не писать

Операторы языка

Набор условных операторов и циклов довольно типичен:

— условные операторы (ветки else может не быть) if a == 0 then print(«a is zero») else print(«a is not zero») end — сокращенная форма if/elseif/end (вместо switch/case) if a == 0 then print(«zero») elseif a == 1 then print(«one») elseif a == 2 then print(«two») else print(«other») end — цикл со счетчиком for i = 1, 10 do print(i) end — цикл с предусловием b = 5 while b > 0 do b = b — 1 end — цикл с постусловием repeat b = b + 1 until b >= 5

ПОДУМАЙТЕ: что может означать цикл «for i = 1, 10, 2 do . end» ?

В выражениях можно использовать такие вот операторы над переменными:

* присваивание: x = 0
* арифметические: +, -, *, /, % (остаток от деления), ^ (возведение в степень)
* логические: and, or, not
* сравнение: >, =, ~= (не-равно, да-да, вместо привычного «!=»)
* конкатенация строк (оператор «..»), напр.: s1=»hello»; s2=»world»; s3=s1..s2
* длина/размер (оператор #): s=»hello»; a = #s (‘a’ будет равно 5).
* получение элемента по индексу, напр.: s[2]

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

Типы данных

Я вам соврал, когда сказал что у языка один тип данных. Их у него много (как и у каждого серьезного языка):

* nil (ровным счетом ничего)
* булевы числа (true/false)
* числа (numbers) — без деления на целые/вещественные. Просто числа.
* строки — кстати, они очень похожи на строки в паскале
* функции — да, переменная может быть типа «функция»
* поток (thread)
* произвольные данные (userdata)
* таблица (table)

Если с первыми типами все понятно, то что же такое userdata? Вспомним о том, что Lua — язык встраиваемый, и обычно тесно работает с компонентами программ, написанными на других языках. Так вот, эти «чужие» компоненты могут создавать данные под свои нужды и хранить эти данные вместе с lua-объектами. Так вот, userdata — и есть подводная часть айсберга, которая с точки зрения языка lua не нужна, но и просто не обращать внимания на нее мы не можем.

А теперь самое важное в языке — таблицы.

Таблицы

Я вам снова соврал, когда сказал, что у языка 8 типов данных. Можете считать что он один: всё — это таблицы (это, кстати, тоже неправда). Таблица — это очень изящная структура данных, она сочетает в себе свойства массива, хэш-таблицы («ключ»-«значение»), структуры, объекта.

— Итак, вот пример таблицы как массива: a = — массив из 3-х элементов print(a[2]) — выведет «2», потому что индесы считаются с единицы — А таблица в виде разреженного массива (у которого есть не все элементы) a = <> — пустая таблица a[1] = 1 a[3] = 5

ПОДУМАЙТЕ: чему равно a[2] в случае разреженного массива?

В примере выше таблица ведет себя как массив, но на самом деле — у нас ведь есть ключи (индексы) и значения (элементы массива). И при этом ключами могут быть какие угодно типы, не только числа:

a = <> a[«hello»] = true a[«world»] = false a[true] = 1 — или так: a = < hello = 123, world = 456 >print(a[«hello»)) print(a.hello) — то же самое, что и a[«hello»], хотя выглядит как структура с полями

Кстати, раз уж у таблицы есть ключи и значения, то можно в цикле перебрать все ключи и соответствующие им значения:

t = < a = 3, b = 4 >for key, value in pairs(t) do print(key, value) — выведет «a 3», потом «b 4» end

А как же объекты? О них мы узнаем чуть позже, вначале — о функциях.

Функции

Вот пример обычной функции.

function add(a, b) return a + b end print(add(5, 3)) — напечатает «8»

Функции языка позволяют принимать несколько аргументов, и возвращать несколько аргументов. Так аргументы, значения которых не указаны явно, считаются равными nil.

ПОДУМАЙТЕ: зачем может понадобиться возвращать несколько аргументов?

function swap(a, b) return b, a end x, y = swap(x, y) — кстати, это можно сделать и без функции: x, y = y, x — и если уж функция возвращает несколько аргументов, — а они вам не нужны — игнорируйте их с помощью — специальной переменной-подчеркивания «_» a, _, _, d = some_function()

Функции могут принимать переменное количество аргументов:

— в прототипе переменное число аргументов записывается как троеточие function sum(. ) s = 0 for _, n in pairs(arg) do — в функции обращаются к ним, как к таблице «arg» s = s + n end return a end sum(1, 2, 3) — вернет 6 sum(1, 2, 3, 4) — вернет 10

Поскольку функции — это полноценный тип данных, то можно создавать переменные-функции, а можно передавать функции как аргументы других функций

a = function(x) return x * 2 end — функция, умножающая на 2 b = function(x) return x + 1 end — функция, увеличивающая на 1 function apply(table, f) result = <> for k, v in pairs(table) do result[k] = f(v) — заменяем элемент на какую-то функцию от этого элемента end end — ПОДУМАЙТЕ: что вернут вызовы t = apply(t, a) apply(t, b)

Объекты = функции + таблицы

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

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

Перейдем к примерам. Есть у нас объект, скажем, лампочка. Она умеет гореть и не гореть. Ну а действия с ней можно сделать два — включить и выключить:

lamp = < on = false >function turn_on(l) l.on = true end function turn_off(l) l.on = false end — это просто функции для работы со структурой turn_on(lamp) turn_off(lamp)

А если лампочку сделать объектом, и функции turn_off и turn_on сделать полями объекта, то получится:

lamp = < on = false turn_on = function(l) l.on = true end turn_off = function(l) l.on = false end >lamp.turn_on(lamp) lamp.turn_off(lamp)

Мы вынуждены передавать сам объект лампочки в качестве первого аргумента, потому что иначе наша функция не узнает с какой именно лампочкой надо работать, чтобы сменить состояние on/off. Но чтобы не быть многословными, в Lua есть сокращенная запись, которую обычно и используют — lamp:turn_on(). Итого, мы уже знаем несколько таких упрощений синтаксиса:

lamp:turn_on() — самая общепринятая запись lamp.turn_on(lamp) — то с точки зрения синтаксиса это тоже правильно lamp[«turn_on»](lamp) — и это

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

lamp = < on = false >— через точку, тогда аргумент надо указывать function lamp.turn_on(l) l.on = true end — через двоеточкие, тогда аргумент неявно задается сам, как переменная «self» — «self» — и есть та лампочка, для которой вызвали метод function lamp:turn_off() self.on = false end

Специальные функции

Некоторые имена функций таблиц (методов) зарезервированы, и они несут особый смысл:

* __add(a, b), __sub(a, b), __div(a, b), __mul(a, b), __mod(a, b), __pow(a, b) — вызываются, когда выполняются арифметические операции над таблицей
* __unm(a) — унарная операция «минус» (когда пишут что-то типа «x = -x»)
* __lt(a, b), __le(a, b), __eq(a, b) — вычисляют результат сравнения ( * __len(a) — вызывается, когда делается «#a»
* __concat(a, b) — вызывается при «a..b»
* __call(a, …) — вызывается при «a()». Переменные аргументы — это аргументы при вызове
* __index(a, i) — обращение к a[i], при условии, что такого элемента не существует
* __newindex(a, i, v) — создание «a[i] = v»
* __gc(a) — когда объект удаляется при сборке мусора

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

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

Для тех, кто не знает ООП, наследование позволяет расширить функциональность уже существующего класса. Например, просто лампочка умеет включаться-выключаться, а супер-ламкочка будет еще и яркость менять. Зачем нам переписывать методы turn_on/turn_off, если можно их повторно использовать?

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

Допустим, что объект-таблицу lamp мы уже создали. Тогда супер-лампочка будет выглядеть так:

superlamp = < brightness = 100 >— указываем родительскую таблицу setmetatable(superlamp, lamp) — и ее методы теперь доступны superlamp:turn_on() superlamp:turn_off()

Расширение функциональности

Родительские таблицы есть у многих типов (ну у строк и таблиц точно, у чисел и булевых чисел, и у nil их нет). Допустим, мы хотим складывать все строки с помощью оператора «+» , а не «..» . Для этого надо подменить функцию «+» (__add) для родительской таблицы всех строк:

s = getmetatable(«») — получили родительскую таблицу строки s.__add = function(s1, s2) return s1..s2 end — подменили метод — проверяем a = «hello» b = «world» print(a + b) — напишет «helloworld»

Собственно, мы еще можем заменить функцию print с помощью «print = myfunction», да и много других хакерских дел можно сделать.

Области видимости

Переменные бывают глобальные и локальные. При создании все переменные в Lua являются глобальными.

Для указания локальной области видимости пишут ключевое слово local:

local x local var1, var2 = 5, 3

Не забывайте об этом слове.

Обработка ошибок

Часто, если возникают ошибки, надо прекратить выполнение определенной функции. Можно, конечно, сделать множество проверок и вызывать «return», если что-то пошло не так. Но это увеличит объем кода. В Lua используется что-то наподобие исключений (exceptions).

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

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

function f(x, y) . if . then error(«failed to do somthing») end . end status, err = pcall(f, x, y) — f:функция, x-y: ее аргументы if not status then — обработать ошибку err. В нашем случае в err находится текст ошибки end

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

Стандартных библиотек мало, зато это позволяет запускать Lua где угодно. Подробнее можно получить их список здесь — http://www.lua.org/manual/5.2/manual.html

Нестандартных библиотек много, их можно найти на LuaForge, LuaRocks и в других репозиториях.

Между Lua и не-Lua

ВНИМАНИЕ: эту часть рекомендуется читать людям со знанием языка C.

А если нам недостаточно функциональности стандартных библиотек? Если у нас есть наша программа на C, а мы хотим вызывать ее функции из Lua? Для этого есть очень простой механизм.

Допустим, мы хотим создать свою функцию, которая возвращает случайное число (в Lua есть math.random(), но мы хотим поучиться). Нам придется написать вот такой код на C:

#include #include #include /* собственно, что делать при вызове `rand(from, to)` */ static int librand_rand(lua_State *L) < int from, to; int x; from = lua_tonumber(L, 1); /* первый параметр функции */ to = lua_tonumber(L, 2); /* второй параметр функции */ x = rand() % (to — from + 1) + from; lua_pushnumber(L, x); /* возвращаемое значение */ return 1; /* возвращаем только один аргумент */ >/* в Lua «rand» соответствует нашей функции librand_rand() */ static const luaL_reg R[] = < , /* конец списка экспортируемых функций */ >; /* вызывается при загрузке библиотеку */ LUALIB_API int luaopen_librand(lua_State *L) < luaL_openlib(L, «librand», R, 0); srand(time(NULL)); return 1; /* завершаемся успешно */ >

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

random = require(«librand») — загружаем библиотеку print(random.rand(1, 100)) print(random.rand(0, 1))

А если мы хотим вызывать код, написанный на Lua из наших программ? Тогда наши программы должны создавать виртуальную машину Lua, в которой и будут выполняться Lua-скрипты. Это намного проще:

#include «lua.h» #include «lauxlib.h» int main() < lua_State *L = lua_open(); // создаем виртуальную машину Lua luaL_openlibs(L); // загружаем стандартные библиотеку luaL_dofile(L, «rand.lua»); // выполняем скрипт lua_close(L); // закрываем Lua return 0; >

Все.

Вы теперь можете писать на Lua. Если вы узнаете интересные моменты про Lua, которые можно было бы отразить в статье — пишите!

Источник: zserge.wordpress.com