0Pricing
Lua Academy · Aula

Analisador simples de expressões

Crie um analisador descendente recursivo para expressões aritméticas em Lua puro.

Analisador simples de expressões é 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.

Objetivo: analisar expressões aritméticas

Crie um analisador de descida recursiva em Lua puro que analise e avalie expressões como 3 + 4 * (2 - 1), respeitando a precedência dos operadores.

Tokenizador

Primeiro, converta a entrada em números, operadores e parênteses.

local function tokenize(expr)
  local tokens = {}
  for tok in expr:gmatch("[%d%.]+|[%+%-%*/%(%)%^]|%S") do
    tokens[#tokens+1] = tok
  end
  return tokens
end

Tokenizador aprimorado

Um tokenizador mais robusto usando padrões de correspondência.

local function tokenize(expr)
  local tokens = {}
  for tok in expr:gmatch("%d+%.?%d*|[%+%-%*/%(%)%^]") do
    tokens[#tokens+1] = tok
  end
  return tokens
end

Estado do analisador

O analisador mantém uma lista de tokens e uma posição. As funções auxiliares peek e consume avançam pelos tokens.

local function newParser(tokens)
  local pos = 1
  local function peek() return tokens[pos] end
  local function consume() pos = pos + 1; return tokens[pos-1] end
  return {peek=peek, consume=consume}
end

Gramática para expressões

A gramática respeita a precedência:

  • expressão = termo ((+ | -) termo)*
  • termo = fator ((* | /) fator)*
  • fator = número | (expressão) | -fator

Analisando termos

Analise expressões aditivas analisando termos e acumulando +/- da esquerda para a direita.

local parseExpr, parseTerm, parseFactor
parseExpr = function(p)
  local val = parseTerm(p)
  while p.peek() == "+" or p.peek() == "-" do
    local op = p.consume()
    local right = parseTerm(p)
    if op == "+" then val = val + right
    else val = val - right end
  end
  return val
end

Analisando fatores

Analise expressões multiplicativas, incluindo a exponenciação.

parseTerm = function(p)
  local val = parseFactor(p)
  while p.peek() == "*" or p.peek() == "/" do
    local op = p.consume()
    local right = parseFactor(p)
    if op == "*" then val = val * right
    else val = val / right end
  end
  return val
end

Analisando números e parênteses

Analise os átomos: literais, subexpressões entre parênteses e negação unária.

parseFactor = function(p)
  local tok = p.peek()
  if tok == "(" then
    p.consume()  -- (
    local val = parseExpr(p)
    p.consume()  -- )
    return val
  elseif tok == "-" then
    p.consume()
    return -parseFactor(p)
  else
    return tonumber(p.consume())
  end
end

Reunindo tudo

Converta em tokens, analise e avalie uma expressão.

local function eval(expr)
  local tokens = tokenize(expr)
  local parser = newParser(tokens)
  return parseExpr(parser)
end
print(eval("3 + 4 * 2"))      -- 11
print(eval("(3 + 4) * 2"))    -- 14
print(eval("2 ^ 10"))         -- 1024 (if ^ is supported)

Estendendo o analisador

Adicione variáveis, funções, operadores de comparação e literais de texto estendendo a gramática e adicionando novos casos a parseFactor.

Relato de erros

Acompanhe a linha e a coluna no tokenizador. Gere erros significativos: "Expected ')' at position 7, got '+'".

Geradores de analisadores

Para gramáticas complexas, use geradores de analisadores como LPEG (Gramáticas de Expressões de Análise). LPEG é muito mais poderoso e expressivo do que a análise de descida recursiva escrita manualmente para gramáticas grandes.

Pergunta sobre o analisador

O que um analisador de descida recursiva usa para impor a precedência dos operadores?

Recapitulação: analisador simples de expressões

Um analisador de descida recursiva usa uma função para cada regra da gramática, impondo naturalmente a precedência dos operadores por meio da hierarquia de chamadas. Faça a tokenização primeiro, then implemente as funções expressão → termo → fator. Estenda-o com variáveis e funções para criar uma linguagem de expressões completa.

Perguntas Frequentes

A aula “Analisador simples de expressões” é grátis?

Sim — o texto completo de “Analisador simples de expressões” é 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 “Analisador simples de expressões”?

Crie um analisador descendente recursivo para expressões aritméticas em Lua puro. 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 “Analisador simples de expressões”?

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. Princípios de design de DSL em Lua
  2. Sobrecarga de operadores para fluência em DSL
  3. Criando uma DSL de configuração
  4. Analisador simples de expressões
← Voltar para Lua Academy