0Pricing
Lua Academy · Aula

Operadores aritméticos e relacionais

Use +, -, *, /, //, %, ^ e os operadores de comparação com eficácia.

Operadores aritméticos e relacionais é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

Visão geral dos operadores aritméticos

Lua oferece um conjunto completo de operadores aritméticos: + (adicionar), - (subtrair), * (multiplicar), / (divisão de ponto flutuante), // (divisão com arredondamento para baixo), % (módulo), ^ (exponenciação) e - unário (negação). Entender quando cada operador retorna um inteiro ou um número de ponto flutuante é fundamental no 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

Divisão inteira e de ponto flutuante

O operador / sempre retorna um número de ponto flutuante, mesmo ao dividir dois inteiros cuja divisão seja exata. O operador de divisão com arredondamento para baixo // retorna um inteiro somente quando ambos os operandos são inteiros; se um deles for de ponto flutuante, o resultado será de ponto flutuante, mas ainda assim arredondado para baixo.

O operador de exponenciação ^ sempre converte o resultado para ponto flutuante, portanto 2^3 produz 8.0, não 8. Use math.tointeger() para converter de volta, se necessário.

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)

Operador de módulo

O operador % de Lua é definido como a % b == a - floor(a/b) * b. Isso significa que ele segue o sinal do divisor, não do dividendo. Isso é diferente de C/Java, em que o resultado segue o sinal do dividendo.

O operador de módulo é útil para envolver valores, percorrer vetores ciclicamente e implementar buffers circulares. Um uso comum é: i % n percorre ciclicamente os valores de 0 a 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

Operadores relacionais

Os operadores relacionais de Lua retornam valores booleanos: == (igual), ~= (diferente), <, >, <=, >=. Observe que Lua usa ~= para desigualdade, ao contrário de != na maioria das linguagens.

Comparar valores de tipos diferentes com == sempre retorna false — não há coerção implícita nas verificações de igualdade. 1 == "1" é false em Lua.

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

Operadores lógicos: and, or, not

Os operadores lógicos de Lua são and, or e not. Diferentemente de muitas linguagens, and e or não retornam valores booleanos — eles retornam um de seus operandos. Isso permite padrões idiomáticos, como valores padrão e atribuição condicional.

  • a and b retorna a se a for falso, caso contrário, retorna b
  • a or b retorna a se a for verdadeiro, caso contrário, retorna 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

O padrão ternário

Lua não tem um operador ternário (?:), mas é possível simulá-lo usando and/or. O padrão condition and value_if_true or value_if_false funciona desde que value_if_true não seja nil nem false.

Esse é um padrão muito comum em Lua. Tenha cuidado com o caso extremo: se o ramo verdadeiro for literalmente false, o padrão falhará — use uma instrução if nesse caso.

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!)

Precedência dos operadores

A precedência dos operadores de Lua, da menor para a maior, é: or, and, comparações (< > <= >= == ~=), |, ~, &, deslocamentos, .., + -, * / // %, unários (not # - ~), ^. Os operadores ^ e .. são associativos à direita; todos os outros são associativos à esquerda.

-- 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

Operadores bit a bit (Lua 5.3+)

O Lua 5.3 adicionou operadores bit a bit nativos que funcionam com inteiros: & (AND), | (OR), ~ (XOR quando binário, NOT quando unário), << (deslocamento à esquerda), >> (deslocamento à direita). Eles não estão disponíveis no Lua 5.1/5.2 sem uma biblioteca.

Os operadores bit a bit exigem operandos inteiros. Passar um número de ponto flutuante causa um erro em tempo de execução, a menos que esse número tenha um valor inteiro exato.

-- 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)

Comprimento e concatenação de strings

O operador # retorna o comprimento de uma string em bytes, e o operador .. concatena duas strings. Quando você aplica .. a números, Lua os converte automaticamente em strings. No entanto, misturar tipos com + segue regras de coerção — uma string que se parece com um número pode ser usada em operações aritméticas.

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!)

Erros comuns com operadores

Vários erros relacionados a operadores são comuns em Lua: esquecer que / sempre retorna um número de ponto flutuante; usar != em vez de ~= (erro de sintaxe); esperar que 0 ou "" sejam falsos (eles são verdadeiros); e depender de and/or quando o ramo verdadeiro puder ser false.

Sempre teste as condições de limite, especialmente ao usar divisão com arredondamento para baixo e números negativos, pois // arredonda em direção ao infinito negativo.

-- 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!)

Verificação rápida

Qual é o resultado de -7 // 2 em Lua?

Recapitulação: operadores aritméticos e relacionais

Pontos principais abordados:

  • / sempre retorna um número de ponto flutuante; // arredonda para baixo em direção ao infinito negativo
  • ^ sempre retorna um número de ponto flutuante e é associativo à direita
  • ~= é o operador de desigualdade (não !=)
  • and/or retornam operandos, não valores booleanos — isso permite o padrão de valor padrão
  • Apenas nil e false são falsos — 0 e "" são verdadeiros
  • Os operadores bit a bit (& | ~ << >>) exigem inteiros do Lua 5.3+

A seguir: coerção de tipos e funções de conversão explícita.

Perguntas Frequentes

A aula “Operadores aritméticos e relacionais” é grátis?

Sim — o texto completo de “Operadores aritméticos e relacionais” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Operadores aritméticos e relacionais”?

Use +, -, *, /, //, %, ^ e os operadores de comparação com eficácia. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Operadores aritméticos e relacionais”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Visão geral dos tipos de dados do Lua
  2. Declarando variáveis em Lua
  3. Operadores aritméticos e relacionais
  4. Coerção e conversão de tipos
← Voltar para Lua Academy