曹大带我学 Go之初识 Ast 的威力

本文转载自微信公众号「码农桃花源」，作者小X。转载本文请联系码农桃花源公众号。

成都创新互联是一家集网站建设,福绵企业网站建设,福绵品牌网站建设,网站定制,福绵网站建设报价,网络营销,网络优化,福绵网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。

你好，我是小X。

曹大最近开 Go 课程了，小X 正在和曹大学 Go。

这个系列会讲一些从课程中学到的让人醍醐灌顶的东西，拨云见日，带你重新认识 Go。

抽象语法树是编译过程中的一个中间产物，一般简单了解一下就行了。但我们可以把 Go 语言的整个 parser 和 ast 包直接拿来用，在一些场景下有很大的威力。

什么是 ast 呢，我从维基百科上摘录了一段：

在计算机科学中，抽象语法树(Abstract Syntax Tree，AST)，或简称语法树(Syntax tree)，是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。

核心就是说 ast 能以一种树的形式表示代码结构。有了树结构，就可以对它做遍历，能干很多事。

假定一个场景

假定一个场景：我们可以从司机平台的某个接口获取司机的各种特征，例如：年龄、订单数、收入、每天驾驶时长、驾龄、平均车速、被投诉次数……数据一般采用 json 来传递。

司机平台的运营小姐姐经常需要搞一些活动，例如选出：

  • 订单数超过 10000，且驾龄超过 5 年的老司机
  • 每天驾驶时小于 3 小时，且收入超过 500 的高效司机
  • 年龄大于 40，且平均速度大于 70 的“狂野”司机
  • ……

这些规则并不是固定的，经常在变化，但总归是各种司机特征的组合。

为了简化，我们选取 2 个特征，并用一个 Driver 结构体来表示：

 
 
 
 
      
  
  
  
  1. type Driver struct { 
    2.   
  
  
  
  2.  Orders         int 
    3.   
  
  
  
  3.  DrivingYears   int 
    4.   
  
  
  
  4. } 
    5.

为了配合运营搞活动，我们需要根据运营给的规则来判断一个司机是否符合要求。

如果公司人多，可以安排一个 rd 专门伺候运营小姐姐，每次做活动都来手动修改代码，也不是不可以。并且其实挺简单，我们来写一个示例代码：

 
 
 
 
      
  
  
  
  1. // 从第三方获取司机特征，json 表示 
    2.   
  
  
  
  2. func getDriverRemote() []byte { 
    3.   
  
  
  
  3.  return []byte(`{"orders":100000,"driving_years":18}`) 
    4.   
  
  
  
  4. } 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6. // 判断是否为老司机 
    7.   
  
  
  
  7. func isOldDriver(d *Driver) bool { 
    8.   
  
  
  
  8.  if d.Orders > 10000 && d.DrivingYears > 5 { 
    9.   
  
  
  
  9.   return true 
    10.   
  
  
  
  10.  } 
    11.   
  
  
  
  11.  return false 
    12.   
  
  
  
  12. } 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14. func main() { 
    15.   
  
  
  
  15.  bs := getDriverRemote() 
    16.   
  
  
  
  16.  var d Driver 
    17.   
  
  
  
  17.  json.Unmarshal(bs, &d) 
    18.   
  
  
  
  18.  fmt.Println(isOldDriver(&d)) 
    19.   
  
  
  
  19. } 
    20.

直接来看 main 函数：getDriverRemote 模拟从第三方 RPC 获取一个司机的特征数据，用 json 表示。接着 json.Unmarshal 来反序列化 Driver 结构体。最后调用 isOldDriver 函数来判断此司机是否符合运营的规则。

isOldDriver 根据 Driver 结构体的 2 个字段使用 if 语句来判断此司机是否为老司机。

确实还挺简单。

但是每次更新规则还得经过一次完整的上线流程，也挺麻烦的。有没有更简单的办法呢?使得我们可以直接解析运营小组姐给我们的一个用字符串表示的规则，并直接返回一个 bool 型的值，表示是否满足条件。

有的!

接下来就是本文的核心内容，如何使用 ast 来完成同样的功能。

直观地理解如何用 ast 解析规则

使用 ast 包提供的一些函数，我们可以非常方便地将如下的规则字符串：

 
 
 
 
      
  
  
  
  1. orders > 10000 && driving_years > 5 
    2.

