0Pricing
Lua Academy · Aula

Visão geral dos tipos de dados do Lua

Explore os tipos nil, boolean, number, string, table, function e userdata.

Visão geral dos tipos de dados do Lua é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 1 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.

Boas-vindas ao Lua

Lua é uma linguagem de script leve, rápida e incorporável, usada em mecanismos de jogos, servidores Web e sistemas incorporados. Antes de escrever programas reais, é necessário entender como Lua representa os dados.

Lua tem 8 tipos básicos: nil, boolean, number, string, table, function, userdata e thread. Cada valor em Lua pertence exatamente a um desses tipos.

-- Check the type of any value with type()
print(type(42))        -- number
print(type("hello"))   -- string
print(type(true))      -- boolean
print(type(nil))       -- nil

nil: a ausência de valor

nil é a forma de Lua representar nada ou nenhum valor. É o único valor de seu tipo. Variáveis às quais nunca foi atribuído um valor contêm nil automaticamente.

Atribuir nil a uma variável global efetivamente a exclui. Em tabelas, definir uma chave como nil remove completamente essa entrada.

-- Unassigned variables are nil
print(x)          -- nil

x = 10
print(x)          -- 10

x = nil
print(x)          -- nil (variable is gone)

boolean: verdadeiro e falso

O tipo boolean tem exatamente dois valores: true e false. As regras de veracidade de Lua são simples, mas importantes: somente nil e false são falsos. Todo o restante — incluindo o número 0 e a cadeia de caracteres vazia "" — é verdadeiro.

Isso é diferente de muitas linguagens, nas quais 0 ou "" são considerados falsos.

-- Lua truthiness examples
if 0 then print("0 is truthy!") end       -- prints!
if "" then print("empty str is truthy!") end -- prints!
if nil then print("nil") else print("nil is falsy") end
if false then print("false") else print("false is falsy") end

number: inteiros e números de ponto flutuante

Lua 5.3+ tem dois subtipos de number: integer e float. Inteiros são valores exatos de 64 bits; números de ponto flutuante usam precisão dupla IEEE 754. Em Lua 5.1/5.2, todos os números são de precisão dupla.

A função math.type() diferencia os dois subtipos. A divisão com / sempre retorna um número de ponto flutuante; // (divisão com arredondamento para baixo) retorna um inteiro quando ambos os operandos são inteiros.

print(type(10))       -- number
print(type(10.5))     -- number
print(math.type(10))  -- integer
print(math.type(10.5))-- float
print(10 / 3)         -- 3.3333...
print(10 // 3)        -- 3  (floor division)

string: texto em Lua

As cadeias de caracteres em Lua são sequências imutáveis de bytes. Elas podem ser delimitadas por aspas simples, aspas duplas ou por colchetes longos [[...]] para cadeias com várias linhas. As cadeias entre colchetes longos ignoram a primeira quebra de linha e preservam literalmente todo o restante.

As cadeias de caracteres de Lua são internadas, portanto cadeias idênticas compartilham memória. O operador de comprimento # retorna a quantidade de bytes.

local s1 = 'single quotes'
local s2 = "double quotes"
local s3 = [[multi-line
long string]]

print(#s1)           -- 13
print(type(s1))      -- string
print(s1 .. " works") -- concatenation with ..

table: o contêiner universal

O tipo table é a única estrutura de dados composta de Lua, mas é suficientemente poderosa para implementar vetores, dicionários, objetos, conjuntos e muito mais. As tabelas são vetores associativos: mapeiam chaves para valores, e as chaves podem ser qualquer valor que não seja nil nem NaN.

As tabelas são criadas com chaves curvas {}. Tabelas no estilo de vetor usam chaves inteiras começando em 1.

-- Array style
local fruits = {"apple", "banana", "cherry"}
print(fruits[1])   -- apple (1-indexed!)

-- Dictionary style
local person = {name = "Alice", age = 30}
print(person.name) -- Alice
print(person["age"]) -- 30

function: valores de primeira classe

As funções em Lua são valores de primeira classe do tipo function. Elas podem ser armazenadas em variáveis, passadas como argumentos e retornadas por outras funções. Isso torna Lua naturalmente adequada a padrões de programação funcional.

É possível definir funções usando a palavra-chave function ou atribuir funções anônimas a variáveis. As duas formas são equivalentes.

-- Two equivalent ways to define a function
function greet(name)
  return "Hello, " .. name
end

local greet2 = function(name)
  return "Hello, " .. name
end

print(type(greet))   -- function
print(greet("Lua"))  -- Hello, Lua

userdata e thread

userdata representa dados arbitrários em C gerenciados pela aplicação hospedeira. Não é possível criar userdata em Lua pura — ele vem de extensões em C ou de ambientes de incorporação, como mecanismos de jogos. Isso permite que o código em C exponha objetos a scripts Lua.

thread representa corrotinas — linhas de execução independentes com suas próprias pilhas. As corrotinas serão exploradas em uma lição dedicada. Por enquanto, saiba que coroutine.create() retorna um valor do tipo thread.

-- thread type via coroutine
local co = coroutine.create(function()
  print("coroutine body")
end)

print(type(co))  -- thread

-- userdata comes from C, not creatable in pure Lua
-- type(io.stdin) == "file" is a userdata variant

Usando type() para inspecionar valores

A função integrada type() sempre retorna uma string que nomeia o tipo de seu argumento. Isso é útil para programação defensiva e depuração. É possível comparar diretamente o resultado com as strings que representam os nomes dos tipos.

Observe que type(nil) retorna a string "nil", não o próprio valor nil. Isso permite verificar com segurança se uma variável contém nil sem gerar erros.

local values = {42, "hi", true, nil, {}, function() end}

-- Note: nil in table stops ipairs early
for i = 1, 3 do
  print(i, type(values[i]))
end
-- 1  number
-- 2  string
-- 3  boolean

Diferenças de tipos em relação a outras linguagens

Se você vem de JavaScript, Python ou Java, algumas regras de tipos de Lua podem surpreendê-lo. Não há um tipo inteiro separado visível para type() — tanto inteiros quanto números de ponto flutuante retornam "number". Vetores não têm um tipo próprio — são apenas tabelas. Classes não existem — objetos são tabelas com metatabelas.

Entender essas diferenças evita erros comuns ao mudar de uma linguagem para outra.

-- No separate array type
local arr = {1, 2, 3}
print(type(arr))      -- table (not array!)

-- No separate integer type visible
print(type(1))        -- number
print(type(1.0))      -- number

-- math.type distinguishes
print(math.type(1))   -- integer
print(math.type(1.0)) -- float

Verificação rápida

O que type(0) retorna em Lua?

Recapitulação: visão geral dos tipos de dados de Lua

Você aprendeu os 8 tipos de Lua:

  • nil — ausência de valor; falso
  • boolean — verdadeiro/falso; somente nil e false são falsos
  • number — inteiro ou número de ponto flutuante; use math.type() para diferenciá-los
  • string — sequências imutáveis de bytes; use .. para concatenar
  • table — o contêiner universal para vetores e dicionários
  • function — valores de primeira classe que podem ser armazenados em variáveis
  • userdata — dados em C expostos a Lua
  • thread — identificadores de corrotinas

A seguir: declaração de variáveis — escopo global versus local.

Perguntas Frequentes

A aula “Visão geral dos tipos de dados do Lua” é grátis?

Sim — o texto completo de “Visão geral dos tipos de dados do 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 “Visão geral dos tipos de dados do Lua”?

Explore os tipos nil, boolean, number, string, table, function e userdata. 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 1 de 4.

Quanto tempo leva a aula “Visão geral dos tipos de dados do 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