0Pricing
Lua Academy · Lección

Parser sencillo de expresiones

Construya un parser descendente recursivo para expresiones aritméticas en Lua puro.

Parser sencillo de expresiones es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

Objetivo: analizar expresiones aritméticas

Construya un analizador descendente recursivo en Lua puro que analice y evalúe expresiones como 3 + 4 * (2 - 1), respetando la precedencia de operadores.

Tokenizador

Primero, convierta la entrada en tokens: números, operadores y paréntesis.

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

Tokenizador mejorado

Un tokenizador más robusto que utiliza patrones de gmatch.

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

Estado del analizador

El analizador mantiene una lista de tokens y una posición. Las funciones auxiliares peek y consume avanzan por los 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 de las expresiones

La gramática respeta la precedencia:

  • expr = term ((+ | -) term)*
  • term = factor ((* | /) factor)*
  • factor = number | (expr) | -factor

Análisis de términos

Analice las expresiones aditivas analizando los términos y acumulando los operadores +/- de izquierda a derecha.

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

Análisis de factores

Analice las expresiones multiplicativas, incluida la exponenciación.

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

Análisis de números y paréntesis

Analice los átomos: literales, subexpresiones entre paréntesis y negación unaria.

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

Integración

Convierta en tokens, analice y evalúe una expresión.

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)

Ampliación del analizador

Añada variables, funciones, operadores de comparación y literales de cadena ampliando la gramática y agregando nuevos casos a parseFactor.

Informe de errores

Registre la línea y la columna en el tokenizador. Genere errores significativos: "Expected ')' at position 7, got '+'".

Generadores de analizadores

Para gramáticas complejas, utilice generadores de analizadores como LPEG (gramáticas de expresiones de análisis). LPEG es mucho más potente y expresivo que un analizador descendente recursivo escrito manualmente para gramáticas grandes.

Pregunta sobre analizadores

¿Qué utiliza un analizador descendente recursivo para imponer la precedencia de operadores?

Resumen: analizador sencillo de expresiones

Un analizador descendente recursivo utiliza una función por cada regla gramatical e impone naturalmente la precedencia de operadores mediante la jerarquía de llamadas. Primero convierta la entrada en tokens y, después, implemente las funciones expr → term → factor. Amplíelo con variables y funciones para obtener un lenguaje de expresiones completo.

Preguntas frecuentes

¿La lección «Parser sencillo de expresiones» es gratis?

Sí — el texto completo de «Parser sencillo de expresiones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Parser sencillo de expresiones»?

Construya un parser descendente recursivo para expresiones aritméticas en Lua puro. Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Parser sencillo de expresiones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Principios de diseño de DSL en Lua
  2. Sobrecarga de operadores para expresiones fluidas en DSL
  3. Construcción de un DSL de configuración
  4. Parser sencillo de expresiones
← Volver a Lua Academy