解析成一棵这样的二叉树：

规则二叉树

其中，ast.BinaryExpr 代表一个二元表达式，它由 X 和 Y 以及符号 OP 三部分组成。最上面的一个 BinaryExpr 表示规则的左半部分和右半部分相与。

很明显，左半部分就是：orders > 10000，而右半部分则是：driving_years > 5。神奇的是，左半部分和右半部分恰好又都是一个二元表达式。

左半部分的 orders > 10000 其实也是最小的叶子节点，它可以算出来一个 bool 值。把它拆开来之后，又可以分成 X、Y、OP。X 是 orders，OP 是 ">"，Y 则是 "10000"。其中 X 表示一个标识符，是 ast.Ident 类型，Y 表示一个基本类型的字面量，例如 int 型、字符串型……是 ast.BasicLit 类型。

右半部分的 driving_years > 18 也可以照此拆分。

然后，从 json 中取出这个司机的 orders 字段的值为 100000，它比 10000 大，所以左半部分算出来为 true。同理，右半部分算出来也为 true。最后，再算最外层的 "&&"，结果仍然为 true。

至此，直接根据规则字符串，我们就可以算出来结果。

如果写成程序的话，就是一个 dfs 的遍历过程。如果不是叶子结点，那就是二元表达式结点，那就一定有 X、Y、OP 部分。递归地遍历 X，如果 X 是叶子结点，那就结束递归，并计算出 X 的值……

这里再展示一个用 ast 包打印出来的抽象语法树：

Go 打印 ast

上图中，1、2、3 表示最外层的二元表达式;4、5、6 则表示左边这个二元表达式。

结合这张图，再参考 ast 包的相关结构体 代码，就非常清晰了。例如 ast.BinaryExpr 的代码如下：

 
 
 
 
      
  
  
  
  1. // A BinaryExpr node represents a binary expression. 
    2.   
  
  
  
  2. BinaryExpr struct { 
    3.   
  
  
  
  3.  X     Expr        // left operand 
    4.   
  
  
  
  4.  OpPos token.Pos   // position of Op 
    5.   
  
  
  
  5.  Op    token.Token // operator 
    6.   
  
  
  
  6.  Y     Expr        // right operand 
    7.   
  
  
  
  7. } 
    8.

它有 X、Y、OP，甚至还解析出了 Op 的位置，用 OpPos 表示。

如果你还对实现感兴趣，那就继续看下面的原理分析部分，否则可以直接跳到结尾总结部分。

原理分析

还是用上面那个例子，我们直接写一个表达式：

 
 
 
 
      
  
  
  
  1. orders > 10000 && driving_years > 5 
    2.

接下来用 ast 来解析规则并判断真假。

 
 
 
 
      
  
  
  
  1. func main() { 
    2.   
  
  
  
  2.  m := map[string]int64{"orders": 100000, "driving_years": 18} 
    3.   
  
  
  
  3.  rule := `orders > 10000 && driving_years > 5` 
    4.   
  
  
  
  4.  fmt.Println(Eval(m, rule)) 
    5.   
  
  
  
  5. } 
    6.

为了简单，我们直接用 map 来代替 json，道理是一样的，仅仅为了方便。

Eval 函数判断 rule 的真假：

 
 
 
 
      
  
  
  
  1. // Eval : 计算 expr 的值 
    2.   
  
  
  
  2. func Eval(m map[string]int64, expr string) (bool, error) { 
    3.   
  
  
  
  3.  exprAst, err := parser.ParseExpr(expr) 
    4.   
  
  
  
  4.  if err != nil { 
    5.   
  
  
  
  5.   return false, err 
    6.   
  
  
  
  6.  } 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.  // 打印 ast 
    9.   
  
  
  
  9.  fset := token.NewFileSet() 
    10.   
  
  
  
  10.  ast.Print(fset, exprAst) 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.  return judge(exprAst, m), nil 
    13.   
  
  
  
  13. } 
    14.

