Lua Academy · Lektion

Einfacher Ausdrucksparser

Erstellen Sie in reinem Lua einen Parser mit rekursivem Abstieg für arithmetische Ausdrücke

Einfacher Ausdrucksparser ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Ziel: Arithmetische Ausdrücke parsen

Erstellen Sie in reinem Lua einen Parser mit rekursivem Abstieg, der Ausdrücke wie 3 + 4 * (2 - 1) parst und auswertet und dabei die Operatorpriorität berücksichtigt.

Tokenizer

Tokenisieren Sie die Eingabe zunächst in Zahlen, Operatoren und Klammern.

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

Verbesserter Tokenizer

Ein robusterer Tokenizer, der gmatch-Muster verwendet.

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

Parserzustand

Der Parser führt eine Tokenliste und eine Position mit. Hilfsfunktionen wie peek und consume bewegen sich durch die 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

Grammatik für Ausdrücke

Die Grammatik berücksichtigt die Operatorpriorität:

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

Terme parsen

Parsen Sie additive Ausdrücke, indem Sie Terme parsen und + beziehungsweise - von links nach rechts zusammenfassen.

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

Faktoren parsen

Parsen Sie multiplikative Ausdrücke einschließlich der Potenzierung.

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

Zahlen und Klammern parsen

Parsen Sie Atome: Literale, Ausdrücke in Klammern und die unäre Negation.

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

Alles zusammenführen

Tokenisieren, parsen und werten Sie einen Ausdruck aus.

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)

Den Parser erweitern

Fügen Sie Variablen, Funktionen, Vergleichsoperatoren und Zeichenkettenliterale hinzu, indem Sie die Grammatik erweitern und neue Fälle zu parseFactor hinzufügen.

Fehler melden

Erfassen Sie beim Tokenisieren Zeile und Spalte. Lösen Sie aussagekräftige Fehler aus: "Expected ')' at position 7, got '+'".

Parsergeneratoren

Verwenden Sie für komplexe Grammatiken Parsergeneratoren wie LPEG (Parsing Expression Grammars). LPEG ist für große Grammatiken wesentlich leistungsfähiger und ausdrucksstärker als ein von Hand geschriebener Parser mit rekursivem Abstieg.

Parserfrage

Was verwendet ein Parser mit rekursivem Abstieg, um die Operatorpriorität durchzusetzen?

Zusammenfassung: Einfacher Ausdrucksparser

Ein Parser mit rekursivem Abstieg verwendet für jede Grammatikregel eine eigene Funktion und setzt die Operatorpriorität durch die Aufrufhierarchie auf natürliche Weise durch. Tokenisieren Sie zuerst und implementieren Sie anschließend die Funktionen expr → term → factor. Erweitern Sie den Parser um Variablen und Funktionen, um eine vollständige Ausdruckssprache zu erhalten.

Häufig gestellte Fragen

Ist die Lektion „Einfacher Ausdrucksparser“ kostenlos?

Ja — der vollständige Text von „Einfacher Ausdrucksparser“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Einfacher Ausdrucksparser“?

Erstellen Sie in reinem Lua einen Parser mit rekursivem Abstieg für arithmetische Ausdrücke Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Einfacher Ausdrucksparser“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Lua Academy