0Pricing
Lua Academy · Lección

Declaración de variables en Lua

Comprenda la diferencia entre variables globales y locales, así como las convenciones de nomenclatura.

Declaración de variables en Lua es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 2 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.

Variables globales frente a locales

En Lua, las variables son globales de forma predeterminada. Escribir x = 10 sin la palabra clave local crea una variable global accesible desde cualquier lugar. Usar local x = 10 restringe la variable al bloque actual y a sus bloques anidados.

Prefiera siempre local por rendimiento y seguridad. Acceder a una variable local es más rápido que acceder a una global porque las variables globales requieren una búsqueda en una tabla hash dentro de la tabla _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)

La palabra clave local

La palabra clave local declara una variable cuyo ámbito corresponde al bloque contenedor más cercano: el cuerpo de una función, un bloque do...end, el cuerpo de un bucle o un fragmento de archivo. Las variables locales se crean en la línea en la que se declaran y dejan de existir al final de su bloque.

Puede declarar varias variables locales en una sola línea e inicializarlas simultáneamente. Las variables locales no inicializadas tienen nil de forma predeterminada.

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

Convenciones para nombrar variables

Los identificadores de Lua siguen estas reglas: deben comenzar con una letra o un guion bajo, seguidos de letras, dígitos o guiones bajos. Lua distingue entre mayúsculas y minúsculas, por lo que Value, value y VALUE son tres variables diferentes.

Por convención, use camelCase o snake_case para las variables habituales, UPPER_CASE para las constantes y anteponga un guion bajo a los campos privados de los módulos. Evite los nombres de una sola letra, excepto para los contadores de bucle.

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

La tabla global _G

Todas las variables globales de Lua viven en una tabla especial llamada _G. Escribir x = 10 equivale a escribir _G.x = 10. Puede inspeccionar todas las variables globales iterando sobre _G, lo que resulta práctico para depurar, pero es peligroso en código de producción.

En Lua 5.2+, _ENV es la tabla de entorno real y _G se inicializa para apuntar a ella. Comprender esto le permite crear un entorno aislado para el código sustituyendo _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)

Asignación múltiple

Lua admite la asignación múltiple: puede asignar varias variables en una sola instrucción. Primero se evalúa el lado derecho y después se asignan los valores de izquierda a derecha. Si hay más variables que valores, las variables adicionales reciben nil. Si hay más valores que variables, los valores adicionales se descartan.

Esto permite intercambiar variables fácilmente sin usar una variable temporal.

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

Ámbito y límites de los bloques

Los delimitadores de bloques de Lua son: do...end, los cuerpos de funciones, if/elseif/else...end, while...end, repeat...until y for...end. Cada uno crea un nuevo nivel de ámbito. Los bloques do...end resultan útiles exclusivamente para limitar el ámbito sin ninguna otra lógica.

Una variable local declarada en la cabecera de un bucle for pertenece al ámbito del cuerpo del bucle y no se filtra fuera de él.

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

Constantes: la convención de local

Lua no tiene una palabra clave const integrada. La convención consiste en usar nombres UPPER_CASE y local para indicar que un valor no debería cambiar. Colocar las constantes al principio de un módulo como variables locales también proporciona al compilador JIT una indicación de que esos valores son estables.

Para conseguir una inmutabilidad real, puede usar una tabla proxy con __newindex que genere un error al modificarla; lo veremos en la lección sobre metatablas.

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

Ocultación de variables

La ocultación se produce cuando un ámbito interno declara una variable local con el mismo nombre que una variable externa. La declaración interna crea una variable completamente nueva que oculta a la externa dentro de su ámbito. La variable externa no cambia y vuelve a ser visible cuando termina el ámbito interno.

La ocultación puede resultar confusa; prefiera nombres únicos en los ámbitos anidados, aunque a veces es intencionada, por ejemplo, al reutilizar nombres de variables de bucle en bucles anidados.

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)

Cómo evitar la contaminación del ámbito global

Las variables globales accidentales son un error común en Lua: escribir incorrectamente el nombre de una variable local crea silenciosamente una nueva variable global. El módulo strict.lua, incluido habitualmente en los proyectos, detecta las lecturas y escrituras de variables globales no declaradas añadiendo una metatabla a _G.

Un enfoque más sencillo consiste en usar siempre local y ejecutar luac -p o un linter como luacheck para detectar las variables globales accidentales antes del tiempo de ejecución.

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

Asignar nil elimina las variables globales

Establecer una variable global en nil la elimina de _G y libera memoria. Esta es la forma correcta de «eliminar» una variable global. En el caso de las variables locales, dejar simplemente que salgan de su ámbito produce el mismo efecto: el recolector de basura recupera la memoria.

Tenga cuidado al pasar nil en una asignación múltiple: puede truncar la lista de argumentos en algunos contextos, especialmente cuando hay llamadas a funciones en el lado derecho.

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

Comprobación rápida

¿Cuál es el ámbito de una variable declarada con local x = 5 dentro del cuerpo de un bucle for?

Resumen: declaración de variables en Lua

Conclusiones principales de esta lección:

  • Las variables son globales de forma predeterminada; use siempre local
  • Las variables locales son más rápidas (no requieren una búsqueda hash) y más seguras
  • Asignación múltiple: a, b = b, a permite intercambiar valores en una sola línea
  • Todas las variables globales viven en _G; establecerlas en nil las elimina
  • Ocultación: una variable local interna oculta la variable externa sin modificarla
  • Por convención, use UPPER_CASE para las constantes

A continuación: operadores aritméticos, relacionales y lógicos.

Preguntas frecuentes

¿La lección «Declaración de variables en Lua» es gratis?

Sí — el texto completo de «Declaración de variables en Lua» 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 «Declaración de variables en Lua»?

Comprenda la diferencia entre variables globales y locales, así como las convenciones de nomenclatura. 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 2 de 4.

¿Cuánto tiempo toma la lección «Declaración de variables en Lua»?

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