Луа (Lua) — мощный, быстрый, лёгкий, расширяемый и встраиваемый скриптовый язык программирования. Луа удобно использовать для написания бизнес-логики приложений.
Отдельные части логики приложения часто бывает удобно описывать в декларативном стиле. Декларативный стиль программирования отличается от более привычного многим императивного тем, что описывается, в первую очередь, каково нечто а не как именно оно создаётся. Написание кода в декларативном стиле часто позволяет скрыть лишние детали реализации.
Луа — мультипарадигменный язык программирования. Одна из сильных сторон Луа — хорошая поддержка декларативного стиля. В этой статье я кратко опишу базовые декларативные средства, предоставлямые языком Луа.
Пример
В качестве наивного примера возьмём код создания диалогового окна с текстовым сообщением и кнопкой в императивном стиле:
function build_message_box ( gui_builder )
local my_dialog = gui_builder:dialog ( )
По быстрому о языке Lua. Если хочешь выучить язык за 15 минут и создать игру — тебе к Lua
my_dialog:set_title ( «Message Box» )local my_label = gui_builder:label ( )
my_label:set_font_size ( 20 )
my_label:set_text ( «Hello, world!» )
my_dialog:add ( my_label )
local my_button = gui_builder:button ( )
my_button:set_title ( «OK» )
my_dialog:add ( my_button )
return my_dialog
end
В декларативном стиле этот код мог бы выглядеть так:
build_message_box = gui:dialog «Message Box»
<
gui:label «Hello, world!» < font_size = 20 >;
gui:button «OK» < >;
>
Гораздо нагляднее. Но как сделать, чтобы это работало?
Основы
Чтобы разобраться в чём дело, нужно знать о некоторых особенностях языка Луа. Я поверхностно расскажу о самых важных для понимания данной статьи. Более подробную информацию можно получить по ссылкам ниже.
Динамическая типизация
Важно помнить, что Луа — язык с динамической типизацией. Это значит, что тип в языке связан не с переменной, а с её значением. Одна и та же переменная может принимать значения разных типов:
a = «the meaning of life» —> была строка,
a = 42 —> стало число
Таблицы
Таблицы (table) — основное средство композиции данных в Луа. Таблица — это и record и array и dictionary и set и object.
Для программирования на Луа очень важно хорошо знать этот тип данных. Я кратко остановлюсь лишь на самых важных для понимания деталях.
Создаются таблицы при помощи «конструктора таблиц» (table constructor) — пары фигурных скобок.
Создадим пустую таблицу t:
Запишем в таблицу t строку «one» по ключу 1 и число 1 по ключу «one»:
t [ 1 ] = «one»
t [ «one» ] = 1
Содержимое таблицы можно указать при её создании:
Lua: самый недооцененный скриптовый язык? / Plavno о главном
Таблица в Луа может содержать ключи и значения всех типов (кроме nil). Но чаще всего в качестве ключей используются целые положительные числа (array) или строки (record / dictionary). Для работы с этими типами ключей язык предоставляет особые средства. Я остановлюсь только на синтаксисе.
Во-первых: при создании таблицы можно опускать положительные целочисленные ключи для идущих подряд элементов. При этом элементы получают ключи в том же порядке, в каком они указаны в конструкторе таблицы. Первый неявный ключ — всегда единица. Явно указанные ключи при выдаче неявных игнорируются.
Следующие две формы записи эквивалентны:
Во-вторых: При использовании строковых литералов в качестве ключей можно опускать кавычки и квадратные скобки, если литерал удовлетворяет ограничениям, налагаемым на луашные идентификаторы.
При создании таблицы следующие две формы записи эквивалентны:
Аналогично для индексации при записи…
t [ «one» ] = 1
t.one = 1
print ( t [ «one» ] )
print ( t.one )
Функции
Функции в Луа — значения первого класса. Это значит, что функцию можно использовать во всех случаях, что и, например, строку: присваивать переменной, хранить в таблице в качестве ключа или значения, передавать в качестве аргумента или возвращаемого значения другой функции.
Функции в Луа можно создавать динамически в любом месте кода. При этом внутри функции доступны не только её аргументы и глобальные переменные, но и локальные переменные из внешних областей видимости. Функции в Луа, на самом деле, это замыкания (closures).
function make_multiplier ( coeff )
return function ( value )
return value * coeff
end
end
local x5 = make_multiplier ( 5 )
print ( x5 ( 10 ) ) —> 50
Важно помнить, что «объявление функции» в Луа — на самом деле синтаксический сахар, скрывающий создание значения типа «функция» и присвоение его переменной.
Следующие два способа создания функции эквивалентны. Создаётся новая функция и присваивается глобальной переменной mul.
function mul ( lhs, rhs ) return lhs * rhs end
mul = function ( lhs, rhs ) return lhs * rhs end
Вызов функции без круглых скобок
В Луа можно не ставить круглые скобки при вызове функции с единственным аргументом, если этот аргумент — строковый литерал или конструктор таблицы. Это очень удобно при написании кода в декларативном стиле.
my_name_is = function ( name )
print ( «Use the force,» , name )
end
my_name_is «Luke» —> Use the force, Luke
my_name_is ( «Luke» )
shopping_list = function ( items )
print ( «Shopping list:» )
for name, qty in pairs ( items ) do
print ( «*» , qty, «x» , name )
end
end
shopping_list
<
milk = 2 ;
bread = 1 ;
apples = 10 ;
>
—> Shopping list:
—> * 2 x milk
—> * 1 x bread
—> * 10 x apples
shopping_list (
<
milk = 2 ;
bread = 1 ;
apples = 10 ;
>
)
Цепочки вызовов
Как я уже упоминал, функция в Луа может вернуть другую функцию (или даже саму себя). Возвращённую функцию можно вызвать сразу же:
function chain_print ( . )
print ( . )
return chain_print
end
chain_print ( 1 ) ( «alpha» ) ( 2 ) ( «beta» ) ( 3 ) ( «gamma» )
—> 1
—> alpha
—> 2
—> beta
—> 3
—> gamma
В примере выше можно опустить скобки вокруг строковых литералов:
chain_print ( 1 ) «alpha» ( 2 ) «beta» ( 3 ) «gamma»
Для наглядности приведу эквивалентный код без «выкрутасов»:
do
local tmp1 = chain_print ( 1 )
local tmp2 = tmp1 ( «alpha» )
local tmp3 = tmp2 ( 2 )
local tmp4 = tmp3 ( «beta» )
local tmp5 = tmp4 ( 3 )
tmp5 ( «gamma» )
end
Методы
Объекты в Луа — чаще всего реализуются при помощи таблиц.
За методами, обычно, скрываются значения-функции, получаемые индексированием таблицы по строковому ключу-идентификатору.
Луа предоставляет специальный синтаксический сахар для объявления и вызова методов — двоеточие. Двоеточие скрывает первый аргумент метода — self, сам объект.
Следующие три формы записи эквивалентны. Создаётся глобальная переменная myobj, в которую записывается таблица-объект с единственным методом foo.
myobj = < a_ = 5 >
function myobj:foo ( b )
print ( self.a_ + b )
end
myobj:foo ( 37 ) —> 42
Совсем без сахара:
myobj = < [ «a_» ] = 5 >
myobj [ «foo» ] = function ( self, b )
print ( self [ «a_» ] + b )
end
myobj [ «foo» ] ( myobj, 37 ) —> 42
Примечание: Как можно заметить, при вызове метода без использования двоеточия, myobj упоминается два раза. Следующие два примера, очевидно, не эквивалентны в случае, когда get_myobj() выполняется с побочными эффектами.
get_myobj ( ) :foo ( 37 )
get_myobj ( ) .foo ( get_myobj ( ) , 37 )
Чтобы код был эквивалентен варианту с двоеточием, нужна временная переменная:
do
local tmp = get_myobj ( )
tmp.foo ( tmp, 37 )
end
При вызове методов через двоеточие также можно опускать круглые скобки, если методу передаётся единственный явный аргумент — строковый литерал или конструктор таблицы:
foo:bar «»
foo:baz
Реализация
Теперь мы знаем почти всё, что нужно для того, чтобы наш декларативный код заработал. Напомню как он выглядит:
build_message_box = gui:dialog «Message Box»
<
gui:label «Hello, world!» < font_size = 20 >;
gui:button «OK» < >;
>
Что же там написано?
Приведу эквивалентную реализацию без декларативных «выкрутасов»:
do
local tmp_1 = gui : label ( «Hello, world!» )
local label = tmp_1 ( < font_size = 20 >)
local tmp_2 = gui : button ( «OK» )
local button = tmp_2 ( < >)
local tmp_3 = gui : dialog ( «Message Box» )
build_message_box = tmp_3 ( < label, button >)
end
Интерфейс объекта gui
Как мы видим, всю работу выполняет объект gui — «конструктор» нашей функции build_message_box(). Теперь уже видны очертания его интерфейса.
Опишем их в псевдокоде:
gui:label(title : string) => function(parameters : table) : [gui_element] gui:button(text : string) => function(parameters : table) : [gui_element] gui:dialog(title : string) => function(element_list : table) : function
Декларативный метод
В интерфейсе объекта gui чётко виден шаблон — метод, принимающий часть аргументов и возвращающий функцию, принимающую остальные аргументы и возвращающую окончательный результат.
Для простоты, будем считать, что мы надстраиваем декларативную модель поверх существующего API gui_builder, упомянутого в императивном примере в начале статьи. Напомню код примера:
function build_message_box ( gui_builder )
local my_dialog = gui_builder:dialog ( )
my_dialog:set_title ( «Message Box» )
local my_label = gui_builder:label ( )
my_label:set_font_size ( 20 )
my_label:set_text ( «Hello, world!» )
my_dialog:add ( my_label )
local my_button = gui_builder:button ( )
my_button:set_title ( «OK» )
my_dialog:add ( my_button )
return my_dialog
end
Попробуем представить себе, как мог бы выглядеть метод gui:dialog():
function gui:dialog ( title )
return function ( element_list )
— Наша build_message_box():
return function ( gui_builder )
local my_dialog = gui_builder:dialog ( )
my_dialog:set_title ( title )
for i = 1 , #element_list do
my_dialog:add (
element_list [ i ] ( gui_builder )
)
end
return my_dialog
end
end
end
Ситуация с [gui_element] прояснилась. Это — функция-конструктор, создающая соответствующий элемент диалога.
Функция build_message_box() создаёт диалог, вызывает функции-конструкторы для дочерних элементов, после чего добавляет эти элементы к диалогу. Функции-конструкторы для элементов диалога явно очень похожи по устройству на build_message_box(). Генерирующие их методы объекта gui тоже будут похожи.
Напрашивается как минимум такое обобщение:
function declarative_method ( method )
return function ( self, name )
return function ( data )
return method ( self, name, data )
end
end
end
Теперь gui:dialog() можно записать нагляднее:
gui.dialog = declarative_method ( function ( self, title, element_list )
return function ( gui_builder )
local my_dialog = gui_builder:dialog ( )
my_dialog:set_title ( title )
for i = 1 , #element_list do
my_dialog:add (
element_list [ i ] ( gui_builder )
)
end
return my_dialog
end
end )
Реализация методов gui:label() и gui:button() стала очевидна:
gui.label = declarative_method ( function ( self, text, parameters )
return function ( gui_builder )
local my_label = gui_builder:label ( )
my_label:set_text ( text )
if parameters.font_size then
my_label:set_font_size ( parameters.font_size )
end
return my_label
end
end )
gui.button = declarative_method ( function ( self, title, parameters )
return function ( gui_builder )
local my_button = gui_builder:button ( )
my_button:set_title ( title )
— Так сложилось, что у нашей кнопки нет параметров.
return my_button
end
end )
Что же у нас получилось?
Проблема улучшения читаемости нашего наивного императивного примера успешно решена.
В результате нашей работы мы, фактически, реализовали с помощью Луа собственный предметно-ориентированный декларативный язык описания «игрушечного» пользовательского интерфейса (DSL).
Благодаря особенностям Луа реализация получилась дешёвой и достаточно гибкой и мощной.
В реальной жизни всё, конечно, несколько сложнее. В зависимости от решаемой задачи нашему механизму могут потребоваться достаточно серьёзные доработки.
Например, если на нашем микро-языке будут писать пользователи, нам понадобится поместить выполняемый код в песочницу. Также, нужно будет серьёзно поработать над понятностью сообщений об ошибках.
Описанный механизм — не панацея, и применять его нужно с умом как и любой другой. Но, тем не менее, даже в таком простейшем виде, декларативный код может сильно повысить читаемость программы и облегчить жизнь программистам.
Полностью работающий пример можно посмотреть здесь.
Дополнительное чтение
- Lua Programming Manual (Перевод)
- Programming in Lua
- Lua Unofficial Frequently Asked Questions
- Lua Programming Gems
- Lua Users Wiki
- The evolution of an extension language: a history of Lua — Статья 2001-го года, в которой, в частности, хорошо видны истоки декларативного синтаксиса в Луа.
Источник: habr.com
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)
Язык программирования 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 и в обсерваториях, которые занимаются исследованиями космоса. Язык также используется различными университетами. А в самой Бразилии его применяют повсеместно. То есть он стал чем-то вроде государственного языка программирования.
Преимущества и недостатки
Язык программирования Луа обладает следующими преимуществами:
- Lua обладает хорошей портируемостью. Например, можно без особых изменений перенести программу из Windows на Linux.
- Большое количество библиотек. Несмотря на то, что по этому параметру Lua проигрывает JavaScript, на официальном сайте языка можно найти все необходимые библиотеки для работы, которых более чем достаточно для выполнения различных задач.
- Возможность быстрого добавления новых библиотек, написанных на языке С.
- Простота синтаксисам и развертывания. Изучение языка не потребует много времени у тех, кто уже занимается программированием. Для новичков этот язык также будет просто в изучении.
- Приложения и программы, написанные на Луа потребляют меньше памяти.
Что касается недостатков, к ним можно отнести то, что язык является скриптовым. Конечно, его можно использовать и самостоятельно, однако чаще всего он применяется вместе с другими языками программирования, например С. Поэтому для полноценной работы потребуется знание еще одного языка разработки.
Критика Луа
Вокруг этого языка не утихают споры в среде разработчиков. Например, критике подвергается тот факт, что Lua создан для использования с С, а не с С++. Это правда. Однако даже сейчас существует несколько библиотек, которые позволяют Луа встраивать и в С++. Такие решения обладают своими недостатками, но они рабочие и, главное, с ними работают сегодня многие программисты.
Также критике подвергается и скорость этого языка. В среде программистов бытует мнение, что Луа намного медленнее своих «конкурентов». Но на самом деле, это миф. Дело в том, что скриптовый язык чаще всего работает с какой-то логикой. То есть здесь просто нечему замедлять процесс работы приложений.
Наконец, еще одним заблуждением является то, что Луа подходит исключительно для небольших проектов. Частично здесь есть рациональное зерно, однако Lua является модульным языком. То есть из различных маленьких блоков можно построить что-то большое и весомое.
Некоторые разработчики критикуют «древность» языка и отсутствие ООП в его базовой версии. Помимо этого, говорят о том, что нумерация элементов начинается не с 0, как это принято в большинстве других ЯП, а с 1. Но здесь, скорее, речь идет уже о личных предпочтениях и взгляде отдельных программистов.
Пример кода на Lua
Посмотрим, как написать простейшую программу с помощью языка программирования Луа на примере строки «Привет Мир». Сделать это на Lua достаточно просто:
print (“Привет мир!”)
Как видно, все действительно очень просто. Луа обладает несложным синтаксисом, что существенно облегчает процесс его изучения.
Перспективы
Разработка игр – очень перспективное направление. Индустрия видео развлечений растет с каждым годом. Соответственно, эта ниша будет только набирать популярность. Но как дело обстоит с языком Lua? По версии индекса популярных языков программирования Tiobe, Луа занимает 30 место, уступая многим популярным инструментам разработки, таким как JS или Java.
В чем причина? Прежде всего в том, что несмотря на использование в игровой индустрии, сами игры пишутся на других языках в основном. С помощью Луа делаются лишь отдельные компоненты, такие как интерфейсы, меню и так далее. То есть Lua не является основным языком в разработке продукта.
Еще один важный момент – сообщество. Несмотря на то, что не так давно стала наблюдаться его активизация, оно все еще заметно меньше и скромнее, чем коммьюнити более популярных языков программирования.
На сегодняшний день предложение превышает спрос. Найти вакансию разработчика на Луа не так просто, а желающих устроиться на такую работу много. Потому если бы вы захотели попасть в какую-нибудь компанию на должность Lua разработчика уже сегодня, вы бы столкнулись не только с трудностью поиска такой вакансии, но и с достаточно высоким уровнем конкуренции.
Стоит ли изучать Lua детям? Если ребенку интересна тематика разработки игр, можно начать с платформы Roblox, которая целиком создана с помощью языка программирования Луа. Роблокс написана таким образом, что для создания своих игровых приложений здесь не потребуется знания кода. Платформа похожа на Scratch, хотя имеет свои отличительные особенности.
Уроки один на один с преподавателем. Ребёнок — в центре внимания.
Раз в неделю учитель даёт советы, обратную связь по успеваемости, а по прохождению курса выдаём сертификат — ребёнок всегда будет видеть свои успехи.
Источник: www.progkids.com