Lua Academy · Урок

Объявление переменных в Lua

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

«Объявление переменных в Lua» — бесплатный урок Lua Academy на CoddyKit. Это урок 2 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Lua Academy, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Lua Academy содержит 4 уроков всего.

Глобальные и локальные переменные

В Lua переменные по умолчанию являются глобальными. Запись x = 10 без ключевого слова local создаёт глобальную переменную, доступную отовсюду. Использование local x = 10 ограничивает переменную текущим блоком и вложенными в него блоками.

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

x = 100          -- global variable
local y = 200    -- local variable

do
  local z = 300  -- block-local
  print(x, y, z) -- 100  200  300
end

print(x, y)      -- 100  200
print(z)         -- nil  (out of scope)

Ключевое слово local

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

Можно объявить несколько локальных переменных в одной строке и одновременно инициализировать их. Неинициализированные локальные переменные по умолчанию получают значение nil.

local a, b, c = 1, 2, 3
print(a, b, c)    -- 1  2  3

local d, e = 10   -- e is nil
print(d, e)       -- 10  nil

local f           -- nil until assigned
f = 42
print(f)          -- 42

Соглашения об именовании переменных

Идентификаторы Lua должны начинаться с буквы или символа подчёркивания, после чего могут содержать буквы, цифры и символы подчёркивания. В Lua учитывается регистр, поэтому Value, value и VALUE — это три разные переменные.

По соглашению для обычных переменных используйте camelCase или snake_case, для констант — UPPER_CASE, а перед именами закрытых полей модуля ставьте символ подчёркивания. Избегайте имён из одной буквы, кроме имён счётчиков циклов.

local myVariable = 1     -- camelCase
local my_variable = 2    -- snake_case
local MAX_SIZE = 100     -- constant convention
local _private = "hidden" -- private convention

-- Case sensitivity demo
local lua = "lower"
local Lua = "upper"
print(lua, Lua)  -- lower  upper

Глобальная таблица _G

Все глобальные переменные Lua находятся в специальной таблице _G. Запись x = 10 эквивалентна записи _G.x = 10. Для просмотра всех глобальных переменных можно перебрать _G; это удобно при отладке, но опасно в рабочем коде.

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

myGlobal = 42
print(_G.myGlobal)   -- 42

-- Setting via _G is the same as direct assignment
_G.another = "hello"
print(another)        -- hello

-- Counting globals (many built-ins exist)
local count = 0
for k in pairs(_G) do count = count + 1 end
print("Globals:", count)

Множественное присваивание

Lua поддерживает множественное присваивание: несколько переменных можно присвоить в одном операторе. Правая часть вычисляется первой, затем значения присваиваются слева направо. Если переменных больше, чем значений, лишние переменные получают nil. Если значений больше, чем переменных, лишние значения отбрасываются.

Благодаря этому обмен значениями переменных выполняется без временной переменной.

-- Swap without temp variable
local a, b = 10, 20
a, b = b, a
print(a, b)   -- 20  10

-- More variables than values
local x, y, z = 1, 2
print(x, y, z)  -- 1  2  nil

-- More values than variables
local p, q = 1, 2, 3  -- 3 is discarded
print(p, q)   -- 1  2

Область видимости и границы блоков

В Lua используются следующие разделители блоков: do...end, тела функций, if/elseif/else...end, while...end, repeat...until и for...end. Каждый из них создаёт новый уровень области видимости. Блоки do...end полезны, когда нужно ограничить область видимости без добавления другой логики.

Локальная переменная, объявленная в заголовке цикла for, видна в теле цикла и не выходит за его пределы.

for i = 1, 3 do
  local msg = "item " .. i
  print(msg)
end
-- print(i)   -- would be nil, i is gone
-- print(msg) -- would be nil, msg is gone

-- do...end for manual scoping
do
  local temp = expensive_computation or 0
  print(temp)
end
-- temp is nil here

Константы: соглашение local

В Lua нет встроенного ключевого слова const. По соглашению используются имена UPPER_CASE и local, чтобы показать, что значение не должно изменяться. Размещение констант в начале модуля в качестве локальных переменных также подсказывает JIT-компилятору, что эти значения стабильны.

Для настоящей неизменяемости можно использовать таблицу-прокси с __newindex, которая вызывает ошибку при изменении. Это будет рассмотрено в уроке о метатаблицах.

local MAX_RETRIES = 3
local PI = 3.14159265358979
local APP_VERSION = "1.0.0"

-- Use them as read-only by convention
local area = PI * 5 * 5
print(area)           -- 78.539...
print(MAX_RETRIES)    -- 3

Затенение переменных

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

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

local x = "outer"
do
  local x = "inner"  -- shadows outer x
  print(x)            -- inner
end
print(x)              -- outer (unchanged)

local n = 10
for n = 1, 3 do       -- loop n shadows outer n
  print(n)            -- 1, 2, 3
end
print(n)              -- 10 (outer unchanged)

Как избежать загрязнения глобальной области

Случайные глобальные переменные — распространённая ошибка в Lua: опечатка в имени локальной переменной молча создаёт новую глобальную переменную. Модуль strict.lua, часто подключаемый в проектах, обнаруживает чтение и запись необъявленных глобальных переменных, добавляя метатаблицу к _G.

Более простой подход — всегда использовать local и запускать luac -p или средство статического анализа вроде luacheck, чтобы обнаруживать случайные глобальные переменные до выполнения программы.

-- Dangerous: typo creates a global silently
local counter = 0
coutner = 5  -- typo! creates global 'coutner'
print(counter)  -- 0 (not 5!)
print(coutner)  -- 5 (the typo global)

-- Fix: always use local keyword
local score = 0
score = 10  -- assigns to existing local
print(score) -- 10

Присваивание nil удаляет глобальные переменные

Присваивание глобальной переменной значения nil удаляет её из _G, освобождая память. Это правильный способ «удалить» глобальную переменную. Для локальных переменных достаточно вывести их из области видимости — сборщик мусора вернёт занятую ими память.

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

myGlobal = "exists"
print(myGlobal)   -- exists
print(_G.myGlobal ~= nil)  -- true

myGlobal = nil
print(myGlobal)   -- nil
print(_G.myGlobal ~= nil)  -- false
-- The entry is removed from _G

Быстрая проверка

Какова область видимости переменной, объявленной с помощью local x = 5 внутри тела цикла for?

Итоги: объявление переменных в Lua

Главные выводы из этого урока:

Переменные по умолчанию являются глобальными — всегда используйте local
Локальные переменные работают быстрее (без поиска в хеш-таблице) и безопаснее
Множественное присваивание: a, b = b, a меняет значения местами в одной строке
Все глобальные переменные находятся в _G; присваивание nil удаляет их
Затенение: внутренний local скрывает внешнюю переменную, не изменяя её
По соглашению для констант используются имена UPPER_CASE

Далее: арифметические, реляционные и логические операторы.

Часто задаваемые вопросы

Урок «Объявление переменных в Lua» бесплатный?

Да — полный текст урока «Объявление переменных в Lua» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Lua Academy, подпишись на CoddyKit PRO. Курс Lua Academy содержит 4 уроков всего.

Чему я научусь в уроке «Объявление переменных в Lua»?

Разберитесь в глобальных и локальных переменных, а также в соглашениях об именовании. Ты практикуешь Lua Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Lua Academy?

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

Сколько времени занимает урок «Объявление переменных в Lua»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Lua Academy?

Да. Каждый урок Lua Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

← Назад к Lua Academy