Перейти к основному содержимому

200 вопросов по Lua

В РАЗРАБОТКЕЛАБОРАТОРИЯНЕ ОБЯЗАТЕЛЬНО

200 вопросов по Lua​

Основы языка Lua​

Вопрос​

Что такое Lua?

Ответ​

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

Вопрос​

Какие основные особенности языка Lua?

Ответ​

Lua имеет минималистичное ядро, поддерживает функции первого класса, замыкания, корутины, таблицы как универсальную структуру данных, автоматическую сборку мусора и легко интегрируется с C/C++.

Вопрос​

Какие типы данных существуют в Lua?

Ответ​

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

Вопрос​

Что означает значение nil в Lua?

Ответ​

nil обозначает отсутствие значения. Переменная, которой не присвоено значение, имеет значение nil. Удаление переменной достигается присваиванием nil.

Вопрос​

Как объявляется локальная переменная в Lua?

Ответ​

Локальная переменная объявляется с помощью ключевого слова local:

local x = 42

Без local переменная становится глобальной.

Вопрос​

Что происходит при обращении к несуществующему ключу в таблице?

Ответ​

При обращении к несуществующему ключу в таблице возвращается nil.

Вопрос​

Как проверить тип значения в Lua?

Ответ​

Тип значения проверяется с помощью функции type:

print(type(42))        --> "number"
print(type("hello"))   --> "string"
print(type(nil))       --> "nil"

Вопрос​

Является ли Lua статически или динамически типизированным языком?

Ответ​

Lua — динамически типизированный язык. Тип переменной определяется во время выполнения и может меняться.

Вопрос​

Как работает оператор конкатенации строк в Lua?

Ответ​

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

local s = "Hello" .. " " .. "world"  --> "Hello world"

Вопрос​

Что возвращает выражение 10 == "10" в Lua?

Ответ​

Выражение 10 == "10" возвращает false, потому что Lua не выполняет неявного приведения типов при сравнении значений разных типов.

Вопрос​

Какой результат у выражения tonumber("123")?

Ответ​

Функция tonumber("123") возвращает число 123. Если строка не может быть преобразована в число, возвращается nil.

Вопрос​

Как преобразовать значение в строку?

Ответ​

Значение преобразуется в строку с помощью функции tostring:

local s = tostring(42)  --> "42"

Вопрос​

Что делает функция print?

Ответ​

Функция print выводит переданные ей аргументы в стандартный поток вывода, разделяя их табуляцией.

Вопрос​

Как получить длину строки или таблицы?

Ответ​

Длина строки или последовательной таблицы получается с помощью оператора #:

