0Pricing
Lua Academy · Aula

Declarando variáveis em Lua

Entenda as variáveis globais e locais e as convenções de nomenclatura.

Declarando variáveis em Lua é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 2 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.

Variáveis globais e locais

Em Lua, as variáveis são globais por padrão. Escrever x = 10 sem a palavra-chave local cria uma variável global acessível de qualquer lugar. Usar local x = 10 restringe a variável ao bloco atual e aos blocos aninhados.

Prefira sempre local por motivos de desempenho e segurança. Acessar uma variável local é mais rápido do que acessar uma global, pois as globais exigem uma busca em tabela hash na tabela _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)

A palavra-chave local

A palavra-chave local declara uma variável com escopo restrito ao bloco envolvente mais próximo: o corpo de uma função, um bloco do...end, o corpo de um laço ou um trecho de arquivo. As variáveis locais são criadas na linha em que são declaradas e deixam de existir ao final do bloco.

É possível declarar várias variáveis locais em uma única linha e inicializá-las simultaneamente. Variáveis locais não inicializadas recebem nil por padrão.

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

Convenções para nomes de variáveis

Os identificadores de Lua seguem estas regras: devem começar com uma letra ou sublinhado, seguido por letras, dígitos ou sublinhados. Lua diferencia maiúsculas de minúsculas, portanto Value, value e VALUE são três variáveis diferentes.

Por convenção: use camelCase ou snake_case para variáveis comuns, UPPER_CASE para constantes e prefixe os campos privados de módulos com um sublinhado. Evite nomes de uma única letra, exceto para contadores de laços.

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

A tabela global _G

Todas as variáveis globais de Lua ficam em uma tabela especial chamada _G. Escrever x = 10 equivale a escrever _G.x = 10. É possível inspecionar todas as globais iterando sobre _G, o que é útil para depuração, mas perigoso em código de produção.

No Lua 5.2+, _ENV é a tabela de ambiente efetiva, e _G é inicializada apontando para ela. Entender isso permite colocar o código em uma área isolada substituindo _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)

Atribuição múltipla

Lua oferece atribuição múltipla: é possível atribuir valores a várias variáveis em uma única instrução. O lado direito é avaliado primeiro e, em seguida, os valores são atribuídos da esquerda para a direita. Se houver mais variáveis do que valores, as excedentes recebem nil. Se houver mais valores do que variáveis, os excedentes serão descartados.

Isso torna trivial trocar variáveis sem uma variável temporária.

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

Escopo e limites de blocos

Os delimitadores de bloco de Lua são: do...end, corpos de funções, if/elseif/else...end, while...end, repeat...until e for...end. Cada um cria um novo nível de escopo. Blocos do...end são úteis exclusivamente para limitar o escopo, sem qualquer outra lógica.

Uma variável local declarada no cabeçalho de um laço for fica restrita ao corpo do laço — ela não vaza para fora dele.

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: a convenção local

Lua não tem uma palavra-chave const integrada. A convenção é usar nomes UPPER_CASE e local para indicar que um valor não deve mudar. Colocar constantes no início de um módulo como variáveis locais também fornece ao compilador JIT uma indicação de que esses valores são estáveis.

Para obter imutabilidade verdadeira, é possível usar uma tabela proxy com __newindex que gere um erro quando houver uma modificação — isso será abordado na lição sobre metatabelas.

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

Ocultação de variáveis

A ocultação ocorre quando um escopo interno declara uma variável local com o mesmo nome de uma variável externa. A declaração interna cria uma variável completamente nova que oculta a externa dentro de seu escopo. A variável externa não é alterada e volta a ficar visível quando o escopo interno termina.

A ocultação pode causar confusão; prefira nomes únicos entre escopos aninhados, embora às vezes ela seja intencional, como ao reutilizar nomes de variáveis de laço em laços aninhados.

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)

Evitando a poluição do escopo global

Variáveis globais acidentais são um erro comum em Lua: digitar incorretamente o nome de uma variável local cria silenciosamente uma nova variável global. O módulo strict.lua (comumente incluído em projetos) detecta leituras e gravações de globais não declaradas adicionando uma metatabela a _G.

Uma abordagem mais simples é sempre usar local e executar luac -p ou um analisador estático como luacheck para detectar globais acidentais antes da execução.

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

Atribuir nil exclui variáveis globais

Definir uma variável global como nil a remove de _G, liberando memória. Essa é a forma correta de "excluir" uma variável global. Para variáveis locais, simplesmente permitir que saiam do escopo produz o mesmo efeito — o coletor de lixo recupera a memória.

Tenha cuidado ao passar nil em uma atribuição múltipla: isso pode truncar a lista de argumentos em alguns contextos, especialmente quando há chamadas de função no lado direito.

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

Verificação rápida

Qual é o escopo de uma variável declarada com local x = 5 dentro do corpo de um laço for?

Recapitulação: declaração de variáveis em Lua

Principais aprendizados desta lição:

  • As variáveis são globais por padrão — use sempre local
  • Variáveis locais são mais rápidas (não exigem busca em hash) e mais seguras
  • Atribuição múltipla: a, b = b, a troca os valores em uma linha
  • Todas as globais ficam em _G; atribuir nil a elas as exclui
  • Ocultação: uma variável local interna oculta a variável externa sem alterá-la
  • Use UPPER_CASE para constantes por convenção

A seguir: operadores aritméticos, relacionais e lógicos.

Perguntas Frequentes

A aula “Declarando variáveis em Lua” é grátis?

Sim — o texto completo de “Declarando variáveis em Lua” é 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 “Declarando variáveis em Lua”?

Entenda as variáveis globais e locais e as convenções de nomenclatura. 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 2 de 4.

Quanto tempo leva a aula “Declarando variáveis em Lua”?

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