先将表达式解析成 Expr，接着调用 judge 函数计算结果：

 
 
 
 
      
  
  
  
  1. // dfs 
    2.   
  
  
  
  2. func judge(bop ast.Node, m map[string]int64) bool { 
    3.   
  
  
  
  3.     // 叶子结点 
    4.   
  
  
  
  4.  if isLeaf(bop) { 
    5.   
  
  
  
  5.   // 断言成二元表达式 
    6.   
  
  
  
  6.   expr := bop.(*ast.BinaryExpr) 
    7.   
  
  
  
  7.   x := expr.X.(*ast.Ident) // 左边 
    8.   
  
  
  
  8.   y := expr.Y.(*ast.BasicLit) // 右边 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.   // 如果是 ">" 符号 
    11.   
  
  
  
  11.   if expr.Op == token.GTR { 
    12.   
  
  
  
  12.    left := m[x.Name] 
    13.   
  
  
  
  13.    right, _ := strconv.ParseInt(y.Value, 10, 64) 
    14.   
  
  
  
  14.    return left > right 
    15.   
  
  
  
  15.   } 
    16.   
  
  
  
  16.   return false 
    17.   
  
  
  
  17.  } 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.  // 不是叶子节点那么一定是 binary expression（我们目前只处理二元表达式） 
    20.   
  
  
  
  20.  expr, ok := bop.(*ast.BinaryExpr) 
    21.   
  
  
  
  21.  if !ok { 
    22.   
  
  
  
  22.   println("this cannot be true") 
    23.   
  
  
  
  23.   return false 
    24.   
  
  
  
  24.  } 
    25.   
  
  
  
  25.  
    26.   
  
  
  
  26.  // 递归地计算左节点和右节点的值 
    27.   
  
  
  
  27.  switch expr.Op { 
    28.   
  
  
  
  28.  case token.LAND: 
    29.   
  
  
  
  29.   return judge(expr.X, m) && judge(expr.Y, m) 
    30.   
  
  
  
  30.  case token.LOR: 
    31.   
  
  
  
  31.   return judge(expr.X, m) || judge(expr.Y, m) 
    32.   
  
  
  
  32.  } 
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34.  println("unsupported operator") 
    35.   
  
  
  
  35.  return false 
    36.   
  
  
  
  36. } 
    37.

judge 使用 dfs 递归地计算表达式的值。

递归地终止条件是叶子节点：

 
 
 
 
      
  
  
  
  1. // 判断是否是叶子节点 
    2.   
  
  
  
  2. func isLeaf(bop ast.Node) bool { 
    3.   
  
  
  
  3.  expr, ok := bop.(*ast.BinaryExpr) 
    4.   
  
  
  
  4.  if !ok { 
    5.   
  
  
  
  5.   return false 
    6.   
  
  
  
  6.  } 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.  // 二元表达式的最小单位，左节点是标识符，右节点是值 
    9.   
  
  
  
  9.  _, okL := expr.X.(*ast.Ident) 
    10.   
  
  
  
  10.  _, okR := expr.Y.(*ast.BasicLit) 
    11.   
  
  
  
  11.  if okL && okR { 
    12.   
  
  
  
  12.   return true 
    13.   
  
  
  
  13.  } 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.  return false 
    16.   
  
  
  
  16. } 
    17.

总结

今天这篇文章主要讲了如何用 ast 包和 parser 包解析一个二元表达式，并见识到了它的威力，利用它可以做成一个非常简单的规则引擎。

其实利用 ast 包还可以做更多有意思的事情。例如批量把 thrift 文件转化成 proto 文件、解析 sql 语句并做一些审计……

想要更深入的学习，可以看曹大这篇《golang 和 ast》[1]，据曹大自己说，他可以在 30 分钟内完成一个项目的一个 api 的编写，非常霸气!不服喷他……

网站标题：曹大带我学 Go之初识 Ast 的威力
网站路径：http://www.shufengxianlan.com/qtweb/news2/244802.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

虚拟主机知识

分类信息网

优化排名　　 　铁科精智测控　　 　都江堰做网站　　 　成都商城网站建设　　 　成都机柜租用　　 　成都网站推广　　 　成都微信二次开发　　 　温江网站建设　　 　成都外贸网站优化　　 　高端网站建设　　 　网站定制　　 　重庆电信回兴机房　　 　圣月阀门　　 　网站空间　　 　绵阳托管服务器　　 　网站改版　　 　广汉锦华橡塑　　 　网站维护报价　　 　小谭建站工作室　　 　高端网站建设