Modelul Interpreter în Go

Ce este

Șablonul Interpreter evaluează propoziții dintr-un limbaj mic construind un arbore de obiecte-expresie — fiecare nod știe cum să se interpreteze pe sine. Numerele se interpretează ca ele însele; un nod de adunare își interpretează cele două părți și le adună.

Se potrivește limbajelor mici: filtre, formule, reguli simple. Limbajele reale merită unelte reale de analiză sintactică.

Exemplu: un calculator minuscul

Intrarea 3 + 4 - 2 devine un arbore de noduri Number, Add și Subtract. Un singur apel Interpret() pe rădăcină evaluează întreaga expresie.

Fiecare nod se interpretează pe sine

parse construiește arborele de la stânga la dreapta; Interpret() îl parcurge. Suportul pentru * ar însemna un singur tip nou de nod — cele existente rămân neatinse.

Scrie un program Go cu șablonul Interpreter: o interfață Expression cu Interpret, noduri Number, Add și Subtract, plus o funcție parse care transformă un șir precum „3 + 4 - 2” într-un arbore de expresii, de la stânga la dreapta. Interpretează expresia și afișează ecuația împreună cu rezultatul ei.

> Ieșire: program Go și rezultatul capturat

Prompt

Scrie un program Go cu șablonul Interpreter: o interfață Expression cu Interpret, noduri Number, Add și Subtract, plus o funcție parse care transformă un șir precum „3 + 4 - 2” într-un arbore de expresii, de la stânga la dreapta. Interpretează expresia și afișează ecuația împreună cu rezultatul ei.

Ieșire: program Go și rezultatul capturat

package main

import (
  "fmt"
  "strconv"
  "strings"
)

// Fiecare nod știe cum să se interpreteze pe sine.
type Expression interface {
  Interpret() int
}

type Number struct{ value int }

func (n Number) Interpret() int { return n.value }

type Add struct{ left, right Expression }

func (a Add) Interpret() int { return a.left.Interpret() + a.right.Interpret() }

type Subtract struct{ left, right Expression }

func (s Subtract) Interpret() int { return s.left.Interpret() - s.right.Interpret() }

func parse(input string) Expression {
  parts := strings.Fields(input)
  n, _ := strconv.Atoi(parts[0])
  var expr Expression = Number{n}

  for i := 1; i < len(parts); i += 2 {
    n, _ := strconv.Atoi(parts[i+1])
    if parts[i] == "+" {
      expr = Add{expr, Number{n}}
    } else {
      expr = Subtract{expr, Number{n}}
    }
  }
  return expr
}

func main() {
  input := "3 + 4 - 2"
  fmt.Println(input, "=", parse(input).Interpret())
}

Când să îl folosești

Folosește-l atunci când utilizatorii sau fișierele de configurare exprimă logica într-un limbaj mic creat de tine: filtre de căutare, formule de preț, reguli de validare.

Evită-l când „limbajul” înseamnă trei opțiuni fixe (folosește un switch) — sau când e un limbaj real (folosește un generator de parsere ori un motor existent).

Avantaje și dezavantaje

Avantaje: gramatica se transpune unu la unu în tipuri mici; operațiile noi înseamnă tipuri noi de noduri; arborii de expresii pot fi construiți, verificați și reutilizați.

Dezavantaje: devine incomod pe măsură ce gramatica crește; analiza sintactică tot trebuie scrisă; performanța este modestă față de logica compilată.