Lua Academy · Урок

Арифметические и реляционные операторы

Научитесь эффективно использовать операторы +, -, *, /, //, %, ^ и операторы сравнения.

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

Обзор арифметических операторов

Lua предоставляет полный набор арифметических операторов: + (сложение), - (вычитание), * (умножение), / (деление с плавающей точкой), // (целочисленное деление с округлением вниз), % (остаток от деления), ^ (возведение в степень) и унарный - (смена знака). В Lua 5.3+ крайне важно понимать, когда каждый оператор возвращает целое число, а когда — число с плавающей точкой.

print(10 + 3)   -- 13
print(10 - 3)   -- 7
print(10 * 3)   -- 30
print(10 / 3)   -- 3.3333...  (always float)
print(10 // 3)  -- 3          (floor division)
print(10 % 3)   -- 1          (modulo)
print(2 ^ 10)   -- 1024.0     (always float)
print(-5)       -- -5

Деление целых чисел и чисел с плавающей точкой

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

Оператор возведения в степень ^ всегда преобразует результат в число с плавающей точкой, поэтому 2^3 даёт 8.0, а не 8. При необходимости используйте math.tointeger(), чтобы выполнить обратное преобразование.

print(6 / 2)        -- 3.0  (float!)
print(6 // 2)       -- 3    (integer)
print(6.0 // 2)     -- 3.0  (float floor)
print(7 // 2)       -- 3    (floor toward -inf)
print(-7 // 2)      -- -4   (floor, not truncate!)
print(2 ^ 3)        -- 8.0  (always float)

Оператор остатка от деления

Оператор % в Lua определяется как a % b == a - floor(a/b) * b. Это означает, что знак результата совпадает со знаком делителя, а не делимого. В C/Java результат определяется знаком делимого, поэтому поведение отличается.

Оператор остатка от деления полезен для зацикливания значений, циклического перебора массивов и реализации кольцевых буферов. Распространённый пример: i % n перебирает значения от 0 до n-1.

print(10 % 3)    --  1  (positive)
print(-10 % 3)   --  2  (sign of divisor!)
print(10 % -3)   -- -2  (sign of divisor)

-- Cycling 1..5 example
for i = 1, 8 do
  local idx = (i - 1) % 5 + 1
  io.write(idx .. " ")  -- 1 2 3 4 5 1 2 3
end

Реляционные операторы

Реляционные операторы Lua возвращают логические значения: == (равно), ~= (не равно), <, >, <=, >=. Обратите внимание: для неравенства Lua использует ~=, в отличие от != в большинстве языков.

Сравнение значений разных типов с помощью == всегда возвращает false — при проверке равенства не выполняется неявное приведение типов. В Lua выражение 1 == "1" даёт false.

print(3 == 3)    -- true
print(3 ~= 4)    -- true
print(3 < 4)     -- true
print(3 >= 3)    -- true

-- No cross-type equality coercion
print(1 == "1")  -- false
print(0 == false) -- false

-- Strings compare lexicographically
print("abc" < "abd")  -- true

Логические операторы: and, or, not

Логические операторы Lua — это and, or и not. В отличие от многих языков, and и or возвращают не логические значения, а один из своих операндов. Это позволяет использовать распространённые идиомы, например значения по умолчанию и условное присваивание.

a and b возвращает a, если a ложно, в противном случае возвращает b
a or b возвращает a, если a истинно, в противном случае возвращает b

-- and/or return operands, not booleans
print(1 and 2)        -- 2
print(false and 2)    -- false
print(1 or 2)         -- 1
print(false or 2)     -- 2

-- Default value idiom
local name = nil
local display = name or "Anonymous"
print(display)        -- Anonymous

Тернарная идиома

В Lua нет тернарного оператора (?:), но его можно имитировать с помощью and/or. Конструкция condition and value_if_true or value_if_false работает, если value_if_true не равно nil или false.

Это очень распространённая идиома Lua. Учитывайте особый случай: если истинная ветвь буквально равна false, конструкция не сработает — вместо неё используйте оператор if.

local x = 10
-- Ternary idiom
local label = x > 5 and "big" or "small"
print(label)   -- big

-- Works for non-false truthy values
local age = 20
local status = age >= 18 and "adult" or "minor"
print(status)  -- adult

-- Edge case: true branch is false -> use if
local val = true and false or "fallback"
print(val)  -- fallback (wrong!)

Приоритет операторов

Приоритет операторов Lua от наименьшего к наибольшему: or, and, сравнения (< > <= >= == ~=), |, ~, &, сдвиги, .., + -, * / // %, унарные операторы (not # - ~), ^. Операторы ^ и .. правоассоциативны, остальные — левоассоциативны.

-- Precedence examples
print(2 + 3 * 4)     -- 14  (not 20)
print(2 ^ 3 ^ 2)     -- 512 (right assoc: 2^(3^2) = 2^9)
print(not 1 == 1)    -- false (not (1) == 1 => false == 1)
print(not (1 == 1))  -- false

-- Use parens to be explicit
print((2 + 3) * 4)   -- 20

Побитовые операторы (Lua 5.3+)

В Lua 5.3 появились встроенные побитовые операторы, работающие с целыми числами: & (AND), | (OR), ~ (XOR в бинарной форме, NOT в унарной), << (сдвиг влево), >> (сдвиг вправо). В Lua 5.1/5.2 они недоступны без библиотеки.

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

-- Bitwise operators (Lua 5.3+)
print(0xFF & 0x0F)   -- 15  (AND)
print(0xF0 | 0x0F)   -- 255 (OR)
print(0xFF ~ 0x0F)   -- 240 (XOR)
print(~0)            -- -1  (bitwise NOT)
print(1 << 4)        -- 16  (left shift)
print(256 >> 4)      -- 16  (right shift)

Длина строк и конкатенация

Оператор # возвращает длину строки в байтах, а оператор .. объединяет две строки. При применении .. к числам Lua автоматически преобразует их в строки. Однако смешивание типов с помощью + подчиняется правилам приведения типов: строку, похожую на число, можно использовать в арифметике.

local s = "hello"
print(#s)            -- 5
print(s .. " world") -- hello world
print(1 .. 2)        -- 12  (number to string)

-- Length of table = array part length
local t = {10, 20, 30}
print(#t)   -- 3

-- Beware: # on tables with holes is undefined
local h = {1, nil, 3}
print(#h)   -- 1 or 3 (undefined behavior!)

Распространённые ошибки при работе с операторами

В Lua часто встречаются следующие ошибки, связанные с операторами: забывают, что / всегда возвращает число с плавающей точкой; используют != вместо ~= (синтаксическая ошибка); ожидают, что 0 или "" будут ложными (они истинны); полагаются на and/or, когда истинная ветвь может иметь значение false.

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

-- Common mistakes
-- 1. / is always float
local result = 10 / 2
print(math.type(result))  -- float, not integer!

-- 2. ~= not !=
-- if x != 5 then  -- SYNTAX ERROR!
if 3 ~= 5 then print("not equal") end

-- 3. 0 is truthy
if 0 then print("0 is truthy in Lua!") end

-- 4. Negative floor division
print(-7 // 2)  -- -4 (not -3!)

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

Каков результат -7 // 2 в Lua?

Повторение: арифметические операторы и операторы отношений

Основные изученные положения:

/ всегда возвращает число с плавающей точкой; // округляет в сторону отрицательной бесконечности
^ всегда возвращает число с плавающей точкой и является правоассоциативным
~= — оператор неравенства (а не !=)
and/or возвращают операнды, а не логические значения, что позволяет использовать идиому значения по умолчанию
Только nil и false являются ложными; 0 и "" истинны
Побитовые операторы (& | ~ << >>) требуют целых чисел в Lua 5.3+

Далее: приведение типов и функции явного преобразования.

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

Урок «Арифметические и реляционные операторы» бесплатный?

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

Чему я научусь в уроке «Арифметические и реляционные операторы»?

Научитесь эффективно использовать операторы +, -, *, /, //, %, ^ и операторы сравнения. Ты практикуешь Lua Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

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

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

Сколько времени занимает урок «Арифметические и реляционные операторы»?

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

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

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

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

← Назад к Lua Academy