인터프리터 패턴

인터프리터 패턴??

인터프리터 패턴은 특정 언어의 문법 규칙을 분류하고 이를 사용하여 해당 언어로 작성된 문장을 해석하는 패턴입니다.보지마.

이 패턴은 각 문법 규칙을 나타냅니다. AbstractExpression 클래스와 해당 하위 클래스로 구성것이 가능하다. 이러한 클래스는 해석하려는 언어의 구문 요소를 나타내고 이를 해석하는 데 필요한 메서드를 구현합니다.

인터프리터 패턴에서 컨텍스트 클래스를 사용하거나 생략할 수 있습니다.

Context 클래스는 해석할 언어의 상태를 저장하고 Expression 클래스는 해당 상태를 참조하여 결과를 반환합니다. Context 클래스는 ConcreteContext 클래스로 구현되며 해석할 언어의 상태를 저장하는 데 사용됩니다.

Interpreter 패턴은 자주 사용되지는 않지만 복잡한 문법을 ​​가진 언어를 해석하는 데 유용합니다.예를 들어, SQL 쿼리 또는 수학 표현식 등을 해석하는 데 사용됩니다.당신은 할 수 있습니다. 해석기 패턴은 다른 디자인 패턴과 함께 사용할 수도 있습니다. 예를 들어 복잡한 언어를 처리하기 위해 복합 패턴과 함께 사용할 수 있습니다.

말이 어렵지만 예를 들면 이해하기 쉽습니다.

type Direction int

const (
    NORTH Direction = iota
    EAST
    SOUTH
    WEST
)

type AbstractExpression interface {
    Interpret(robot *Robot) error
}

type MoveExpression struct {
    steps int
}

func (m *MoveExpression) Interpret(robot *Robot) error {
    for i := 0; i < m.steps; i++ {
        robot.MoveForward()
    }
    return nil
}

type TurnLeftExpression struct{}

func (t *TurnLeftExpression) Interpret(robot *Robot) error {
    robot.TurnLeft()
    return nil
}

type TurnRightExpression struct{}

func (t *TurnRightExpression) Interpret(robot *Robot) error {
    robot.TurnRight()
    return nil
}

type Robot struct {
    x      int
    y      int
    facing Direction
}

func (r *Robot) MoveForward() {
    switch r.facing {
    case NORTH:
        r.y++
    case EAST:
        r.x++
    case SOUTH:
        r.y--
    case WEST:
        r.x--
    }
}

func (r *Robot) TurnLeft() {
    r.facing = (r.facing + 3) % 4
}

func (r *Robot) TurnRight() {
    r.facing = (r.facing + 1) % 4
}

type Interpreter struct {
    expressions ()AbstractExpression
}

func (i *Interpreter) Interpret(robot *Robot) error {
    for _, expression := range i.expressions {
        err := expression.Interpret(robot)
        if err != nil {
            return err
        }
    }
    return nil
}

func main() {
    robot := &Robot{x: 0, y: 0, facing: EAST}

    interpreter := &Interpreter{
        expressions: ()AbstractExpression{
            &MoveExpression{steps: 3},
            &TurnLeftExpression{},
            &MoveExpression{steps: 2},
            &TurnRightExpression{},
            &MoveExpression{steps: 1},
        },
    }

    err := interpreter.Interpret(robot)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Printf("Robot is at (%d, %d) facing %d\n", robot.x, robot.y, robot.facing)
    }
}

위의 코드에서 Robot 클래스는 Context와 같은 역할을 합니다.