0Pricing
Lua Academy · Aula

Coerção e conversão de tipos

Aprenda a coerção automática entre cadeias de caracteres e números, além de tonumber/tostring explícitos.

Coerção e conversão de tipos é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 4 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.

O que é coerção de tipos?

Coerção de tipos é a conversão automática de um valor de um tipo para outro quando o contexto exige isso. Lua realiza coerção em duas direções específicas: de string para número em contextos aritméticos e de número para string em contextos de concatenação.

Diferentemente de JavaScript, a coerção em Lua é restrita e previsível. Lua não converte automaticamente valores booleanos em números nem tabelas em strings.

-- String to number (arithmetic context)
print("10" + 5)     -- 15  (coerced)
print("3.14" * 2)   -- 6.28

-- Number to string (concatenation context)
print(10 .. "px")   -- 10px
print(3.14 .. "!")  -- 3.14!

-- No boolean coercion
-- print(true + 1)  -- ERROR!

Regras de coerção de string para número

Quando uma string aparece em uma expressão aritmética, Lua tenta convertê-la em um número. Se a string não representar um número válido, um erro em tempo de execução será gerado. Strings numéricas válidas incluem inteiros ("42"), números de ponto flutuante ("3.14"), números hexadecimais ("0xff") e notação científica ("1e3").

Strings com espaços em branco no início ou no fim são aceitas — Lua remove esses espaços durante a coerção.

print("42" + 0)      -- 42    (integer)
print("3.14" + 0)    -- 3.14  (float)
print("0xff" + 0)    -- 255   (hex)
print("  10  " + 0)  -- 10    (whitespace ok)
print("1e3" + 0)     -- 1000.0

-- This will error:
-- print("hello" + 0)  -- attempt to perform arithmetic on a string value

Coerção de número para string

Quando você concatena um número usando .., Lua converte automaticamente o número em uma string. Inteiros se tornam sua representação decimal; números de ponto flutuante podem ganhar casas decimais. Para ter controle preciso sobre o formato, use sempre tostring() ou string.format(), em vez de depender da coerção implícita.

print(10 .. "!")       -- 10!
print(3.14 .. "!")     -- 3.14!
print(1/3 .. "!")      -- 0.33333333333333!

-- Explicit is better for precision
print(string.format("%.2f", 1/3))  -- 0.33
print(tostring(10))                -- 10
print(tostring(10.0))              -- 10.0

tonumber(): conversão explícita

tonumber(v) converte explicitamente um valor em um número. Em caso de sucesso, retorna o número convertido; se a conversão falhar, retorna nil — nunca gera um erro. É possível especificar uma base opcional (2–36) para a interpretação de inteiros, permitindo conversões binárias, octais e hexadecimais.

Sempre verifique se o valor retornado por tonumber() é nil ao processar a entrada do usuário.

print(tonumber("42"))      -- 42
print(tonumber("3.14"))    -- 3.14
print(tonumber("0xFF"))    -- 255
print(tonumber("hello"))   -- nil (no error!)
print(tonumber(true))      -- nil

-- Base conversion
print(tonumber("ff", 16))  -- 255
print(tonumber("11", 2))   -- 3   (binary)
print(tonumber("77", 8))   -- 63  (octal)

tostring(): conversão explícita

tostring(v) converte qualquer valor em uma string. Para números, produz uma string em representação decimal ou em notação científica. Para valores booleanos, produz "true" ou "false". Para nil, retorna "nil". Para tabelas e funções, retorna um endereço como "table: 0x...", a menos que um método metamágico __tostring esteja definido.

print(tostring(42))         -- 42
print(tostring(3.14))       -- 3.14
print(tostring(true))       -- true
print(tostring(false))      -- false
print(tostring(nil))        -- nil
print(tostring({}))         -- table: 0x...

-- Useful for safe concatenation
local val = nil
local msg = "Value: " .. tostring(val)
print(msg)   -- Value: nil

math.tointeger()

math.tointeger(x) (Lua 5.3+) converte um número de ponto flutuante em um inteiro somente se o valor tiver uma representação inteira exata. Se a conversão causar perda de precisão, retorna nil. Isso é mais seguro do que math.floor(), que sempre tem sucesso, mas pode truncar silenciosamente.

Use isso quando precisar validar estritamente um inteiro, por exemplo, ao trabalhar com APIs que exigem inteiros exatos.

