Учебник по Lua для программистов — различия между версиями

Материал из ТХАБ.РФ
Перейти к: навигация, поиск
(Новая страница: « == см. также == * Lua == Ссылки == * [https://zserge.wordpress.com/2012/02/23/lua-за-60-минут/ Lua за 60 минут] Категор…»)
 
м (→‎Функции могут принимать переменное количество аргументов:)
 
(не показано 36 промежуточных версий 5 участников)
Строка 1: Строка 1:
 +
Исправленная версия статьи: [https://zserge.wordpress.com/2012/02/23/lua-за-60-минут/ Lua за 60 минут]
 +
* [[Учебник по LuaRu]] - см. [[LuaRu]]
 +
 +
=== Исправлены ===
 +
* сообщения переведены на русский
 +
* исправлены ошибки в примерах
 +
 +
И насчет битовых операций учебнике LuaRu устаревшая информация, в версии 5.3 добавлена полноценная их поддержка.
 +
 +
== Lua? Что это? ==
 +
 +
Lua — простой встраиваемый язык (его можно интегрировать с вашими программами, написанными на других языках), легкий и понятный, с одним типом данных, с однообразным синтаксисом. Идеальный язык для изучения.
 +
 +
== Зачем? ==
 +
 +
Lua может вам пригодится:
 +
 +
* если вы геймер (плагины для World of Warcraft и множества других игр)
 +
* если вы пишете игры (очень часто в играх движок пишут на C/C++, а AI — на Lua)
 +
* если вы системный программист (на Lua можно писать плагины для nmap, wireshark, nginx и других утилит)
 +
* если вы embedded-разработчик (Lua очень быстрый, компактный и требует очень мало ресурсов)
 +
 +
== Что надо для того, чтобы читать дальше? ==
 +
 +
1. Научитесь программировать. Хотя бы немного. Не важно на каком языке.
 +
2. Установите Lua. Для этого либо скачайте здесь версию 5.3 (http://www.lua.org/download.html), либо ищите ее в репозиториях для linux.
 +
 +
Все примеры из статьи запускайте в терминале командой наподобие «lua file.lua».
 +
 +
== Первые впечатления ==
 +
 +
Lua — язык с динамической типизацией (переменные получают типы «на лету» в зависимости от присвоенных значений). Писать на нем можно как в императивном, так и в объектно-ориентированном или функциональном стиле (даже если вы не знаете как это — ничего страшного, продолжайте читать). Вот программа "Привет мир" на Lua:
 +
 +
-- my first lua app: hello.lua
 +
print "Привет мир!";
 +
print("Пока мир.")
 +
 +
Что уже можно сказать о языке:
 +
 +
* однострочные комментарии начинаются с двух дефисов "--"
 +
* скобки и точки-с-запятыми можно не писать
 +
 +
== Операторы языка ==
 +
 +
Набор условных операторов и циклов довольно типичен:
 +
 +
-- условные операторы (ветки 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 = {1, 2, 3} -- массив из 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 s
 +
end
 +
 +
print (sum(1, 2, 3)) -- вернет 9
 +
print (sum(1, 2, 3, 4)) -- вернет 14
 +
 +
 +
Все аргументы, скрытые за многоточием, собираются в локальную таблицу arg. У этой таблицы есть явное поле n, которое возвращает количество аргументов, скрытых за многоточием:
 +
НАПРИМЕР
 +
 +
funcion func(...) 
 +
  print(arg.n);
 +
end
 +
 +
func(1,2,3); -- 3
 +
func(1,4,562,6,26,); -- 5
 +
 +
--Немного изменим программу с функцией sum(...)
 +
 +
function sum(...)
 +
  s = 0
 +
for i=1,arg.n do
 +
s=s+arg[i]
 +
end
 +
  return s
 +
end
 +
 +
print (sum(1, 2, 3))-- вернет 6
 +
 +
print (sum(1, 2, 3, 4)) -- вернет 10
 +
 +
 +
 +
{{s1| Замечание |4}}
 +
* pairs(arg) - перебирает пары ключ-значение аргументов функции (_ и n)
 +
* значение "ключ" - номер по порядку аргумента канализируется в переменную _
 +
* вновь вводимая переменная n суммируется в s
 +
{{s2}}
 +
----
 +
 +
Поскольку функции — это полноценный тип данных, то можно создавать переменные-функции, а можно передавать функции как аргументы других функций
 +
 +
a = function(x) -- функция, умножающая X на 2
 +
        return x * 2
 +
    end
 +
-- краткая форма записи
 +
b = function(x) return x + 1 end -- функция, увеличивающая X на 1
 +
 +
function apply(table, f)
 +
  result = {} -- создание пустой таблицы
 +
  for k, v in pairs(table) do
 +
    result[k] = f(v) -- заменяем элемент на какую-то функцию от этого элемента
 +
    print (result[k]) -- печать результата применения функции f к элементу массива t
 +
  end
 +
end
 +
 +
-- ПОДУМАЙТЕ: что вернут вызовы
 +
t = {1, 3, 5}
 +
print (apply(t, a))
 +
print (apply(t, b))
 +
 +
{{s1| Ответ |4}}
 +
* 2, 6, 10
 +
* 2, 4, 6
 +
{{s2}}
 +
 +
== Объекты = таблицы + функции ==
 +
 +
Раз мы можем сохранять функции в переменных, то и в полях таблиц тоже сможем. А это уже получаются как-бы-методы. Для тех, кто не знаком с ООП скажу, что основная его польза (по крайней мере в Lua) в том, что функции и данные, с которыми они работают находятся рядом — в пределах одного объекта. Для тех, кто знаком с ООП скажу, что классов здесь нет, а наследование прототипное.
 +
 +
Перейдем к примерам. Есть у нас объект, скажем, лампочка. Она умеет гореть и не гореть. Ну а действия с ней можно сделать два — включить и выключить:
 +
-- в таблицу lamp заносится ключ=значение on=false
 +
lamp = {
 +
  on = false
 +
}
 +
 +
function turn_on(lmp) -- в таблицу передаваемую переменной lmp записывается пара ключ-значение on = true
 +
  lmp.on = true
 +
end
 +
-- или в кратком виде
 +
function turn_off(lmp) lmp.on = false  end -- в таблицу передаваемую переменной lmp записывается пара ключ-значение on = false
 +
 +
-- это просто функции для работы со структурой
 +
turn_on(lamp) -- в таблицу lamp записывается пара ключ-значение on = true
 +
print (lamp.on) -- вывод состояния переменной lamp.on (вывод ЗНАЧЕНИЯ переменной on из таблицы lamp)
 +
turn_off(lamp) -- в таблицу lmp записывается пара ключ-значение on = false
 +
print (lamp.on) -- вывод состояния переменной lamp.on 
 +
 +
А если лампочку сделать объектом, и функции turn_off и turn_on сделать полями объекта, то получится:
 +
 +
lamp = {
 +
  on = false,
 +
  turn_on = function(lmp)  -- в таблице lamp ключу turn_on присваивается значение - функция с аргументом lmp
 +
                  lmp.on = true
 +
            end,
 +
  turn_off = function(lmp) lmp.on = false end
 +
}
 +
lamp.turn_on(lamp)
 +
print (lamp.on) -- вывод состояния переменной lamp.on 
 +
lamp.turn_off(lamp)
 +
print (lamp.on) -- вывод состояния переменной lamp.on 
 +
 +
Мы вынуждены передавать сам объект лампочки в качестве 1-го аргумента, потому что иначе наша функция не узнает с какой именно лампочкой надо работать, чтобы сменить состояние on/off. Но чтобы не быть многословными, в Lua есть сокращенная запись, которую обычно и используют — lamp:turn_on(). Итого, мы уже знаем несколько таких упрощений синтаксиса:
 +
 +
lamp:turn_on() -- самая общепринятая запись
 +
lamp.turn_on(lamp) -- то с точки зрения синтаксиса это тоже правильно
 +
lamp["turn_on"](lamp) -- в таблице lamp ключу turn_on
 +
 +
Продолжая говорить о сокращениях, функции можно описывать не только явно, как поля структуры, но и в более удобной форме:
 +
 +
lamp = {
 +
  on = false
 +
}
 +
-- через точку, тогда аргумент надо указывать
 +
function lamp.turn_on(l) l.on = true end
 +
-- через двоеточие, тогда аргумент неявно задается сам, как переменная "self"
 +
-- "self" - и есть та лампочка, для которой вызвали метод
 +
function lamp:turn_off() self.on = false end
 +
 +
Интересно?
 +
 +
=== Специальные функции ===
 +
Раскрыть тему [[Lua.Специальные функции]]
 +
 +
Некоторые имена функций таблиц (методов) зарезервированы, и они несут особый смысл:
 +
 +
* __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) — когда объект удаляется при сборке мусора
 +
 +
Ниже список всех доступных событий и их описание:
 +
 +
* __index( self, key ) чтение по ключу
 +
* __newindex( self, key, value ) запись по ключу
 +
* __call( self, ... ) вызов как функции
 +
* __add( self, arg ) сложение
 +
* __sub( self, arg ) вычитание
 +
* __mul( self, arg ) умножение
 +
* __div( self, arg ) деление
 +
* __mod( self, arg ) остаток от деления
 +
* __pow( self, arg ) возведение в степень
 +
* __unm( self ) унарный минус
 +
* __concat( self, arg ) конкатенация строк
 +
* __len( self ) длина
 +
* __eq( self, arg ) оператор "равно"
 +
* __lt( self, arg ) оператор "меньше"
 +
* __le( self, arg ) оператор "меньше или равно"
 +
* __tostring( self ) Вызывается при попытке перевести объект в строковое представление (например с помощью функции tostring)
 +
* __gc Вызывается для userdata-объектов при сборке мусора
 +
* __metatable Если задать это поле в метатаблице, то getmetatable будет просто возвращать его значение, а setmetatable вернет ошибку.
 +
 +
Подменяя эти методы, можно перегружать операторы и использовать синтаксис языка для своих целей. Главное не переусердствовать.
 +
 +
== Наследование ==
 +
 +
Для тех, кто не знает ООП, наследование позволяет расширить функциональность уже существующего класса. Например, просто лампочка умеет включаться-выключаться, а супер-лампочка будет еще и яркость менять. Зачем нам переписывать методы turn_on/turn_off, если можно их повторно использовать?
 +
 +
В Lua для этого есть понятие мета-таблицы, т.е. таблицы-предка. У каждой таблицы есть одна таблица-предок, и дочерняя таблица умеет делать все, что умеет предок.
 +
 +
* Метатаблица - это обычная таблица в которой описываются определённые события (например сложение, вычитание, сравнивание и т.д.)
 +
* В качестве названия события выступает индекс таблицы, а её значение - обработчик события (метод)
 +
 +
setmetatable связывает таблицы новую и таблицу-предок, с помощью метода __index. Этот метод вызывается всякий раз, когда запрашиваемый атрибут таблицы не найдет (в нашем случае — superlamp:turn_on). И поскольку superlamp.__index == nil и lamp.__index == nil, то вызова метода не происходит.
 +
 +
Допустим, что объект-таблицу lamp мы уже создали. Тогда супер-лампочка будет выглядеть так:
 +
 +
lamp = {
 +
on = false;
 +
turn_on = function(l) l.on = true end;
 +
turn_off = function(l) l.on = false end;
 +
}
 +
-- говорим искать в таблице lamp все неизвестные атрибуты
 +
lamp.__index = lamp
 +
superlamp = {
 +
brightness = 100
 +
}
 +
-- указываем родительскую таблицу
 +
setmetatable(superlamp, lamp)
 +
-- и ее методы теперь доступны (ищутся в таблице, superlamp, потом в superlamp.__index, потом в ее метатаблице lamp.__index
 +
superlamp:turn_on()
 +
print (superlamp.on)
 +
superlamp:turn_off()
 +
print (superlamp.on)
 +
 +
== Расширение функциональности ==
 +
Работает но непонятно
 +
 +
Родительские таблицы есть у многих типов (ну у строк и таблиц точно, у чисел и булевых чисел, и у nil их нет). Допустим, мы хотим складывать все строки с помощью оператора "+", а не "..". Для этого надо подменить функцию «+» (__add) для родительской таблицы всех строк:
 +
 +
s = getmetatable("") -- получили родительскую таблицу строки
 +
s.__add = function(s1, s2) return s1..s2 end -- подменили метод
 +
 +
-- проверяем
 +
a = "Привет"
 +
b = "Мир!"
 +
print(a + b) -- напишет "ПриветМир!"
 +
 +
Собственно, мы еще можем заменить функцию 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 <lua.h>
 +
#include <lauxlib.h>
 +
#include <time.h>
 +
 +
/* собственно, что делать при вызове `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[] = {
 +
    {"rand", librand_rand},
 +
    {NULL, NULL} /* конец списка экспортируемых функций */
 +
};
 +
 +
/* вызывается при загрузке библиотеку */
 +
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, которые можно было бы отразить в статье — пишите!
  
 
== см. также ==
 
== см. также ==
 
* [[Lua]]
 
* [[Lua]]
 +
* [[Lua. Справочное руководство по языку Lua 5.1]]
 +
 
== Ссылки ==
 
== Ссылки ==
−
* [https://zserge.wordpress.com/2012/02/23/lua-за-60-минут/ Lua за 60 минут]
+
* [https://zserge.wordpress.com/2012/02/23/lua-за-60-минут/ Lua за 60 минут] - внесено сюда
−
 
+
* [https://forum.mtasa.com/topic/49166-lua-setmetatable-учимся-работать-с-метатаблицами/ Lua Метатаблицы]
 +
* [https://geekbrains.ru/posts/about_lua Хочу всё знать]
 +
* [http://www.lua.ru/doc/ Справочное руководство по языку Lua 5.1]
 +
* [http://tylerneylon.com/a/learn-lua/ lua за 15 минут]
 +
* [http://lua-users.org/wiki/TutorialDirectory учебник Lua англ]
  
 
[[Категория:Lua]]
 
[[Категория:Lua]]
 
[[Категория:Учебник]]
 
[[Категория:Учебник]]

Текущая версия на 12:46, 15 декабря 2019

Исправленная версия статьи: Lua за 60 минут

Исправлены

  • сообщения переведены на русский
  • исправлены ошибки в примерах
И насчет битовых операций учебнике LuaRu устаревшая информация, в версии 5.3 добавлена полноценная их поддержка.

Lua? Что это?

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

Зачем?

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

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

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

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

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

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

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

-- my first lua app: hello.lua
print "Привет мир!";
print("Пока мир.")

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

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

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

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

-- условные операторы (ветки 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 = {1, 2, 3} -- массив из 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 s
end

print (sum(1, 2, 3)) -- вернет 9
print (sum(1, 2, 3, 4)) -- вернет 14


Все аргументы, скрытые за многоточием, собираются в локальную таблицу arg. У этой таблицы есть явное поле n, которое возвращает количество аргументов, скрытых за многоточием: НАПРИМЕР 

funcion func(...)  
 print(arg.n); 
end 

func(1,2,3); -- 3 
func(1,4,562,6,26,); -- 5

--Немного изменим программу с функцией sum(...) 

function sum(...) 
  s = 0
for i=1,arg.n do
s=s+arg[i]
end
  return s
end

print (sum(1, 2, 3))-- вернет 6

print (sum(1, 2, 3, 4)) -- вернет 10


Замечание
  • pairs(arg) - перебирает пары ключ-значение аргументов функции (_ и n)
  • значение "ключ" - номер по порядку аргумента канализируется в переменную _
  • вновь вводимая переменная n суммируется в s

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

a = function(x) -- функция, умножающая X на 2
        return x * 2
    end 
-- краткая форма записи
b = function(x) return x + 1 end -- функция, увеличивающая X на 1

function apply(table, f)
  result = {} -- создание пустой таблицы
  for k, v in pairs(table) do
    result[k] = f(v) -- заменяем элемент на какую-то функцию от этого элемента
    print (result[k]) -- печать результата применения функции f к элементу массива t
  end
end

-- ПОДУМАЙТЕ: что вернут вызовы
t = {1, 3, 5}
print (apply(t, a))
print (apply(t, b))
Ответ
  • 2, 6, 10
  • 2, 4, 6

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

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

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

-- в таблицу lamp заносится ключ=значение on=false
lamp = {
  on = false
}

function turn_on(lmp) -- в таблицу передаваемую переменной lmp записывается пара ключ-значение on = true
  lmp.on = true
end
-- или в кратком виде
function turn_off(lmp) lmp.on = false  end -- в таблицу передаваемую переменной lmp записывается пара ключ-значение on = false

-- это просто функции для работы со структурой
turn_on(lamp) -- в таблицу lamp записывается пара ключ-значение on = true 
print (lamp.on) -- вывод состояния переменной lamp.on (вывод ЗНАЧЕНИЯ переменной on из таблицы lamp)
turn_off(lamp) -- в таблицу lmp записывается пара ключ-значение on = false
print (lamp.on) -- вывод состояния переменной lamp.on

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

lamp = {
  on = false,
  turn_on = function(lmp)   -- в таблице lamp ключу turn_on присваивается значение - функция с аргументом lmp
                  lmp.on = true
            end,
  turn_off = function(lmp) lmp.on = false end 
}
lamp.turn_on(lamp)
print (lamp.on) -- вывод состояния переменной lamp.on  
lamp.turn_off(lamp)
print (lamp.on) -- вывод состояния переменной lamp.on

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

lamp:turn_on() -- самая общепринятая запись
lamp.turn_on(lamp) -- то с точки зрения синтаксиса это тоже правильно
lamp["turn_on"](lamp) -- в таблице lamp ключу turn_on

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

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

Интересно?

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

Раскрыть тему Lua.Специальные функции

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

  • __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) — когда объект удаляется при сборке мусора

Ниже список всех доступных событий и их описание:

  • __index( self, key ) чтение по ключу
  • __newindex( self, key, value ) запись по ключу
  • __call( self, ... ) вызов как функции
  • __add( self, arg ) сложение
  • __sub( self, arg ) вычитание
  • __mul( self, arg ) умножение
  • __div( self, arg ) деление
  • __mod( self, arg ) остаток от деления
  • __pow( self, arg ) возведение в степень
  • __unm( self ) унарный минус
  • __concat( self, arg ) конкатенация строк
  • __len( self ) длина
  • __eq( self, arg ) оператор "равно"
  • __lt( self, arg ) оператор "меньше"
  • __le( self, arg ) оператор "меньше или равно"
  • __tostring( self ) Вызывается при попытке перевести объект в строковое представление (например с помощью функции tostring)
  • __gc Вызывается для userdata-объектов при сборке мусора
  • __metatable Если задать это поле в метатаблице, то getmetatable будет просто возвращать его значение, а setmetatable вернет ошибку.

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

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

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

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

  • Метатаблица - это обычная таблица в которой описываются определённые события (например сложение, вычитание, сравнивание и т.д.)
  • В качестве названия события выступает индекс таблицы, а её значение - обработчик события (метод)

setmetatable связывает таблицы новую и таблицу-предок, с помощью метода __index. Этот метод вызывается всякий раз, когда запрашиваемый атрибут таблицы не найдет (в нашем случае — superlamp:turn_on). И поскольку superlamp.__index == nil и lamp.__index == nil, то вызова метода не происходит.

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

lamp = {
on = false;
turn_on = function(l) l.on = true end;
turn_off = function(l) l.on = false end;
}
-- говорим искать в таблице lamp все неизвестные атрибуты
lamp.__index = lamp
superlamp = {
brightness = 100
}
-- указываем родительскую таблицу
setmetatable(superlamp, lamp)
-- и ее методы теперь доступны (ищутся в таблице, superlamp, потом в superlamp.__index, потом в ее метатаблице lamp.__index
superlamp:turn_on()
print (superlamp.on)
superlamp:turn_off()
print (superlamp.on)

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

Работает но непонятно

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

s = getmetatable("") -- получили родительскую таблицу строки
s.__add = function(s1, s2) return s1..s2 end -- подменили метод

-- проверяем
a = "Привет"
b = "Мир!"
print(a + b) -- напишет "ПриветМир!"

Собственно, мы еще можем заменить функцию 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 <lua.h>
#include <lauxlib.h>
#include <time.h>

/* собственно, что делать при вызове `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[] = {
   {"rand", librand_rand}, 
   {NULL, NULL} /* конец списка экспортируемых функций */
};

/* вызывается при загрузке библиотеку */
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, которые можно было бы отразить в статье — пишите!

см. также

Ссылки

Источник — «https://xn--80ac3cm.xn--p1ai/index.php?title=Учебник_по_Lua_для_программистов&oldid=7720»