local s = "abc"
local t = {10, 20, 30}
print(#s)  --> 3
print(#t)  --> 3

Для таблиц с нечисловыми или разреженными ключами результат может быть непредсказуем.

Вопрос​

Что такое последовательность (sequence) в Lua?

Ответ​

Последовательность — это таблица, в которой ключи представляют собой целые числа от 1 до n без пропусков. Такие таблицы поддерживают оператор # и функции из модуля table.

Вопрос​

Как работает условный оператор if в Lua?

Ответ​

Условный оператор if проверяет истинность условия. В Lua ложными значениями считаются только false и nil; все остальное — истинно:

if x then
    print("x is truthy")
end

Вопрос​

Как записать цикл for с числовым счётчиком?

Ответ​

Цикл for с числовым счётчиком записывается так:

for i = 1, 10, 2 do
    print(i)
end

Третий аргумент — шаг (по умолчанию 1).

Вопрос​

Как перебрать все пары ключ-значение в таблице?

Ответ​

Для перебора всех пар ключ-значение используется функция pairs:

for k, v in pairs(t) do
    print(k, v)
end

Вопрос​

Как перебрать элементы последовательной таблицы по порядку?

Ответ​

Для перебора элементов последовательной таблицы по порядку используется функция ipairs:

for i, v in ipairs(t) do
    print(i, v)
end

Вопрос​

Что такое глобальные переменные в Lua и как их избегать?

Ответ​

Глобальные переменные создаются при первом присваивании без ключевого слова local. Их следует избегать, всегда объявляя переменные как local, чтобы не засорять глобальное пространство имён.

Функции​

Вопрос​

Как объявляется функция в Lua?

Ответ​

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

function greet(name)
    print("Hello, " .. name)
end

Вопрос​

Можно ли в Lua присвоить функцию переменной?

Ответ​

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

local f = function(x) return x * 2 end
print(f(5))  --> 10

Вопрос​

Что такое анонимная функция в Lua?

Ответ​

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

table.sort(t, function(a, b) return a > b end)

Вопрос​

Сколько значений может возвращать функция в Lua?

Ответ​

Функция в Lua может возвращать любое количество значений. Для этого используется множественный return:

function coords()
    return 10, 20
end

local x, y = coords()  -- x = 10, y = 20

Вопрос​

Как обрабатываются лишние или недостающие аргументы при вызове функции?

Ответ​

Если аргументов меньше, чем параметров, недостающим присваивается nil. Если аргументов больше, лишние игнорируются:

function f(a, b)
    print(a, b)  -- если вызвать f(1), то b будет nil
end

Вопрос​

Что такое замыкание (closure) в Lua?

Ответ​

Замыкание — это функция, которая захватывает локальные переменные из внешней области видимости и сохраняет к ним доступ даже после завершения выполнения внешней функции:

function make_counter()
    local i = 0
    return function()
        i = i + 1
        return i
    end
end

local counter = make_counter()
print(counter())  --> 1
print(counter())  --> 2

Вопрос​

Как передать переменное число аргументов в функцию?

Ответ​

Для этого используется многоточие (...) в списке параметров. Внутри функции аргументы доступны через ..., а их количество можно получить с помощью select("#", ...):

function sum(...)
    local s = 0
    for i = 1, select("#", ...) do
        s = s + select(i, ...)
    end
    return s
end

print(sum(1, 2, 3))  --> 6

Вопрос​

Что делает функция unpack в Lua 5.1 и как её заменить в Lua 5.3+?

Ответ​

В Lua 5.1 unpack распаковывает таблицу в список значений. Начиная с Lua 5.2, эта функция перемещена в библиотеку table.unpack:

-- Lua 5.1
local t = {10, 20, 30}
print(unpack(t))

-- Lua 5.2+
print(table.unpack(t))

Вопрос​

Можно ли рекурсивно вызывать анонимную функцию?

Ответ​

Да, но только если она имеет имя внутри своего тела через local-переменную:

local fact
fact = function(n)
    if n <= 1 then return 1 end
    return n * fact(n - 1)
end

Прямой вызов function(...) ... end(...) невозможен без присваивания имени.

Вопрос​

Как работает хвостовая рекурсия (tail call) в Lua?

Ответ​

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

function loop(n)
    print(n)
    return loop(n + 1)  -- хвостовой вызов
end

Таблицы​

Вопрос​

Что такое таблица в Lua?

Ответ​

Таблица — это встроенная структура данных в Lua, объединяющая функциональность массивов, словарей, множеств и объектов. Это единственная структура данных, предоставляемая языком напрямую.

Вопрос​

Как создать пустую таблицу?

Ответ​

Пустая таблица создаётся с помощью конструктора {}:

local t = {}

Вопрос​

Как добавить элемент в таблицу?

Ответ​

Элемент добавляется путём присваивания значения по ключу:

local t = {}
t["key"] = "value"
-- или, если ключ — строка без пробелов:
t.key = "value"
-- или, если ключ — число:
t[1] = 42

Вопрос​

Можно ли использовать произвольные типы данных как ключи в таблице?

Ответ​

Да. Ключами могут быть любые значения, кроме nil и NaN. Числа, строки, булевы значения, функции, другие таблицы — всё допустимо.

local t = {}
t[true] = "boolean key"
t[print] = "function key"
t[{1, 2}] = "table key"  -- не рекомендуется: разные таблицы — разные ключи

Вопрос​

Что происходит при использовании таблицы в качестве ключа?

Ответ​

Каждая новая таблица — уникальный объект, даже если её содержимое идентично. Поэтому две таблицы с одинаковым содержимым будут разными ключами:

local t1 = {[{1}] = "a"}
local t2 = {[{1}] = "b"}  -- другой ключ

Вопрос​

Как удалить элемент из таблицы?

Ответ​

Элемент удаляется присваиванием nil по соответствующему ключу:

t.key = nil
-- или
t["key"] = nil
-- или
t[1] = nil

Вопрос​

Что делает оператор # для таблицы?

Ответ​

Оператор # возвращает длину последовательной части таблицы — то есть наибольший целочисленный индекс n, такой что t[n] ~= nil и все предыдущие индексы от 1 до n также не равны nil.

local t = {10, 20, 30}
print(#t)  --> 3

Для таблиц с разрывами (например, {1, nil, 3}) результат может быть непредсказуем.

Вопрос​

Чем отличаются pairs и ipairs?

Ответ​

ipairs перебирает только последовательную часть таблицы с целыми ключами от 1 до первого nil.
pairs перебирает все пары ключ-значение в таблице в произвольном порядке.

local t = {a = 1, [1] = 10, [3] = 30}

for i, v in ipairs(t) do print(i, v) end  --> 1 10
for k, v in pairs(t) do print(k, v) end   --> a 1; 1 10; 3 30 (в любом порядке)

Вопрос​

Можно ли хранить функции в таблице?

Ответ​

Да. Функции — значения первого класса, их можно хранить в таблицах:

local math_ops = {
    add = function(a, b) return a + b end,
    sub = function(a, b) return a - b end
}
print(math_ops.add(5, 3))  --> 8

Вопрос​

Что такое «последовательность» в контексте таблиц Lua?

Ответ​

Последовательность — это таблица, в которой ключи представляют собой непрерывный набор целых чисел, начиная с 1. Такие таблицы корректно обрабатываются #, ipairs и функциями из модуля table.

Вопрос​

Как скопировать таблицу?

Ответ​

Lua не предоставляет встроенной функции глубокого копирования. Простое присваивание создаёт ссылку. Для поверхностного копирования используется цикл:

local function shallow_copy(t)
    local copy = {}
    for k, v in pairs(t) do
        copy[k] = v
    end
    return copy
end

Глубокое копирование требует рекурсии и обработки циклических ссылок.

Вопрос​

Что происходит при сравнении двух таблиц с помощью ==?

Ответ​

Оператор == сравнивает таблицы по ссылке, а не по содержимому. Две таблицы равны только если это один и тот же объект:

local a = {1, 2}
local b = {1, 2}
print(a == b)  --> false
print(a == a)  --> true

Вопрос​

Можно ли использовать таблицу как очередь или стек?

Ответ​

Да. Lua предоставляет функции в модуле table:

  • Стек: table.insert(t, value) и table.remove(t)
  • Очередь: table.insert(t, 1, value) и table.remove(t)

Пример стека:

local stack = {}
table.insert(stack, 10)
table.insert(stack, 20)
print(table.remove(stack))  --> 20

Вопрос​

Как проверить, является ли значение таблицей?

Ответ​

Используется функция type:

if type(value) == "table" then
    -- это таблица
end

Вопрос​

Что делает table.concat?

Ответ​

table.concat(t, sep, i, j) объединяет элементы последовательной таблицы t от индекса i до j (по умолчанию — всю таблицу), вставляя между ними строку-разделитель sep:

local t = {"a", "b", "c"}
print(table.concat(t, ", "))  --> "a, b, c"

Все элементы должны быть строками или числами.

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

Вопрос​

Что такое метатаблица в Lua?

Ответ​

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

Вопрос​

Как связать таблицу с метатаблицей?

Ответ​

Связь устанавливается с помощью функции setmetatable:

local t = {}
local mt = {}
setmetatable(t, mt)

После этого операции над t могут использовать обработчики из mt.

Вопрос​

Как получить метатаблицу таблицы?

Ответ​

Метатаблицу можно получить с помощью функции getmetatable:

local mt = getmetatable(t)

Вопрос​

Что делает метаметод __index?

Ответ​

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

local defaults = {color = "white", size = 10}
local t = setmetatable({}, {__index = defaults})
print(t.color)  --> "white"

Если __index — функция, она вызывается с двумя аргументами: таблицей и ключом.

Вопрос​

Что делает метаметод __newindex?

Ответ​

Метаметод __newindex вызывается при попытке присвоить значение несуществующему ключу в таблице. Он позволяет перехватывать запись и реализовать, например, защиту от изменения или логирование:

local t = {}
local mt = {
    __newindex = function(tbl, key, value)
        error("Запись запрещена")
    end
}
setmetatable(t, mt)
t.x = 1  -- ошибка

Вопрос​

Можно ли сделать таблицу «только для чтения» с помощью метатаблицы?

Ответ​

Да. Нужно задать __newindex, который генерирует ошибку, и __index, указывающий на исходную таблицу:

local function readonly(t)
    return setmetatable({}, {
        __index = t,
        __newindex = function() error("Таблица только для чтения") end
    })
end

local ro = readonly({x = 10})
print(ro.x)  --> 10
ro.y = 20    -- ошибка

Вопрос​

Как реализовать оператор сложения для таблиц?

Ответ​

Нужно определить метаметод __add в метатаблице:

local v1 = {x = 1, y = 2}
local v2 = {x = 3, y = 4}
local mt = {
    __add = function(a, b)
        return {x = a.x + b.x, y = a.y + b.y}
    end
}
setmetatable(v1, mt)
setmetatable(v2, mt)

local v3 = v1 + v2  -- {x = 4, y = 6}

Вопрос​

Какие арифметические метаметоды поддерживает Lua?

Ответ​

Lua поддерживает следующие арифметические метаметоды:
__add (+), __sub (-), __mul (*), __div (/), __mod (%), __pow (^), __unm (унарный минус).

Вопрос​

Какие метаметоды сравнения существуют?

Ответ​

Метаметоды сравнения: __eq (==), __lt (<), __le (<=). Остальные операторы (~= , >, >=) выводятся автоматически, если соответствующие базовые определены.

Вопрос​

Что делает метаметод __call?

Ответ​

Метаметод __call позволяет вызывать таблицу как функцию:

local obj = setmetatable({}, {
    __call = function(self, x)
        return x * 2
    end
})

print(obj(5))  --> 10

Вопрос​

Как работает метаметод __tostring?

Ответ​

Метаметод __tostring вызывается при преобразовании таблицы в строку, например, в print или конкатенации:

local t = setmetatable({name = "Alice"}, {
    __tostring = function(self)
        return "User: " .. self.name
    end
})

print(t)  --> "User: Alice"

Вопрос​

Можно ли задать поведение при использовании оператора # для таблицы?

Ответ​

Да. Для этого используется метаметод __len. Он должен возвращать число:

local t = setmetatable({data = {1, 2, 3}}, {
    __len = function(self)
        return #self.data
    end
})

print(#t)  --> 3

В Lua 5.1 __len работает только для userdata; начиная с Lua 5.2 он поддерживается и для таблиц.

Вопрос​

Что делает метаметод __pairs?

Ответ​

Метаметод __pairs переопределяет поведение встроенной функции pairs. Он должен возвращать три значения: итератор, неизменяемое состояние и начальный ключ:

local t = {a = 1, b = 2}
local mt = {
    __pairs = function(tbl)
        return function(_, k)
            if k == nil then return "custom_key", "custom_value" end
        end, nil, nil
    end
}
setmetatable(t, mt)

for k, v in pairs(t) do print(k, v) end  --> custom_key custom_value

Вопрос​

Может ли метатаблица иметь свою метатаблицу?

Ответ​

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

Вопрос​

Что произойдёт, если в __index вернуть функцию, которая сама обращается к тому же ключу?

Ответ​

Это вызовет бесконечную рекурсию, если не предусмотрена защита. Например:

local t = setmetatable({}, {
    __index = function(tbl, k)
        return tbl[k]  -- рекурсия!
    end
})
print(t.x)  -- стек переполнится

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

Корутины​

Вопрос​

Что такое корутина в Lua?

Ответ​

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

Вопрос​

Как создать корутину?

Ответ​

Корутина создаётся с помощью функции coroutine.create, которой передаётся обычная функция:

local co = coroutine.create(function()
    print("Hello from coroutine")
end)

Результат — объект типа thread.

Вопрос​

Как запустить или возобновить корутину?

Ответ​

Корутина запускается или возобновляется с помощью coroutine.resume:

coroutine.resume(co)

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

Вопрос​

Как приостановить выполнение корутины?

Ответ​

Выполнение корутины приостанавливается вызовом coroutine.yield внутри неё:

local co = coroutine.create(function()
    print("Step 1")
    coroutine.yield()
    print("Step 2")
end)

coroutine.resume(co)  --> Step 1
coroutine.resume(co)  --> Step 2

Вопрос​

Что возвращает coroutine.resume?

Ответ​

coroutine.resume возвращает статус выполнения как первый аргумент (true при успехе, false при ошибке), а затем — значения, переданные в yield или возвращённые функцией:

local co = coroutine.create(function()
    coroutine.yield(10, 20)
    return 30
end)

print(coroutine.resume(co))  --> true, 10, 20
print(coroutine.resume(co))  --> true, 30

Вопрос​

Как узнать состояние корутины?

Ответ​

Состояние корутины определяется с помощью coroutine.status. Возможные значения:

  • "suspended" — создана или приостановлена,
  • "running" — сейчас выполняется,
  • "dead" — завершена (успешно или с ошибкой).

Вопрос​

Можно ли передавать аргументы в корутину при возобновлении?

Ответ​

Да. Аргументы, переданные в coroutine.resume, становятся дополнительными аргументами для coroutine.yield:

local co = coroutine.create(function(a)
    print("Start:", a)
    local x, y = coroutine.yield()
    print("Resume:", x, y)
end)

coroutine.resume(co, "init")      --> Start: init
coroutine.resume(co, 100, 200)    --> Resume: 100, 200

Вопрос​

Что происходит, если возобновить завершённую корутину?

Ответ​

Попытка возобновить корутину в состоянии "dead" вызывает ошибку:

local co = coroutine.create(function() end)
coroutine.resume(co)  -- OK
coroutine.resume(co)  -- ошибка: cannot resume dead coroutine

Вопрос​

Являются ли корутины потоками в терминах параллелизма?

Ответ​

Нет. Корутины в Lua — кооперативные и однопоточные. Они не выполняются одновременно и не требуют синхронизации, потому что переключение происходит только при явном вызове yield.

Вопрос​

Можно ли использовать корутины для реализации генераторов?

Ответ​

Да. Корутины идеально подходят для создания генераторов:

function range(n)
    return coroutine.create(function()
        for i = 1, n do
            coroutine.yield(i)
        end
    end)
end

local gen = range(3)
while coroutine.status(gen) ~= "dead" do
    local ok, val = coroutine.resume(gen)
    if ok and val then print(val) end
end
-- Вывод: 1, 2, 3

Вопрос​

Что делает coroutine.running?

Ответ​

Функция coroutine.running возвращает текущую выполняющуюся корутину и булево значение, указывающее, является ли она главной (main thread):

local current = coroutine.running()
print(current)  -- например, thread: 0x..., false (если внутри корутины)

В главном потоке второе значение — true.

Вопрос​

Можно ли обрабатывать ошибки внутри корутины?

Ответ​

Да. Ошибки внутри корутины не прерывают основной поток. Они возвращаются через coroutine.resume как false и сообщение об ошибке:

local co = coroutine.create(function()
    error("Oops!")
end)

local ok, err = coroutine.resume(co)
print(ok, err)  --> false, "Oops!"

Вопрос​

Поддерживают ли корутины рекурсию?

Ответ​

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

Вопрос​

Можно ли использовать yield вне корутины?

Ответ​

Нет. Вызов coroutine.yield вне корутины (например, в основном потоке) вызывает ошибку: «attempt to yield across a C-call boundary» или аналогичное сообщение, в зависимости от окружения.

Вопрос​

Как реализовать планировщик корутин (scheduler)?

Ответ​

Планировщик управляет очередью корутин и поочерёдно возобновляет их:

local queue = {}

function add(co)
    table.insert(queue, co)
end

function run()
    while #queue > 0 do
        local co = table.remove(queue, 1)
        local ok, val = coroutine.resume(co)
        if ok and coroutine.status(co) == "suspended" then
            table.insert(queue, co)  -- вернуть в очередь, если ещё не завершена
        end
    end
end

Модули​

Вопрос​

Что такое модуль в Lua?

Ответ​

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

Вопрос​

Как создать простой модуль в Lua?

Ответ​

Модуль создаётся как обычная таблица, которая возвращается в конце файла:

-- math_utils.lua
local M = {}

function M.add(a, b)
    return a + b
end

return M

Вопрос​

Как загрузить модуль в другой скрипт?

Ответ​

Модуль загружается с помощью функции require:

local utils = require("math_utils")
print(utils.add(3, 4))  --> 7

Имя передаётся как строка без расширения .lua.

Вопрос​

Как работает функция require?

Ответ​

Функция require ищет модуль по имени в путях, заданных в переменной package.path. Если модуль уже был загружен ранее, require возвращает кэшированную версию из таблицы package.loaded, не перезагружая файл.

Вопрос​

Где хранятся уже загруженные модули?

Ответ​

Загруженные модули хранятся в таблице package.loaded, где ключ — имя модуля, а значение — результат вызова модуля (обычно таблица).

Вопрос​

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

Ответ​

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

local M = {}
local helper = function() ... end  -- приватная функция
function M.public() ... end        -- публичная функция
return M

Вопрос​

Можно ли использовать module(..., package.seeall) для создания модуля?

Ответ​

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

Вопрос​

Как организовать иерархию модулей?

Ответ​

Иерархия модулей отражается в имени при вызове require и в структуре файловой системы. Точка в имени соответствует разделителю каталогов:

-- Загрузка: require("graphics.renderer.opengl")
-- Файл: graphics/renderer/opengl.lua

Вопрос​

Что такое package.path?

Ответ​

package.path — это строка, определяющая шаблоны поиска файлов Lua-модулей. Она содержит пути с подстановочным символом ?, который заменяется на имя модуля:

print(package.path)
-- Пример: ./?.lua;/usr/local/share/lua/5.4/?.lua

Вопрос​

Как добавить свой каталог в поиск модулей?

Ответ​

Нужно изменить package.path, добавив новый шаблон:

package.path = package.path .. ";./my_modules/?.lua"

Теперь require("mymod") будет искать файл ./my_modules/mymod.lua.

Вопрос​

Поддерживает ли Lua загрузку бинарных модулей?

Ответ​

Да. Бинарные модули (написанные на C) загружаются через require, если они находятся в путях, указанных в package.cpath. Они должны экспортировать функцию luaopen_<имя>.

Вопрос​

Что происходит, если модуль не найден?

Ответ​

Если ни один из путей в package.path и package.cpath не приводит к существующему файлу, require генерирует ошибку.

Вопрос​

Можно ли перезагрузить модуль во время выполнения?

Ответ​

Да, но только вручную. Нужно удалить запись из package.loaded и вызвать require снова:

package.loaded["mymod"] = nil
local mymod = require("mymod")

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

Вопрос​

Как экспортировать несколько значений из модуля без таблицы?

Ответ​

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

Вопрос​

Как реализовать «ленивую» инициализацию модуля?

Ответ​

Модуль может отложить инициализацию до первого обращения к его функциям, используя метатаблицу с __index:

local M = {}
local initialized = false

local function init()
    if not initialized then
        -- дорогая инициализация
        initialized = true
    end
end

setmetatable(M, {
    __index = function(_, key)
        init()
        return rawget(M, key)
    end
})

return M

Работа с C API​

Вопрос​

Как встроить интерпретатор Lua в программу на C?

Ответ​

Интерпретатор Lua встраивается через библиотеку liblua. Программа создаёт состояние Lua с помощью luaL_newstate(), загружает стандартные библиотеки через luaL_openlibs(), а затем выполняет скрипты или вызывает функции.

#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    luaL_dostring(L, "print('Hello from Lua!')");
    lua_close(L);
    return 0;
}

Вопрос​

Что такое стек Lua в контексте C API?

Ответ​

Стек Lua — это центральная структура данных C API, через которую передаются все значения между C и Lua. Каждое значение (число, строка, таблица и т.д.) помещается в стек как элемент с целочисленным индексом.

Вопрос​

Как поместить число на стек Lua из C?

Ответ​

Число помещается на стек с помощью функции lua_pushnumber:

lua_pushnumber(L, 3.14159);

После этого оно становится доступно для Lua-кода как верхний элемент стека.

Вопрос​

Как вызвать Lua-функцию из C?

Ответ​

Lua-функция вызывается через последовательность действий:

  1. Поместить функцию на стек (lua_getglobal или другим способом),
  2. Поместить аргументы на стек,
  3. Вызвать lua_call(L, nargs, nresults).
lua_getglobal(L, "my_function");  // кладёт функцию на стек
lua_pushnumber(L, 42);            // аргумент
lua_call(L, 1, 1);                // 1 аргумент, 1 результат
double result = lua_tonumber(L, -1);  // читаем результат

Вопрос​

Как зарегистрировать C-функцию в Lua?

Ответ​

C-функция регистрируется с помощью lua_register или вручную через lua_pushcfunction и lua_setglobal:

static int add(lua_State *L) {
    double a = lua_tonumber(L, 1);
    double b = lua_tonumber(L, 2);
    lua_pushnumber(L, a + b);
    return 1;  // количество возвращаемых значений
}

// Регистрация:
lua_register(L, "add", add);

Теперь в Lua можно писать: print(add(2, 3)).

Вопрос​

Что возвращает C-функция, вызываемая из Lua?

Ответ​

C-функция возвращает целое число — количество значений, которые она оставила на вершине стека Lua для возврата вызывающему коду.

Вопрос​

Как проверить тип значения на стеке?

Ответ​

Тип значения проверяется с помощью функций вида lua_is*, например lua_isnumber, lua_isstring, lua_istable:

if (lua_isnumber(L, 1)) {
    double x = lua_tonumber(L, 1);
}

Вопрос​

Как получить строку из стека Lua в C?

Ответ​

Строка извлекается с помощью lua_tolstring, которая также возвращает длину строки:

size_t len;
const char *s = lua_tolstring(L, index, &len);

Возвращённый указатель действителен только до следующего вызова API, который может изменить стек.

Вопрос​

Что такое userdata в Lua?

Ответ​

Userdata — это тип данных, представляющий блок памяти, управляемый C-кодом. Он используется для передачи указателей на объекты C++ или другие нативные структуры в Lua.

Вопрос​

Как создать userdata в C?

Ответ​

Userdata создаётся с помощью lua_newuserdata, которая выделяет блок памяти заданного размера и помещает его на стек:

MyStruct *obj = (MyStruct*)lua_newuserdata(L, sizeof(MyStruct));
obj->value = 42;

Вопрос​

Как связать userdata с метатаблицей?

Ответ​

После создания userdata на стеке, к нему применяется метатаблица с помощью lua_setmetatable. Метатаблица должна быть предварительно загружена на стек:

luaL_getmetatable(L, "MyStruct");
lua_setmetatable(L, -2);  // применяет к userdata под ней

Вопрос​

Как реализовать методы для userdata?

Ответ​

Методы реализуются как C-функции, которые получают userdata как первый аргумент (self). Они регистрируются в метатаблице userdata под ключами-именами:

static int MyStruct_getValue(lua_State *L) {
    MyStruct *obj = (MyStruct*)lua_touserdata(L, 1);
    lua_pushnumber(L, obj->value);
    return 1;
}

// В метатаблице:
lua_pushcfunction(L, MyStruct_getValue);
lua_setfield(L, -2, "getValue");

В Lua: obj:getValue().

Вопрос​

Что делает функция lua_pcall?

Ответ​

Функция lua_pcall вызывает Lua-функцию в защищённом режиме. Если в процессе выполнения возникает ошибка, она не прерывает программу, а возвращается как значение в стеке.

if (lua_pcall(L, 0, 0, 0) != LUA_OK) {
    const char *err = lua_tostring(L, -1);
    fprintf(stderr, "Error: %s\n", err);
    lua_pop(L, 1);
}

Вопрос​

Как обработать ошибки при работе с C API?

Ответ​

Ошибки обрабатываются проверкой возвращаемых кодов функций (LUA_OK, LUA_ERRRUN, LUA_ERRSYNTAX и т.д.) и использованием lua_pcall вместо lua_call для изоляции исключений.

Вопрос​

Можно ли вызывать C-функцию из Lua без глобального имени?

Ответ​

Да. C-функция может быть помещена в таблицу или передана как замыкание, не попадая в глобальное пространство имён. Это достигается через lua_pushcfunction и последующее размещение в нужной таблице.

Производительность и лучшие практики​

Вопрос​

Почему следует избегать глобальных переменных в Lua?

Ответ​

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

Вопрос​

Как ускорить доступ к часто используемым функциям или модулям?

Ответ​

Следует сохранить ссылку на функцию или модуль в локальной переменной:

local math_floor = math.floor
local table_insert = table.insert

for i = 1, 1000 do
    table_insert(t, math_floor(i / 2))
end

Это исключает повторный поиск в таблицах math и table.

Вопрос​

Почему важно объявлять переменные как local?

Ответ​

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

Вопрос​

Как избежать частого создания мелких объектов (например, таблиц) в циклах?

Ответ​

Следует переиспользовать объекты или выносить их создание за пределы цикла. Создание таблиц вызывает аллокации памяти и увеличивает нагрузку на сборщик мусора.

-- Плохо:
for i = 1, 1000 do
    local tmp = {x = i, y = i * 2}
    process(tmp)
end

-- Лучше (если возможно):
local tmp = {}
for i = 1, 1000 do
    tmp.x = i
    tmp.y = i * 2
    process(tmp)
end

Вопрос​

Что такое «разреженная таблица» и почему она может быть неэффективной?

Ответ​

Разреженная таблица — это таблица, в которой числовые ключи имеют большие промежутки (например, {[1] = a, [1000000] = b}). Такая структура не распознаётся как последовательность, оператор # работает некорректно, а память может использоваться неоптимально.

Вопрос​

Как минимизировать влияние сборщика мусора?

Ответ​

Следует избегать ненужного создания временных объектов (строк, таблиц, замыканий), переиспользовать структуры данных и при необходимости управлять сборкой вручную через collectgarbage("stop") и collectgarbage("restart") в критических участках.

Вопрос​

Почему конкатенация строк в цикле неэффективна?

Ответ​

Строки в Lua неизменяемы. Каждая операция .. создаёт новую строку, что приводит к множеству аллокаций. Для сборки длинных строк следует использовать таблицу и table.concat:

local parts = {}
for i = 1, n do
    table.insert(parts, tostring(i))
end
local result = table.concat(parts, ", ")

Вопрос​

Как правильно организовать условные выражения для повышения читаемости?

Ответ​

Следует избегать глубокой вложенности if и использовать ранний выход (return или break) для упрощения логики. Также рекомендуется выносить сложные условия в отдельные локальные переменные с понятными именами.

Вопрос​

Стоит ли использовать метатаблицы повсеместно?

Ответ​

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

Вопрос​

Как избежать ошибок при работе с nil в таблицах?

Ответ​

Следует явно проверять наличие значений перед использованием и проектировать API так, чтобы отсутствие данных было представлено единообразно (например, через специальный маркер или опциональный второй возвращаемый параметр).

Вопрос​

Почему важно тестировать код на разных версиях Lua?

Ответ​

Lua 5.1, 5.2, 5.3 и 5.4 имеют различия в синтаксисе, библиотеках и поведении (например, unpack vs table.unpack, поддержка __len для таблиц). Совместимость обеспечивает надёжность развёртывания.

Вопрос​

Как улучшить читаемость кода с корутинами?

Ответ​

Следует инкапсулировать управление корутиной в объект-обёртку, который скрывает вызовы resume/yield и предоставляет чистый интерфейс (например, итератор или задачу).

Вопрос​

Следует ли использовать goto в Lua?

Ответ​

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

Вопрос​

Как документировать Lua-код?

Ответ​

Рекомендуется использовать комментарии в стиле LuaDoc или EmmyLua над функциями и модулями, указывая типы параметров, возвращаемых значений и назначение. Это помогает IDE и другим разработчикам.

Вопрос​

Что делать, если производительность критична?

Ответ​

Следует профилировать код с помощью инструментов (например, luaprofiler), выявлять узкие места и при необходимости переносить тяжёлые вычисления в C-модули или оптимизировать алгоритмы.

Продвинутые темы​

Вопрос​

Что такое окружение (environment) функции в Lua?

Ответ​

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

Вопрос​

Как работает _ENV в Lua 5.2+?

Ответ​

_ENV — это неявная локальная переменная, автоматически вставляемая в начало каждого чанка. Все свободные имена (не объявленные как local) компилируются как индексы в _ENV. Это позволяет легко изменять глобальное окружение:

local custom_env = {print = print, x = 42}
local f = load("print(x)", "chunk", "t", custom_env)
f()  --> 42

Вопрос​

Можно ли создать «песочницу» для выполнения ненадёжного кода?

Ответ​

Да. Нужно передать в load или loadstring ограниченное окружение без доступа к опасным функциям (os.execute, io.open и т.д.):

local safe_env = {
    print = print,
    tonumber = tonumber,
    tostring = tostring,
    -- нет os, io, debug, package
}
local untrusted_code = "print('safe')"
local f = load(untrusted_code, "", "t", safe_env)
if f then f() end

Вопрос​

Что такое «слабые таблицы» (weak tables)?

Ответ​

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

local mt = {__mode = "k"}
local weak_table = setmetatable({}, mt)

Вопрос​

Как работает сборщик мусора в Lua?

Ответ​

Lua использует инкрементальный трёхфазный сборщик мусора на основе алгоритма «mark-and-sweep». Он автоматически освобождает объекты, недостижимые из корней (глобальные переменные, стек вызовов, registry). Сборка может быть настроена или частично контролироваться через collectgarbage.

Вопрос​

Что такое реестр (registry) в Lua?

Ответ​

Реестр — это скрытая таблица, доступная только из C API через псевдоиндекс LUA_REGISTRYINDEX. Она используется для хранения ссылок на Lua-объекты, которые должны быть доступны C-коду, но не видны из Lua-скриптов.

Вопрос​

Как реализовать наследование с помощью метатаблиц?

Ответ​

Наследование достигается тем, что __index дочерней таблицы указывает на родительскую:

local Parent = {x = 10}
function Parent:getX() return self.x end

local Child = {y = 20}
setmetatable(Child, {__index = Parent})

print(Child:getX())  --> 10

Вопрос​

Можно ли перехватить попытку вызова несуществующего метода?

Ответ​

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

local obj = setmetatable({}, {
    __index = function(_, key)
        return function()
            print("Method '" .. key .. "' not implemented")
        end
    end
})

obj.unknown()  --> Method 'unknown' not implemented

Вопрос​

Что происходит при сравнении NaN в Lua?

Ответ​

NaN не равен ничему, включая самого себя. Выражение x ~= x истинно, если x — NaN. Это соответствует стандарту IEEE 754.

Вопрос​

Поддерживает ли Lua целочисленный тип?

Ответ​

Начиная с Lua 5.3, число представлено либо как целое (64-битное signed integer), либо как вещественное (double). Операции вроде деления / всегда дают вещественное число, а целочисленное деление — //.

Вопрос​

Как работает оператор //?

Ответ​

Оператор // выполняет деление с округлением вниз до ближайшего целого (floor division). Результат всегда целое число:

print(7 // 2)   --> 3
print(-7 // 2)  --> -4

Вопрос​

Что делает битовая библиотека bit32 (Lua 5.2) или встроенные битовые операторы (Lua 5.3+)?

Ответ​

Они предоставляют операции над целыми числами на уровне битов: & (И), | (ИЛИ), ~ (XOR), << (сдвиг влево), >> (сдвиг вправо), ~x (NOT). В Lua 5.2 эти функции находились в модуле bit32.

Вопрос​

Можно ли сериализовать произвольную таблицу в Lua?

Ответ​

Простая таблица без циклических ссылок и userdata может быть сериализована вручную. Для общего случая требуется рекурсивный обход с отслеживанием уже посещённых таблиц. Стандартная библиотека не предоставляет сериализацию.

Вопрос​

Как реализовать «прокси-объект» в Lua?

Ответ​

Прокси создаётся с помощью метатаблицы, перехватывающей все обращения через __index и __newindex, и перенаправляющей их на целевой объект:

local function proxy(target)
    return setmetatable({}, {
        __index = target,
        __newindex = target
    })
end

Вопрос​

Что такое «замороженная» таблица?

Ответ​

Замороженная таблица — это таблица, в которую нельзя добавлять, изменять или удалять элементы. Она реализуется через метатаблицу с __newindex, генерирующим ошибку, и __index, указывающим на оригинальные данные.

Освоение главы0%