在Golang中进行多个接口转换的简洁方法是什么？

huangapple
go评论108阅读模式
英文:

Concise way to do multiple interface conversions in Golang?

问题

我正在尝试使用go/ast包从代码中解析函数调用。

为了做到这一点，我首先找到所有的函数调用，如下所示：

  1. ast.Inspect(f, func(n ast.Node) bool {
  2.     switch x := n.(type) {
  3.     case *ast.FuncDecl:
  4.         processFunction(x)
  5.     }
  6.     return true
  7. })

然后，processFunction()函数如下所示：

  1. func processFunction(e *ast.FuncDecl) {
  2.     // 保存包装函数名
  3.     f := e.Name.Name
  5.     for _, expression := range e.Body.List {
  6.         logrus.Printf("Current stmt: %#v", expression)
  7.         pkg := expression.(*ast.ExprStmt).X.(*ast.CallExpr).Fun.(*ast.SelectorExpr).X.(*ast.Ident).Name
  8.         fn := expression.(*ast.ExprStmt).X.(*ast.CallExpr).Fun.(*ast.SelectorExpr).Sel.Name
  9.         fcall := fmt.Sprintf("%s.%s", pkg, fn)
  10.         logrus.Printf("Yay. found my function call: ", fcall)
  11.     }
  12. }

这段代码的问题在于，如果在AST中找不到特定的层次结构，程序会发生崩溃。我知道我们可以通过以下方式优雅地进行接口转换：

  1. x, ok := x.(type)

但是，如果我对每个转换都这样做，我的代码会变得很冗长。当然，在这里尝试使用这种方法会失败。

  1. pkg, ok := expression.(*ast.ExprStmt).X.(*ast.CallExpr).Fun.(*ast.SelectorExpr).X.(*ast.Ident).Name
  2. if !ok {
  3.     continue
  4. }

错误信息：

  1. ./parser.go:41: assignment count mismatch: 2 = 1

有没有一种简洁的方法来进行这些连续的转换，并且在找不到这个层次结构时能够优雅地处理错误？

英文:

I'm trying to parse function calls from a code using go/ast package.

To do that, I first find all function calls like:

  1. ast.Inspect(f, func(n ast.Node) bool {
  2.     switch x := n.(type) {
  3.     case *ast.FuncDecl:
  4.         processFunction(x)
  5.     }
  6.     return true
  7. })

And then, processFunction() looks like this:

  1. func processFunction(e *ast.FuncDecl) {
  2.     // Save wrapper function name
  3.     f := e.Name.Name
  5.     for _, expression := range e.Body.List {
  6.         logrus.Printf("Current stmt: %#v", expression)
  7.         pkg := expression.(*ast.ExprStmt).X.(*ast.CallExpr).Fun.(*ast.SelectorExpr).X.(*ast.Ident).Name
  8.         fn := expression.(*ast.ExprStmt).X.(*ast.CallExpr).Fun.(*ast.SelectorExpr).Sel.Name
  9.         fcall := fmt.Sprintf("%s.%s", pkg, fn)
  10.         logrus.Printf("Yay. found my function call: ", fcall)
  11.     }
  13. }

The problem with this code is that if that particular hierarchy is not found in AST, the program panics. I know that we can do interface conversions gracefully via

  1. x, ok := x.(type)

But, if I do each conversion like this, my code will be huge. Trying to use that in this fails of course.

  1.     pkg, ok := expression.(*ast.ExprStmt).X.(*ast.CallExpr).Fun.(*ast.SelectorExpr).X.(*ast.Ident).Name
  2.     if !ok {
  3.         continue
  4.     }

Error:

  1. ./parser.go:41: assignment count mismatch: 2 = 1

Is there a concise way to do these series of conversions and also fail gracefully if this hierarchy is not found?

答案1

得分: 1

我已经为您翻译了代码部分，如下所示：

  1. // 无法使用*类型断言*来链接。但是，您可以通过将重复的代码提取到自己的函数中来简化此特定示例。
  3. func fnSelExpr(s ast.Stmt) (*ast.SelectorExpr, bool) {
  4.     if xs, ok := s.(*ast.ExprStmt); ok {
  5.         if cx, ok := xs.X.(*ast.CallExpr); ok {
  6.             return cx.Fun.(*ast.SelectorExpr)
  7.         }
  8.     }
  9.     return nil, false
  10. }
  12. 然后，您可以像这样简化您的`processFunction`函数。
  14. func processFunction(e *ast.FuncDecl) {
  15.     // 保存包装函数名称
  16.     f := e.Name.Name
  18.     for _, expression := range e.Body.List {
  19.         logrus.Printf("当前语句: %#v", expression)
  21.         sx, ok := fnSelExpr(expression)
  22.         if !ok {
  23.             continue
  24.         }
  26.         var pkg string
  27.         if id, ok := sx.X.(*ast.Ident); ok {
  28.             pkg = id.Name
  29.         }
  30.         fn := sx.Sel.Name
  32.         fcall := fmt.Sprintf("%s.%s", pkg, fn)
  33.         logrus.Printf("耶。找到了我的函数调用: ", fcall)
  34.     }
  35. }

希望对您有所帮助！

英文:

There is no way, that I know of, to chain type assertions. But you can simplify this specific example by extracting duplicate code into its own function.

  1. func fnSelExpr(s ast.Stmt) (*ast.SelectorExpr, bool) {
  2. 	if xs, ok := s.(*ast.ExprStmt); ok {
  3. 		if cx, ok := xs.X.(*ast.CallExpr); ok {
  4. 			return cx.Fun.(*ast.SelectorExpr)
  5. 		}
  6. 	}
  7. 	return nil, false
  8. }

Then you can simplify your processFunction like this.

  1. func processFunction(e *ast.FuncDecl) {
  2. 	// Save wrapper function name
  3. 	f := e.Name.Name
  5. 	for _, expression := range e.Body.List {
  6. 		logrus.Printf("Current stmt: %#v", expression)
  7. 		
  8. 		sx, ok := fnSelExpr(expression)
  9. 		if !ok {
  10. 			continue
  11. 		}
  12. 		
  13. 		var pkg string
  14. 		if id, ok := sx.X.(*ast.Ident); ok {
  15. 			pkg = id.Name
  16. 		}
  17. 		fn := sx.Sel.Name
  19. 		fcall := fmt.Sprintf("%s.%s", pkg, fn)
  20. 		logrus.Printf("Yay. found my function call: ", fcall)
  21. 	}
  22. }

huangapple
  • 本文由 发表于 2017年4月24日 02:47:32
  • 转载请务必保留本文链接：https://go.coder-hub.com/43575101.html
  • abstract-syntax-tree
  • go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定