0Pricing
Lua Academy · Leçon

Analyseur d’expressions simple

Construisez un analyseur descendant récursif pour les expressions arithmétiques en Lua pur.

Analyseur d’expressions simple est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Objectif : analyser des expressions arithmétiques

Construisez un analyseur syntaxique par descente récursive en Lua pur, capable d'analyser et d'évaluer des expressions comme 3 + 4 * (2 - 1) tout en respectant la priorité des opérateurs.

Analyseur lexical

Commencez par découper l'entrée en nombres, opérateurs et parenthèses.

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

Analyseur lexical amélioré

Un analyseur lexical plus robuste utilisant des motifs gmatch.

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

État de l'analyseur

L'analyseur conserve une liste de jetons et une position. Les fonctions auxiliaires peek et consume parcourent les jetons.

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

Grammaire des expressions

La grammaire respecte la priorité :

  • expression = terme ((+ | -) terme)*
  • terme = facteur ((* | /) facteur)*
  • facteur = nombre | (expression) | -facteur

Analyse des termes

Analysez les expressions additives en analysant les termes et en combinant les opérateurs +/- de gauche à droite.

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

Analyse des facteurs

Analysez les expressions multiplicatives, y compris l'exponentiation.

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

Analyse des nombres et des parenthèses

Analysez les atomes : littéraux, sous-expressions entre parenthèses et négation unaire.

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

Assemblage

Tokenisez, analysez et évaluez une expression.

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)

Extension de l'analyseur

Ajoutez des variables, des fonctions, des opérateurs de comparaison et des littéraux de chaîne en étendant la grammaire et en ajoutant de nouveaux cas à parseFactor.

Signalement des erreurs

Suivez la ligne et la colonne dans l'analyseur lexical. Levez des erreurs explicites : "Expected ')' at position 7, got '+'".

Générateurs d'analyseurs syntaxiques

Pour les grammaires complexes, utilisez des générateurs d'analyseurs syntaxiques comme LPEG (grammaires d'expressions d'analyse). LPEG est beaucoup plus puissant et expressif qu'une descente récursive écrite à la main pour les grandes grammaires.

Question sur l'analyseur

Qu'utilise un analyseur syntaxique par descente récursive pour imposer la priorité des opérateurs ?

Récapitulatif : analyseur simple d'expressions

Un analyseur syntaxique par descente récursive utilise une fonction par règle de grammaire, ce qui impose naturellement la priorité des opérateurs grâce à la hiérarchie des appels. Tokenisez d'abord, then implémentez les fonctions expression → terme → facteur. Étendez-le avec des variables et des fonctions pour obtenir un langage complet d'expressions.

Questions Fréquemment Posées

La leçon « Analyseur d’expressions simple » est-elle gratuite ?

Oui — le texte complet de « Analyseur d’expressions simple » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Analyseur d’expressions simple » ?

Construisez un analyseur descendant récursif pour les expressions arithmétiques en Lua pur. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Analyseur d’expressions simple » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Principes de conception des DSL en Lua
  2. Surcharge des opérateurs pour maîtriser les DSL
  3. Construire un DSL de configuration
  4. Analyseur d’expressions simple
← Retour à Lua Academy