0Pricing
Lua Academy · Aula

Noções básicas de cadeias: concatenação e comprimento

Use .. para concatenação, # para comprimento e string.rep/reverse.

Noções básicas de cadeias: concatenação e comprimento é 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.

Concatenação de Textos com ..

lua usa .. (dois pontos) para concatenar textos. Isso funciona com textos e números (os números são convertidos automaticamente). Diferentemente de + em muitas linguagens, + em lua é apenas aritmético — usá-lo em textos causa um erro.

local first = "Hello"
local second = "World"
print(first .. ", " .. second .. "!")  -- Hello, World!

-- Numbers auto-converted
local age = 30
print("Age: " .. age)   -- Age: 30

-- Bad: print("x" + "y")  ERROR: arithmetic on string

Operador de Comprimento #

O operador # retorna o comprimento em byte de um texto. Para textos ASCII, isso equivale à quantidade de caracteres. Para textos UTF-8 com vários bytes, # conta bytes, não caracteres — um emoji UTF-8 conta como 4. Use uma biblioteca UTF-8 para obter comprimentos precisos em caracteres.

print(#"hello")        -- 5
print(#"")             -- 0
print(#"café")         -- 5 (c,a,f,é=2bytes)

local s = "Lua"
for i = 1, #s do
  io.write(string.byte(s, i) .. " ")
end
print()  -- 76 117 97

string.rep e string.reverse

string.rep(s, n, sep) repete o texto s exatamente n vezes, com um separador opcional. string.reverse(s) inverte a ordem dos bytes do texto. Ambas retornam novos textos — textos de lua são imutáveis.

print(string.rep("ab", 3))       -- ababab
print(string.rep("ha", 3, "-"))  -- ha-ha-ha
print(string.rep("x", 0))        -- (empty)
print(string.reverse("hello"))   -- olleh
print(string.reverse("12345"))   -- 54321

string.upper e string.lower

string.upper(s) e string.lower(s) convertem caracteres ASCII. Elas não lidam com Unicode — caracteres não ASCII permanecem inalterados. Para uma comparação que ignore maiúsculas e minúsculas, converta ambos os textos para lower antes de compará-los.

print(string.upper("hello"))     -- HELLO
print(string.lower("WORLD"))     -- world
print(string.upper("Lua 5.4!"))  -- LUA 5.4!

-- Case-insensitive comparison
local a = "Hello"
local b = "hello"
print(a:lower() == b:lower())    -- true

Sintaxe de Método com Dois-pontos

Funções de texto podem ser chamadas usando a sintaxe de dois-pontos em valores de texto: s:upper() em vez de string.upper(s). Isso funciona porque textos têm uma metatabela com __index = string, portanto todas as funções da biblioteca de textos ficam acessíveis como métodos em qualquer texto.

local s = "  hello world  "
print(s:upper())         -- HELLO WORLD
print(s:len())           -- 15
print(s:rep(2, "|"))     -- same as string.rep(s,2,"|")

-- Chain calls
print(("lua"):upper():reverse())  -- AUL

Imutabilidade de Textos

Textos de lua são imutáveis. Não é possível modificar caracteres diretamente. Cada operação sobre um texto cria um novo texto. Para concatenações intensas dentro de laços, use uma tabela para acumular as partes e table.concat ao final — é muito mais eficiente do que repetir ...

-- Efficient string building
local parts = {}
for i = 1, 5 do
  parts[i] = "item" .. i
end
local result = table.concat(parts, ", ")
print(result)  -- item1, item2, item3, item4, item5

-- Slow! Creates 5 intermediate strings:
-- local s = ""
-- for i = 1, 5 do s = s .. "item" .. i end

table.concat para Unir Textos

table.concat(t, sep, i, j) une elementos de um array em um texto usando um separador. Isso funciona apenas com valores de texto e número — tabelas ou booleanos causam um erro. Esta é a forma mais rápida de criar textos a partir de muitas partes.

local parts = {"one", "two", "three", "four"}
print(table.concat(parts, ", "))          -- one, two, three, four
print(table.concat(parts, " | ", 2, 3))  -- two | three

-- Building CSV
local row = {1, "Alice", 95, true}
-- Need tostring for non-string values:
for i, v in ipairs(row) do row[i] = tostring(v) end
print(table.concat(row, ","))

Comparação de Textos

Textos são comparados lexicograficamente pelo valor dos bytes. Letras maiúsculas vêm antes das minúsculas em ASCII (A=65, a=97), portanto "Z" < "a" é verdadeiro. Use string.lower em ambos os lados para ordenar sem diferenciar maiúsculas de minúsculas.

print("abc" < "abd")    -- true
print("abc" < "abcd")   -- true (shorter)
print("Z" < "a")        -- true (Z=90, a=97)
print("10" < "9")       -- true (lexicographic!)
print(10 < 9)           -- false (numeric)

-- Sort strings case-insensitively
local words = {"Banana","apple","Cherry"}
table.sort(words, function(a,b) return a:lower()<b:lower() end)
print(table.concat(words,", "))

tostring e tonumber

tostring(v) converte qualquer valor em sua representação textual. tonumber(s, base) analisa uma cadeia de caracteres e a converte em um número. tonumber retorna nil se a análise falhar, ao contrário de muitas linguagens que lançam uma exceção. A base pode ser de 2 a 36 para a análise de inteiros.

print(tostring(42))        -- 42
print(tostring(true))      -- true
print(tostring(nil))       -- nil
print(tostring({1,2}))     -- table: 0x...

print(tonumber("3.14"))    -- 3.14
print(tonumber("0xff"))    -- 255 (hex)
print(tonumber("11",2))    -- 3 (binary)
print(tonumber("abc"))     -- nil (invalid)

Internação de cadeias de caracteres

Lua interna cadeias de caracteres curtas: conteúdos idênticos compartilham o mesmo objeto na memória. Isso faz com que == em cadeias de caracteres seja, na prática, uma comparação de ponteiros após uma verificação de hash — muito rápida. A internação também significa que criar uma cadeia de caracteres tem um pequeno custo adicional (cálculo do hash), mas as cadeias repetidas não têm custo.

local s1 = "hello"
local s2 = "hel" .. "lo"

-- Same content, interned to same object
print(s1 == s2)   -- true
print(#s1)        -- 5

-- Long strings may not be interned
-- They are still compared correctly by value
local long1 = string.rep("x", 1000)
local long2 = string.rep("x", 1000)
print(long1 == long2)  -- true

Verificação rápida

Qual é a maneira mais eficiente de construir uma cadeia de caracteres longa a partir de muitas partes pequenas em Lua?

Recapitulação: fundamentos das cadeias de caracteres

Pontos principais:

  • .. concatena; nunca use + para cadeias de caracteres
  • #s conta bytes (não caracteres Unicode)
  • s:upper(), s:lower(), s:rep(n, sep), s:reverse()
  • Cadeias de caracteres são imutáveis — cada operação retorna uma nova cadeia
  • Construa cadeias grandes com uma tabela e table.concat
  • tostring/tonumber para conversão de tipos

Perguntas Frequentes

A aula “Noções básicas de cadeias: concatenação e comprimento” é grátis?

Sim — o texto completo de “Noções básicas de cadeias: concatenação e comprimento” é 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 “Noções básicas de cadeias: concatenação e comprimento”?

Use .. para concatenação, # para comprimento e string.rep/reverse. 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 “Noções básicas de cadeias: concatenação e comprimento”?

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. Noções básicas de cadeias: concatenação e comprimento
  2. Localização e extração de substrings
  3. string.format para saída
  4. string.gsub e string.gmatch
← Voltar para Lua Academy