print(math.tointeger(5.0))   -- 5   (exact)
print(math.tointeger(5.5))   -- nil (not exact)
print(math.tointeger(2^53))  -- 9007199254740992

-- Contrast with math.floor
print(math.floor(5.9))       -- 5   (truncates)
print(math.floor(5.0))       -- 5

-- Check before use
local n = math.tointeger(val) or error("need integer")

Coerção em comparações

Lua não faz coerção de tipos em comparações de igualdade. 1 == "1" é sempre false porque os operandos têm tipos diferentes. No entanto, os operadores relacionais (<, > etc.) acionam a coerção entre strings e números — mas somente quando ambos os operandos são do mesmo tipo. Misturar tipos em comparações de ordenação gera um erro.

print(1 == "1")    -- false (no coercion)
print(1 == 1.0)    -- true  (int/float equal)

-- Ordering: same type only
print("abc" < "abd")  -- true (string compare)
print(1 < 2)          -- true (number compare)

-- This ERRORS: mixing string and number
-- print(1 < "2")  -- attempt to compare number with string

Prática: analisando a entrada do usuário

Um padrão muito comum em programas Lua é ler uma string da entrada do usuário (por exemplo, usando io.read()) e convertê-la em um número. Use sempre tonumber() e verifique se o resultado é nil para tratar entradas inválidas de forma adequada, em vez de causar uma falha.

-- Safe input parsing pattern
local function parseNumber(input)
  local n = tonumber(input)
  if n == nil then
    return nil, "Invalid number: " .. tostring(input)
  end
  return n, nil
end

local val, err = parseNumber("42")
print(val, err)   -- 42  nil

local val2, err2 = parseNumber("abc")
print(val2, err2) -- nil  Invalid number: abc

Armadilhas de precisão de inteiros e números de ponto flutuante

Números de ponto flutuante têm precisão limitada. Operações que misturam inteiros e números de ponto flutuante podem produzir resultados inesperados devido à representação IEEE 754. O maior inteiro exato que pode ser representado como um número de precisão dupla é 2^53 = 9.007.199.254.740.992. Inteiros maiores perdem precisão quando armazenados como números de ponto flutuante.

No Lua 5.3+, inteiros nativos de 64 bits permitem representar exatamente valores de até 2^63-1, que são muito maiores. Use sempre aritmética inteira quando a exatidão for importante.

-- Float precision limit
print(2^53)            -- 9.007...e+15
print(2^53 + 1 == 2^53) -- true (precision lost!)

-- Integer stays exact
local big = math.maxinteger
print(big)             -- 9223372036854775807
print(math.type(big))  -- integer

-- Mixing promotes to float
print(math.type(1 + 1.0))  -- float

Conversões de formato de strings

string.format() é a ferramenta mais poderosa para conversão de números em strings quando você precisa controlar a precisão, o preenchimento e a notação. Ela segue os especificadores de formato de printf da linguagem C. Use-a para exibição, saída em arquivos e qualquer situação em que a representação padrão de tostring() não seja adequada.

print(string.format("%d", 255))      -- 255
print(string.format("%x", 255))      -- ff
print(string.format("%05d", 42))     -- 00042
print(string.format("%.2f", 3.14159)) -- 3.14
print(string.format("%e", 12345.0))  -- 1.234500e+04
print(string.format("%s=%d", "x", 10)) -- x=10

Verificação rápida

O que tonumber("hello") retorna em Lua?

Recapitulação: coerção e conversão de tipos

O que você aprendeu:

  • Lua converte automaticamente strings em números na aritmética e números em strings na concatenação
  • tonumber() retorna nil em caso de falha — verifique sempre!
  • tostring() converte qualquer valor em uma string com segurança
  • A igualdade (==) nunca faz coerção — tipos diferentes nunca são iguais
  • Use string.format() para formatar números com precisão
  • O limite de precisão de números de ponto flutuante é 2^53; use inteiros nativos para valores exatos grandes

A seguir: fluxo de controle com if/elseif/else e laços.

Perguntas Frequentes

A aula “Coerção e conversão de tipos” é grátis?

Sim — o texto completo de “Coerção e conversão de tipos” é 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 “Coerção e conversão de tipos”?

Aprenda a coerção automática entre cadeias de caracteres e números, além de tonumber/tostring explícitos. 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 4 de 4.

Quanto tempo leva a aula “Coerção e conversão de tipos”?

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