Go 表達式求值器
示例：表達式求值器
本篇將建立簡單算術表達式的一個求值器。 express
定義接口和類型
開始，先肯定要使用一個接口 Expr 來表明這種語言的任意一個表達式。暫時沒有任何方法，稍後再逐個添加：canvas
// Expr: 算術表達式
type Expr interface{}
咱們的表達式語言將包括如下符號：app
- 浮點數字面量
- 二元操做符：加減乘除（+、-、*、\/）
- 一元操做符：表示正數和負數的 -x 和 +x
- 函數調用：pow(x,y)、sin(x) 和 sqrt(x)
- 變量：好比 x、pi，本身定義一個變量名稱，每次能夠提供不用的值
還要有標準的操做符優先級，以及小括號。全部的值都是 float64 類型。 ide
下面是幾個示例表達式：svg
sqrt(A / pi) pow(x, 3) + pow(y, 3) (F - 32) * 5 / 9
下面5種具體類型表明特定類型的表達式：函數
- Var ： 表明變量引用。這個類型是可導出的，至於爲何，後面會講明
- literal ： 表明浮點數常量
- unary ： 表明有一個操做數的操做符表達式，操做數能夠是任意的 Expr
- binary ： 表明有兩個操做數的操做符表達式，操做數能夠是任意的 Expr
- call ： 表明函數調用，這裏限制它的 fn 字段只能是 pow、sin、sqrt
爲了要計算包含變量的表達式，還須要一個上下文（environment）來把變量映射到數值。全部接口和類型的定義以下：測試
package eval
// Expr: 算術表達式
type Expr interface {
// 返回表達式在 env 上下文下的值
Eval(env Env) float64
// Check 方法報告表達式中的錯誤，並把表達式中的變量加入 Vars 中
Check(vars map[Var]bool) error
}
// Var 表示一個變量，好比：x.
type Var string
// Env 變量到數值的映射關係
type Env map[Var]float64
// literal 是一個數字常量，好比：3.1415926
type literal float64
// unary 表示一元操做符表達式，好比：-x
type unary struct {
op rune // one of '+', '-'
x Expr
}
// binary 表示二元操做符表達式，好比：x+y.
type binary struct {
op rune // one of '+', '-', '*', '/'
x, y Expr
}
// call 表示函數調用表達式，好比：sin(x).
type call struct {
fn string // one of "pow", "sin", "sqrt"
args []Expr
}
在定義好各類類型後，發現每一個類型都須要提供一個 Eval 方法，因而加把這個方法加到接口中，已經添加到上面的代碼中了。
這個包只導出了 Expr、Var、Env。客戶端能夠在不接觸其餘表達式類型的狀況下使用這個求值器。 lua
定義方法
接下來實現每一個類型的 Eval 方法來知足接口：code
- Var 的 Eval 方法從上下文中查詢結果，若是變量不存在，則會返回0。
- literal 的 Eval 方法直接返回自己的值。
- unbary 的 Eval 方法首先對操做數遞歸求值，而後應用 op 操做符。
- binary 的 Eval 方法的處理邏輯和 unbary 同樣。
- call 的 Eval 方法先對 pow、sin、sqrt 函數的參數求值，再調用 math 包中的對應函數。
package eval
import (
"fmt"
"math"
)
func (v Var) Eval(env Env) float64 {
return env[v] // 若是查詢不到變量名，則返回類型的零值，就是0
}
func (l literal) Eval(_ Env) float64 {
return float64(l)
}
func (u unary) Eval(env Env) float64 {
switch u.op {
case '+':
return +u.x.Eval(env)
case '-':
return -u.x.Eval(env)
}
panic(fmt.Sprintf("unsupported unary operator: %q", u.op))
}
func (b binary) Eval(env Env) float64 {
switch b.op {
case '+':
return b.x.Eval(env) + b.y.Eval(env)
case '-':
return b.x.Eval(env) - b.y.Eval(env)
case '*':
return b.x.Eval(env) * b.y.Eval(env)
case '/':
return b.x.Eval(env) / b.y.Eval(env)
}
panic(fmt.Sprintf("unsupported binary operator: %q", b.op))
}
func (c call) Eval(env Env) float64 {
switch c.fn {
case "pow":
return math.Pow(c.args[0].Eval(env), c.args[1].Eval(env))
case "sin":
return math.Sin(c.args[0].Eval(env))
case "sqrt":
return math.Sqrt(c.args[0].Eval(env))
}
panic(fmt.Sprintf("unsupported function call: %s", c.fn))
}
某些方法可能會失敗，有些錯誤會致使 Eval 崩潰，還有些會致使返回不正確的結果。全部這些錯誤能夠在求值以前作檢查來發現，因此還須要一個Check方法。不過暫時能夠先無論Check方法，而是把 Eval 方法用起來，並經過測試進行驗證。 orm
Parse函數
要驗證 Eval 方法，首先須要獲得對象，而後調用對像的 Eval 方法。而對象須要經過解析字符串來獲取，這就須要一個 Parse 函數。
text/scanner 包的使用
詞法分析器 lexer 使用 text/scanner 包提供的掃描器 Scanner 類型來把輸入流分解成一系列的標記（token），包括註釋、標識符、字符串字面量和數字字面量。掃描器的 Scan 方法將提早掃描並返回下一個標記（類型爲 rune）。大部分標記（好比'('）都只包含單個rune，但 text/scanner 包也能夠支持由多個字符組成的記號。調用 Scan 會返回標記的類型，調用 TokenText 則會返回標記的文本。
由於每一個解析器可能須要屢次使用當前的記號，可是 Scan 會一直向前掃描，因此把掃描器封裝到一個 lexer 輔助類型中，其中保存了 Scan 最近返回的標記。下面是一個簡單的用法示例：
package main
import (
"fmt"
"os"
"strings"
"text/scanner"
)
type lexer struct {
scan scanner.Scanner
token rune // 當前標記
}
func (lex *lexer) next() { lex.token = lex.scan.Scan() }
func (lex *lexer) text() string { return lex.scan.TokenText() }
// consume 方法並無被使用到，包括後面的Pause函數
// 不過這是一個可複用的處理邏輯
func (lex *lexer) consume(want rune) {
if lex.token != want { // 注意: 錯誤處理不是這篇的重點，簡單粗暴的處理了
panic(fmt.Sprintf("got %q, want %q", lex.text(), want))
}
lex.next()
}
func main() {
for _, input := range os.Args[1:] {
lex := new(lexer)
lex.scan.Init(strings.NewReader(input))
lex.scan.Mode = scanner.ScanIdents | scanner.ScanInts | scanner.ScanFloats
fmt.Println(input, ":")
lex.next()
for lex.token != scanner.EOF {
fmt.Println("\t", scanner.TokenString(lex.token), lex.text())
lex.next()
}
}
}
執行效果以下：
PS G:\Steed\Documents\Go\src\localdemo\parse> go run main.go "sqrt(A / pi)" "pow(x, 3) + pow(y, 3)" "(F - 32) * 5 / 9"
sqrt(A / pi) :
Ident sqrt
"(" (
Ident A
"/" /
Ident pi
")" )
pow(x, 3) + pow(y, 3) :
Ident pow
"(" (
Ident x
"," ,
Int 3
")" )
"+" +
Ident pow
"(" (
Ident y
"," ,
Int 3
")" )
(F - 32) * 5 / 9 :
"(" (
Ident F
"-" -
Int 32
")" )
"*" *
Int 5
"/" /
Int 9
PS G:\Steed\Documents\Go\src\localdemo\parse>
Parse 函數
Parse 函數，遞歸地將字符串解析爲表達式，下面是完整的代碼：
package eval
import (
"fmt"
"strconv"
"strings"
"text/scanner"
)
type lexer struct {
scan scanner.Scanner
token rune // 當前標記
}
func (lex *lexer) next() { lex.token = lex.scan.Scan() }
func (lex *lexer) text() string { return lex.scan.TokenText() }
type lexPanic string
// describe 返回一個描述當前標記的字符串，用於錯誤處理
func (lex *lexer) describe() string {
switch lex.token {
case scanner.EOF:
return "end of file"
case scanner.Ident:
return fmt.Sprintf("identifier %s", lex.text())
case scanner.Int, scanner.Float:
return fmt.Sprintf("number %s", lex.text())
}
return fmt.Sprintf("%q", rune(lex.token)) // any other rune
}
func precedence(op rune) int {
switch op {
case '*', '/':
return 2
case '+', '-':
return 1
}
return 0
}
// Parse 將字符串解析爲表達式
//
// expr = num a literal number, e.g., 3.14159
// | id a variable name, e.g., x
// | id '(' expr ',' ... ')' a function call
// | '-' expr a unary operator (+-)
// | expr '+' expr a binary operator (+-*/)
//
func Parse(input string) (_ Expr, err error) {
defer func() {
// 選擇性地使用 recover
// 已經將 panic value 設置成特殊類型 lexPanic
// 在 recover 時對 panic value 進行檢查
switch x := recover().(type) {
case nil:
// no panic
case lexPanic:
// 若是發現 panic value 是特殊類型，就將這個 panic 做爲 errror 處理
err = fmt.Errorf("%s", x)
default:
// 若是不是，則按照正常的 panic 進行處理
panic(x)
}
}()
lex := new(lexer)
lex.scan.Init(strings.NewReader(input))
lex.scan.Mode = scanner.ScanIdents | scanner.ScanInts | scanner.ScanFloats
lex.next() // 獲取第一個標記
e := parseExpr(lex)
if lex.token != scanner.EOF {
return nil, fmt.Errorf("unexpected %s", lex.describe())
}
return e, nil
}
func parseExpr(lex *lexer) Expr { return parseBinary(lex, 1) }
// binary = unary ('+' binary)*
// parseBinary 遇到優先級低於 prec1 的運算符時就中止
// 這個遞歸處理計算優先級的循環策略比較難理解
func parseBinary(lex *lexer, prec1 int) Expr {
lhs := parseUnary(lex)
for prec := precedence(lex.token); prec >= prec1; prec-- {
for precedence(lex.token) == prec {
op := lex.token
lex.next() // consume operator
rhs := parseBinary(lex, prec+1) // 優先級加1，進入下一次遞歸
lhs = binary{op, lhs, rhs}
}
}
return lhs
}
// unary = '+' expr | primary
func parseUnary(lex *lexer) Expr {
if lex.token == '+' || lex.token == '-' {
op := lex.token
lex.next() // consume '+' or '-'
return unary{op, parseUnary(lex)}
}
return parsePrimary(lex)
}
// primary = id
// | id '(' expr ',' ... ',' expr ')'
// | num
// | '(' expr ')'
func parsePrimary(lex *lexer) Expr {
switch lex.token {
case scanner.Ident:
id := lex.text()
lex.next() // consume Ident
if lex.token != '(' {
return Var(id)
}
lex.next() // consume '('
var args []Expr
if lex.token != ')' {
for {
args = append(args, parseExpr(lex))
if lex.token != ',' {
break
}
lex.next() // consume ','
}
if lex.token != ')' {
msg := fmt.Sprintf("got %q, want ')'", lex.token)
panic(lexPanic(msg))
}
}
lex.next() // consume ')'
return call{id, args}
case scanner.Int, scanner.Float:
f, err := strconv.ParseFloat(lex.text(), 64)
if err != nil {
panic(lexPanic(err.Error()))
}
lex.next() // consume number
return literal(f)
case '(':
lex.next() // consume '('
e := parseExpr(lex)
if lex.token != ')' {
msg := fmt.Sprintf("got %s, want ')'", lex.describe())
panic(lexPanic(msg))
}
lex.next() // consume ')'
return e
}
msg := fmt.Sprintf("unexpected %s", lex.describe())
panic(lexPanic(msg))
}
總體的邏輯都比較難理解。parseBinary 函數是負責解析二元表達式的，其中包括了對運算符優先級的處理（邏輯比較難懂，本身想不出來，看也沒徹底看懂，之後有相似的實現或許能夠借鑑）。
測試函數
下面的 TestEval 函數用於測試求值器，它使用 testing 包，使用基於表的測試方式。表格中定義了三個表達式併爲每一個表達式準備了不一樣的上下文。第一個表達式用於根據圓面積A求半徑，第二個用於計算兩個變量x和y的立方和，第三個把華氏溫度F轉爲攝氏溫度：
package eval
import (
"fmt"
"math"
"testing"
)
func TestEval(t *testing.T) {
tests := []struct {
expr string
env Env
want string
}{
{"sqrt(A / pi)", Env{"A": 87616, "pi": math.Pi}, "167"},
{"pow(x, 3) + pow(y, 3)", Env{"x": 12, "y": 1}, "1729"},
{"pow(x, 3) + pow(y, 3)", Env{"x": 9, "y": 10}, "1729"},
{"5 / 9 * (F - 32)", Env{"F": -40}, "-40"},
{"5 / 9 * (F - 32)", Env{"F": 32}, "0"},
{"5 / 9 * (F - 32)", Env{"F": 212}, "100"},
}
var prevExpr string
for _, test := range tests {
// 僅在表達式變動時才輸出
if test.expr != prevExpr {
fmt.Printf("\n%s\n", test.expr)
prevExpr = test.expr
}
expr, err := Parse(test.expr)
if err != nil {
t.Error(err) // 解析出錯
continue
}
got := fmt.Sprintf("%.6g", expr.Eval(test.env))
fmt.Printf("\t%v => %s\n", test.env, got)
if got != test.want {
t.Errorf("%s.Eval() in %v = %q, want %q\n", test.expr, test.env, got, test.want)
}
}
}
對於表格中的每一行記錄，先解析表達式，在上下文中求值，再輸出表達式。啓用 -v 選項查看測試的輸出：
PS G:\Steed\Documents\Go\src\gopl\output\expression_evaluator\eval> go test -v
=== RUN TestEval
sqrt(A / pi)
map[A:87616 pi:3.141592653589793] => 167
pow(x, 3) + pow(y, 3)
map[x:12 y:1] => 1729
map[x:9 y:10] => 1729
5 / 9 * (F - 32)
map[F:-40] => -40
map[F:32] => 0
map[F:212] => 100
--- PASS: TestEval (0.00s)
PASS
ok gopl/output/expression_evaluator/eval 0.329s
PS G:\Steed\Documents\Go\src\gopl\output\expression_evaluator\eval>
check 方法
到目前爲止，全部的輸入都是合法的，可是並非總能如此。即便在解釋性語言中，經過語法檢查來發現靜態錯誤（即不用運行程序也能檢測出來的錯誤）也是很常見的。經過分離靜態檢查和動態檢查，能夠更快發現錯誤，也能夠只在運行前檢查一次，而不用在表達式求值時每次都檢查。
如今就給 Expr 加上一個 Check 方法，用於在表達式語法樹上檢查靜態錯誤。這個 Check 方法有一個 vars 參數，並非由於須要傳參，而是爲了讓遞歸調用的實現起來更方便，具體看後面的代碼和說明：
// Expr: 算術表達式
type Expr interface {
// 返回表達式在 env 上下文下的值
Eval(env Env) float64
// Check 方法報告表達式中的錯誤，並把表達式中的變量加入 Vars 中
Check(vars map[Var]bool) error
}
具體的 Check 方法以下所示。literal 和 Var 的求值不可能出錯，因此直接返回 nil。unary 和 binary 的方法首先檢查操做符是否合法，再遞歸地檢查操做數。相似地，call 的方法首先檢查函數是不是已知的，而後檢查參數個數，最後遞歸地檢查每一個參數：
package eval
import (
"fmt"
"strings"
)
func (v Var) Check(vars map[Var]bool) error {
vars[v] = true
return nil
}
func (literal) Check(vars map[Var]bool) error {
return nil
}
func (u unary) Check(vars map[Var]bool) error {
if !strings.ContainsRune("+-", u.op) {
return fmt.Errorf("unexpected unary op %q", u.op)
}
return u.x.Check(vars)
}
func (b binary) Check(vars map[Var]bool) error {
if !strings.ContainsRune("+-*/", b.op) {
return fmt.Errorf("unexpected binary op %q", b.op)
}
if err := b.x.Check(vars); err != nil {
return err
}
return b.y.Check(vars)
}
func (c call) Check(vars map[Var]bool) error {
arity, ok := numParams[c.fn]
if !ok {
return fmt.Errorf("unknown function %q", c.fn)
}
if len(c.args) != arity {
return fmt.Errorf("call to %s has %d args, want %d",
c.fn, len(c.args), arity)
}
for _, arg := range c.args {
if err := arg.Check(vars); err != nil {
return err
}
}
return nil
}
// 已知的函數名稱和對應的參數個數
var numParams = map[string]int{"pow": 2, "sin": 1, "sqrt": 1}
關於遞歸的實現。Check 的輸入參數是一個 Var 集合，這個集合是表達式中的變量名。要讓表達式能成功求值，上下文必須包含全部的變量。從邏輯上來說，這個集合應當是 Check 的輸出結果而不是輸入參數，但由於這個方法是遞歸調用的，在這種狀況下使用參數更爲方便。調用方最初調用時須要提供一個空的集合。
Web 應用
這篇裏已經有一個繪製函數 z=f(x,y) 的 SVG 圖形的實現了：
http://www.javashuo.com/article/p-rwltglje-ey.html
不過當時的函數 f 是在編譯的時候指定的。既然這裏能夠對字符串形式的表達式進行解析、檢查和求值，那麼就能夠構建一個 Web 應用，在運行時從客戶端接收一個表達式，並繪製函數的曲面圖。可使用 vars 集合來檢查表達式是不是一個只有兩個變量x、y的函數（爲了簡單起見，還提供了半徑r，因此其實是3個變量）。使用 Check 方法來拒絕掉不規範的表達式，這樣就不會在下面函數的40000個計算過程當中（100x100的格子，每個有4個角）重複這些檢查。
表達式求值器已經完成了，把它做爲一個包引入。而後把繪製函數圖形加上 Web 應用的代碼從新實現一遍，完整的代碼以下：
package main
import (
"fmt"
"io"
"log"
"math"
"net/http"
)
import "gopl/output/expression_evaluator/eval"
const (
width, height = 600, 320 // canvas size in pixels
cells = 100 // number of grid cells
xyrange = 30.0 // x, y axis range (-xyrange..+xyrange)
xyscale = width / 2 / xyrange // pixels per x or y unit
zscale = height * 0.4 // pixels per z unit
)
var sin30, cos30 = 0.5, math.Sqrt(3.0 / 4.0) // sin(30°), cos(30°)
func corner(f func(x, y float64) float64, i, j int) (float64, float64) {
// find point (x,y) at corner of cell (i,j)
x := xyrange * (float64(i)/cells - 0.5)
y := xyrange * (float64(j)/cells - 0.5)
z := f(x, y) // compute surface height z
// project (x,y,z) isometrically onto 2-D SVG canvas (sx,sy)
sx := width/2 + (x-y)*cos30*xyscale
sy := height/2 + (x+y)*sin30*xyscale - z*zscale
return sx, sy
}
func surface(w io.Writer, f func(x, y float64) float64) {
fmt.Fprintf(w, "<svg xmlns='http://www.w3.org/2000/svg' "+
"style='stroke: grey; fill: white; stroke-width: 0.7' "+
"width='%d' height='%d'>", width, height)
for i := 0; i < cells; i++ {
for j := 0; j < cells; j++ {
ax, ay := corner(f, i+1, j)
bx, by := corner(f, i, j)
cx, cy := corner(f, i, j+1)
dx, dy := corner(f, i+1, j+1)
fmt.Fprintf(w, "<polygon points='%g,%g %g,%g %g,%g %g,%g'/>\n",
ax, ay, bx, by, cx, cy, dx, dy)
}
}
fmt.Fprintln(w, "</svg>")
}
// 組合瞭解析（Parse方法）和檢查（Check方法）步驟
func parseAndCheck(s string) (eval.Expr, error) {
if s == "" {
return nil, fmt.Errorf("empty expression")
}
expr, err := eval.Parse(s)
if err != nil {
return nil, err
}
vars := make(map[eval.Var]bool)
if err := expr.Check(vars); err != nil {
return nil, err
}
for v := range vars {
if v != "x" && v != "y" && v != "r" {
return nil, fmt.Errorf("undefined variable: %s", v)
}
}
return expr, nil
}
// 解析並檢查Get請求的表達式，用它來建立一個有兩個變量的匿名函數。
// 這個匿名函數與曲面繪製程序中的f有一樣的簽名。
func plot(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
expr, err := parseAndCheck(r.Form.Get("expr"))
if err != nil {
http.Error(w, "bad expr: "+err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("Content-Type", "image/svg+xml")
surface(w, func(x, y float64) float64 {
r := math.Hypot(x, y) // distance from (0,0)
return expr.Eval(eval.Env{"x": x, "y": y, "r": r})
})
}
func main() {
fmt.Println("http://localhost:8000/plot?expr=sin(-x)*pow(1.5,-r)")
fmt.Println("http://localhost:8000/plot?expr=pow(2,sin(y))*pow(2,sin(x))/12")
fmt.Println("http://localhost:8000/plot?expr=sin(x*y/10)/10")
http.HandleFunc("/plot", plot)
log.Fatal(http.ListenAndServe("localhost:8000", nil))
}
重點看 parseAndCheck 函數，組合瞭解析和檢查的步驟。 還有 plot 函數，函數的簽名與 http.HandlerFunc 相似。解析並檢查 HTTP 請求中的表達式，並用它來建立一個有兩個變量的匿名函數。這個匿名函數與原始曲面繪製程序中的 f 有一樣的簽名，而且能對用戶提供的表達式進行求值。上下文定義了x、y和半徑r。最後，plot 調用了 surface 函數，這裏略作了修改，本來直接使用函數 f，如今把函數 f 做爲參數傳入。
相關文章
- 1. 表達式求值
- 2. 表達式·表達式樹·表達式求值
- 3. 表達式求值-中綴表達式-後綴表達式
- 4. 後綴表達式求值
- 5. 中綴表達式求值
- 6. 關係表達式求值
- 7. hdu 4192(表達式求值)
- 8. P1981 表達式求值
- 9. 棧------表達式求值
- 10. Mathematica 表達式求值
- 更多相關文章...
- • SQLite 表達式 - SQLite教程
- • XQuery FLWOR 表達式 - XQuery 教程
- • Docker容器實戰(七) - 容器眼光下的文件系統
- • Docker容器實戰(六) - 容器的隔離與限制
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 表達式求值
- 2. 表達式·表達式樹·表達式求值
- 3. 表達式求值-中綴表達式-後綴表達式
- 4. 後綴表達式求值
- 5. 中綴表達式求值
- 6. 關係表達式求值
- 7. hdu 4192(表達式求值)
- 8. P1981 表達式求值
- 9. 棧------表達式求值
- 10. Mathematica 表達式求值