0Pricing
Lua Academy · Lección

Operadores aritméticos y relacionales

Utilice +, -, *, /, //, %, ^ y los operadores de comparación de forma eficaz.

Operadores aritméticos y relacionales es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

Descripción general de los operadores aritméticos

Lua proporciona un conjunto completo de operadores aritméticos: + (suma), - (resta), * (multiplicación), / (división de coma flotante), // (división entera), % (módulo), ^ (potenciación) y - unario (negación). En Lua 5.3+, es fundamental comprender cuándo cada uno devuelve un entero o un número de coma flotante.

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

División entera frente a división de coma flotante

El operador / siempre devuelve un número de coma flotante, incluso al dividir dos enteros cuyo resultado es exacto. El operador de división entera // devuelve un entero solo cuando ambos operandos son enteros; si uno de ellos es un número de coma flotante, el resultado también lo será, aunque seguirá redondeándose hacia abajo.

El operador de potenciación ^ siempre convierte el resultado a coma flotante, por lo que 2^3 produce 8.0, no 8. Use math.tointeger() para volver a convertirlo si es necesario.

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 módulo

El operador % de Lua se define como a % b == a - floor(a/b) * b. Esto significa que sigue el signo del divisor, no el del dividendo. Se diferencia de C/Java, donde el resultado sigue el signo del dividendo.

El operador módulo resulta útil para envolver valores, recorrer arrays cíclicamente e implementar buffers circulares. Un uso habitual es i % n, que recorre los valores del 0 al 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 relacionales

Los operadores relacionales de Lua devuelven valores booleanos: == (igual), ~= (distinto), <, >, <= y >=. Tenga en cuenta que Lua usa ~= para indicar desigualdad, a diferencia de !=, que se usa en la mayoría de los lenguajes.

Comparar valores de tipos diferentes con == siempre devuelve false: no hay conversión implícita en las comprobaciones de igualdad. En Lua, 1 == "1" es 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

Operadores lógicos: and, or, not

Los operadores lógicos de Lua son and, or y not. A diferencia de muchos lenguajes, and y or no devuelven valores booleanos: devuelven uno de sus operandos. Esto permite patrones idiomáticos como los valores predeterminados y la asignación condicional.

  • a and b devuelve a si a es falso, y b en caso contrario
  • a or b devuelve a si a es verdadero, y b en caso contrario
-- 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

El modismo ternario

Lua no tiene un operador ternario (?:), pero puede emularlo mediante and/or. El patrón condition and value_if_true or value_if_false funciona siempre que value_if_true no sea nil ni false.

Este es un modismo muy habitual en Lua. Tenga en cuenta el caso límite: si la rama verdadera es literalmente false, el patrón falla; utilice una instrucción if en su lugar.

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

Precedencia de operadores

Precedencia de los operadores de Lua, de menor a mayor: or, and, comparaciones (< > <= >= == ~=), |, ~, &, desplazamientos, .., + -, * / // %, unarios (not # - ~), ^. Los operadores ^ y .. son asociativos por la derecha; todos los demás son asociativos por la izquierda.

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

Lua 5.3 incorporó operadores bit a bit nativos que funcionan con enteros: & (AND), | (OR), ~ (XOR en forma binaria, NOT en forma unaria), << (desplazamiento a la izquierda), >> (desplazamiento a la derecha). No están disponibles en Lua 5.1/5.2 sin una biblioteca.

Los operadores bit a bit requieren operandos enteros. Pasar un número de punto flotante provoca un error en tiempo de ejecución, a menos que tenga un valor entero exacto.

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

Longitud y concatenación de cadenas

El operador # devuelve la longitud de una cadena en bytes, y el operador .. concatena dos cadenas. Al aplicar .. a números, Lua los convierte automáticamente en cadenas. Sin embargo, mezclar tipos con + sigue las reglas de coerción: una cadena con apariencia de número puede utilizarse en operaciones 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!)

Errores comunes con los operadores

En Lua son habituales varios errores relacionados con los operadores: olvidar que / siempre devuelve un número de punto flotante; utilizar != en lugar de ~= (error de sintaxis); esperar que 0 o "" sean falsos (son verdaderos); y confiar en and/or cuando la rama verdadera podría ser false.

Pruebe siempre las condiciones límite, especialmente al trabajar con división entera negativa, ya que // redondea hacia el 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!)

Comprobación rápida

¿Cuál es el resultado de -7 // 2 en Lua?

Recapitulación: operadores aritméticos y relacionales

Aspectos clave:

  • / siempre devuelve un número de punto flotante; // redondea hacia el infinito negativo
  • ^ siempre devuelve un número de punto flotante y es asociativo por la derecha
  • ~= es el operador de desigualdad (no !=)
  • and/or devuelven operandos, no valores booleanos; esto permite el modismo de valor predeterminado
  • Solo nil y false son falsos; 0 y "" son verdaderos
  • Los operadores bit a bit (& | ~ << >>) requieren enteros de Lua 5.3 o posterior

Siguiente: coerción de tipos y funciones de conversión explícita.

Preguntas frecuentes

¿La lección «Operadores aritméticos y relacionales» es gratis?

Sí — el texto completo de «Operadores aritméticos y relacionales» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Operadores aritméticos y relacionales»?

Utilice +, -, *, /, //, %, ^ y los operadores de comparación de forma eficaz. Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Operadores aritméticos y relacionales»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Resumen de los tipos de datos de Lua
  2. Declaración de variables en Lua
  3. Operadores aritméticos y relacionales
  4. Coerción y conversión de tipos
← Volver a Lua Academy