0Pricing
Lua Academy · Aula

Localização e extração de substrings

Use string.find e string.sub para localizar e extrair texto.

Localização e extração de substrings é 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.

Fundamentos de string.find

string.find(s, pattern, init, plain) procura um padrão em s, começando em init (por padrão, 1). Retorna as posições inicial e final da correspondência ou nil se ela não for encontrada. Com plain=true, trata o padrão como uma cadeia literal (sem caracteres especiais).

local s = "hello world"
local i, j = string.find(s, "world")
print(i, j)    -- 7  11

-- Plain search (literal string)
local i2, j2 = string.find("a+b=5", "+", 1, true)
print(i2, j2)  -- 2  2

-- Not found
print(string.find(s, "xyz"))  -- nil

string.sub para extração

string.sub(s, i, j) extrai a subcadeia da posição i até a posição j (inclusive). Índices negativos contam a partir do final: -1 é o último caractere. Se j for omitido, o padrão será o final da cadeia.

local s = "hello world"
print(string.sub(s, 1, 5))    -- hello
print(string.sub(s, 7))       -- world
print(string.sub(s, -5))      -- world
print(string.sub(s, 1, -7))   -- hello
print(s:sub(7, 11))           -- world (method syntax)

Combinando find e sub

Combine string.find e string.sub para localizar e extrair subcadeias. Primeiro encontre o delimitador e depois extraia as partes ao redor dele. Essa é a abordagem básica para dividir cadeias de caracteres.

local s = "key=value"
local i = string.find(s, "=")
if i then
  local key = string.sub(s, 1, i - 1)
  local val = string.sub(s, i + 1)
  print(key, val)   -- key  value
end

string.match para captura de padrões

string.match(s, pattern, init) retorna as subcadeias capturadas que correspondem ao padrão. Se o padrão não tiver capturas, retorna a correspondência inteira. Se nada corresponder, retorna nil. As capturas são definidas com parênteses no padrão.

local date = "2024-03-15"
local y, m, d = string.match(date, "(%d+)-(%d+)-(%d+)")
print(y, m, d)   -- 2024  03  15

-- No capture: returns the whole match
local num = string.match("price: 42.5 USD", "%d+%.%d+")
print(num)       -- 42.5

Encontrando a última ocorrência

Para encontrar a última ocorrência de uma subcadeia, faça uma busca em um laço avançando a posição inicial ou pesquise a partir do final. A abordagem padrão é chamar string.find repetidamente, usando a posição logo após a correspondência anterior, até que ele retorne nil.

local function findLast(s, sub)
  local last_i, last_j
  local i, j = string.find(s, sub, 1, true)
  while i do
    last_i, last_j = i, j
    i, j = string.find(s, sub, j + 1, true)
  end
  return last_i, last_j
end

local i, j = findLast("a/b/c/d", "/")
print(i, j)   -- 6  6

Extraindo extensões de arquivos

Um uso prático de string.match é extrair a extensão de um nome de arquivo. O padrão "([^%.]+)$" captura a última sequência sem ponto no final da cadeia, ou "%.([^%.]+)$" para capturar apenas o trecho após o último ponto.

local function getExt(filename)
  return string.match(filename, "%.([^%.]+)$")
end

print(getExt("photo.jpg"))        -- jpg
print(getExt("archive.tar.gz"))   -- gz
print(getExt("README"))           -- nil
print(getExt("config.lua.bak"))   -- bak

Dividindo cadeias de caracteres

Lua não tem uma operação integrada para dividir cadeias de caracteres, mas você pode implementá-la com string.gmatch. Itere sobre todas as sequências que não sejam delimitadores ou use um padrão que capture o conteúdo entre os delimitadores.

local function split(s, sep)
  local result = {}
  local pattern = "([^" .. sep .. "]+)"
  for part in string.gmatch(s, pattern) do
    result[#result+1] = part
  end
  return result
end

local parts = split("one,two,three,four", ",")
for i, p in ipairs(parts) do
  print(i, p)
end
-- 1 one  2 two  3 three  4 four

Removendo espaços em branco

Remova os espaços em branco iniciais e finais capturando-os e descartando-os. O padrão "^%s*(.-)%s*$" usa um quantificador não guloso .- para capturar o conteúdo mínimo entre espaços opcionais no início e no fim.

local function trim(s)
  return string.match(s, "^%s*(.-)%s*$")
end

print("|" .. trim("  hello  ") .. "|")  -- |hello|
print("|" .. trim("  \t\n") .. "|")    -- ||
print("|" .. trim("no spaces") .. "|")  -- |no spaces|

Extraindo números de um texto

Use string.gmatch com um padrão numérico para extrair todos os números de uma cadeia de caracteres. O padrão %-?%d+%.?%d* corresponde a um sinal negativo opcional, dígitos, um ponto decimal opcional e mais dígitos.

local text = "Revenue: $1,234.56 Expenses: $567.89 Net: $666.67"
local numbers = {}
for n in string.gmatch(text, "%d+%.?%d*") do
  numbers[#numbers+1] = tonumber(n)
end
for _, v in ipairs(numbers) do
  io.write(v .. " ")
end
print()  -- 1 234.0 56.0 567.89 666.67

Normalização das posições em cadeias

Os índices negativos de Lua permitem trabalhar a partir do final de uma cadeia de caracteres. string.sub(s, -n) obtém os últimos n caracteres. Combine isso com #s para calcular posições. Entender a relação entre índices positivos e negativos evita erros de deslocamento de uma posição.

local s = "abcdefgh"

-- Last 3 characters
print(s:sub(-3))     -- fgh

-- All but last 2
print(s:sub(1, -3))  -- abcdef

-- Character at position from end
print(s:sub(-1, -1)) -- h
print(s:sub(-4, -2)) -- efg

Verificação rápida

O que string.sub("hello", 2, -2) retorna?

Recapitulação: localização e extração

Resumo:

  • string.find(s, pat, init, plain) — retorna início, fim ou nil
  • string.sub(s, i, j) — extrai por posição; índices negativos contam a partir do final
  • string.match(s, pat) — retorna as capturas ou a correspondência inteira
  • Use plain=true para uma busca literal (sem caracteres especiais)
  • Implemente a divisão com string.gmatch
  • Remova espaços nas extremidades com o padrão "^%s*(.-)%s*$"

Perguntas Frequentes

A aula “Localização e extração de substrings” é grátis?

Sim — o texto completo de “Localização e extração de substrings” é 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 “Localização e extração de substrings”?

Use string.find e string.sub para localizar e extrair texto. 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 “Localização e extração de substrings”?

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