如何在Go的函数中得到调用者函数名?

有时候在Go的函数调用的过程中，我们需要知道函数被谁调用，比如打印日志信息等。例如下面的函数，我们希望在日志中打印出调用者的名字。

 
 
 
 
    
  
  
  
  
  1. func Foo() { 
    2. 
  
  
  
  
  2.     fmt.Println("谁在调用我？") 
    3. 
  
  
  
  
  3.     bar() 
    4. 
  
  
  
  
  4. } 
    5. 
  
  
  
  
  5. func Bar() { 
    6. 
  
  
  
  
  6.     fmt.Println("谁又在调用我？") 
    7. 
  
  
  
  
  7. } 
    8.

首先打印函数本身的名称

最简单的方式就是硬编码。 因为在编译之前，我们肯定知道打印的时候所在哪个函数，但是更好的方式是编写一个通用的函数，比如下面的例子：

 
 
 
 
    
  
  
  
  
  1. package main 
    2. 
  
  
  
  
  2. import ( 
    3. 
  
  
  
  
  3.     "fmt" 
    4. 
  
  
  
  
  4.     "runtime" 
    5. 
  
  
  
  
  5. ) 
    6. 
  
  
  
  
  6. func main() { 
    7. 
  
  
  
  
  7.     Foo() 
    8. 
  
  
  
  
  8. } 
    9. 
  
  
  
  
  9. func Foo() { 
    10. 
  
  
  
  
  10.     fmt.Printf("我是 %s, 谁在调用我?\n", printMyName()) 
    11. 
  
  
  
  
  11.     Bar() 
    12. 
  
  
  
  
  12. } 
    13. 
  
  
  
  
  13. func Bar() { 
    14. 
  
  
  
  
  14.     fmt.Printf("我是 %s, 谁又在调用我?\n", printMyName()) 
    15. 
  
  
  
  
  15. } 
    16. 
  
  
  
  
  16. func printMyName() string { 
    17. 
  
  
  
  
  17.     pc, _, _, _ := runtime.Caller(1) 
    18. 
  
  
  
  
  18.     return runtime.FuncForPC(pc).Name() 
    19. 
  
  
  
  
  19. } 
    20.

输出结果:

 
 
 
 
    
  
  
  
  
  1. 我是 main.Foo, 谁在调用我? 
    2. 
  
  
  
  
  2. 我是 main.Bar, 谁又在调用我? 
    3.

可以看到函数在被调用的时候，printMyName把函数本身的名字打印出来了，注意这里Caller的参数是1, 因为我们将业务代码封装成了一个函数。

首先打印函数调用者的名称

将上面的代码修改一下，增加一个新的printCallerName的函数，可以打印调用者的名称。

 
 
 
 
    
  
  
  
  
  1. func main() { 
    2. 
  
  
  
  
  2.     Foo() 
    3. 
  
  
  
  
  3. } 
    4. 
  
  
  
  
  4. func Foo() { 
    5. 
  
  
  
  
  5.     fmt.Printf("我是 %s, %s 在调用我!\n", printMyName(), printCallerName()) 
    6. 
  
  
  
  
  6.     Bar() 
    7. 
  
  
  
  
  7. } 
    8. 
  
  
  
  
  8. func Bar() { 
    9. 
  
  
  
  
  9.     fmt.Printf("我是 %s, %s 又在调用我!\n", printMyName(), printCallerName()) 
    10. 
  
  
  
  
  10. } 
    11. 
  
  
  
  
  11. func printMyName() string { 
    12. 
  
  
  
  
  12.     pc, _, _, _ := runtime.Caller(1) 
    13. 
  
  
  
  
  13.     return runtime.FuncForPC(pc).Name() 
    14. 
  
  
  
  
  14. } 
    15. 
  
  
  
  
  15. func printCallerName() string { 
    16. 
  
  
  
  
  16.     pc, _, _, _ := runtime.Caller(2) 
    17. 
  
  
  
  
  17.     return runtime.FuncForPC(pc).Name() 
    18. 
  
  
  
  
  18. } 
    19.

相关函数介绍

你可以通过runtime.Caller、runtime.Callers、runtime.FuncForPC等函数更详细的跟踪函数的调用堆栈。

1、func Caller(skip int) (pc uintptr, file string, line int, ok bool)

Caller可以返回函数调用栈的某一层的程序计数器、文件信息、行号。

0 代表当前函数，也是调用runtime.Caller的函数。1 代表上一层调用者，以此类推。

2、func Callers(skip int, pc []uintptr) int

Callers用来返回调用站的程序计数器, 放到一个uintptr中。

0 代表 Callers 本身，这和上面的Caller的参数的意义不一样，历史原因造成的。 1 才对应这上面的 0。

比如在上面的例子中增加一个trace函数，被函数Bar调用。

 
 
 
 
    
  
  
  
  
  1. …… 
    2. 
  
  
  
  
  2. func Bar() { 
    3. 
  
  
  
  
  3.     fmt.Printf("我是 %s, %s 又在调用我!\n", printMyName(), printCallerName()) 
    4. 
  
  
  
  
  4.     trace() 
    5. 
  
  
  
  
  5. } 
    6. 
  
  
  
  
  6. func trace() { 
    7. 
  
  
  
  
  7.     pc := make([]uintptr, 10) // at least 1 entry needed 
    8. 
  
  
  
  
  8.     n := runtime.Callers(0, pc) 
    9. 
  
  
  
  
  9.     for i := 0; i < n; i++ { 
    10. 
  
  
  
  
  10.         f := runtime.FuncForPC(pc[i]) 
    11. 
  
  
  
  
  11.         file, line := f.FileLine(pc[i]) 
    12. 
  
  
  
  
  12.         fmt.Printf("%s:%d %s\n", file, line, f.Name()) 
    13. 
  
  
  
  
  13.     } 
    14. 
  
  
  
  
  14. } 
    15.

输出结果可以看到这个goroutine的整个栈都打印出来了：

 
 
 
 
    
  
  
  
  
  1. /usr/local/go/src/runtime/extern.go:218 runtime.Callers 
    2. 
  
  
  
  
  2. /Users/yuepan/go/src/git.intra.weibo.com/platform/tool/g/main.go:34 main.trace 
    3. 
  
  
  
  
  3. /Users/yuepan/go/src/git.intra.weibo.com/platform/tool/g/main.go:20 main.Bar 
    4. 
  
  
  
  
  4. /Users/yuepan/go/src/git.intra.weibo.com/platform/tool/g/main.go:15 main.Foo 
    5. 
  
  
  
  
  5. /Users/yuepan/go/src/git.intra.weibo.com/platform/tool/g/main.go:10 main.main 
    6. 
  
  
  
  
  6. /usr/local/go/src/runtime/proc.go:210 runtime.main 
    7. 
  
  
  
  
  7. /usr/local/go/src/runtime/asm_amd64.s:1334 runtime.goexit 
    8.

3、func CallersFrames(callers []uintptr) *Frames

上面的Callers只是或者栈的程序计数器，如果想获得整个栈的信息，可以使用CallersFrames函数，省去遍历调用FuncForPC。

上面的trace函数可以更改为下面的方式：

 
 
 
 
    
  
  
  
  
  1. func trace2() { 
    2. 
  
  
  
  
  2.     pc := make([]uintptr, 10) // at least 1 entry needed 
    3. 
  
  
  
  
  3.     n := runtime.Callers(0, pc) 
    4. 
  
  
  
  
  4.     frames := runtime.CallersFrames(pc[:n]) 
    5. 
  
  
  
  
  5.     for { 
    6. 
  
  
  
  
  6.         frame, more := frames.Next() 
    7. 
  
  
  
  
  7.         fmt.Printf("%s:%d %s\n", frame.File, frame.Line, frame.Function) 
    8. 
  
  
  
  
  8.         if !more { 
    9. 
  
  
  
  
  9.             break 
    10. 
  
  
  
  
  10.         } 
    11. 
  
  
  
  
  11.     } 
    12. 
  
  
  
  
  12. } 
    13.

4、func FuncForPC(pc uintptr) *Func

FuncForPC 是一个有趣的函数， 它可以把程序计数器地址对应的函数的信息获取出来。如果因为内联程序计数器对应多个函数，它返回最外面的函数。

它的返回值是一个*Func类型的值，通过*Func可以获得函数地址、文件行、函数名等信息。

除了上面获取程序计数器的方式，也可以通过反射的方式获取函数的地址：

 
 
 
 
    
  
  
  
  
  1. runtime.FuncForPC(reflect.ValueOf(foo).Pointer()).Name() 
    2.

5、获取程序堆栈

在程序panic的时候，一般会自动把堆栈打出来，如果你想在程序中获取堆栈信息，可以通过debug.PrintStack()打印出来。比如你在程序中遇到一个Error,但是不期望程序panic,只是想把堆栈信息打印出来以便跟踪调试，你可以使用debug.PrintStack()。

抑或，你自己读取堆栈信息，自己处理和打印：

 
 
 
 
    
  
  
  
  
  1. func DumpStacks() { 
    2. 
  
  
  
  
  2.     buf := make([]byte, 16384) 
    3. 
  
  
  
  
  3.     buf = buf[:runtime.Stack(buf, true)] 
    4. 
  
  
  
  
  4.     fmt.Printf("=== BEGIN goroutine stack dump ===\n%s\n=== END goroutine stack dump ===", buf) 
    5. 
  
  
  
  
  5. } 
    6.

参考 调试利器：dump goroutine 的 stacktrace。

利用堆栈信息还可以获取goroutine的id, 参考: 再谈谈获取 goroutine id 的方法

 
 
 
 
    
  
  
  
  
  1. func GoID() int { 
    2. 
  
  
  
  
  2.     var buf [64]byte 
    3. 
  
  
  
  
  3.     n := runtime.Stack(buf[:], false) 
    4. 
  
  
  
  
  4.     idField := strings.Fields(strings.TrimPrefix(string(buf[:n]), "goroutine "))[0] 
    5. 
  
  
  
  
  5.     id, err := strconv.Atoi(idField) 
    6. 
  
  
  
  
  6.     if err != nil { 
    7. 
  
  
  
  
  7.         panic(fmt.Sprintf("cannot get goroutine id: %v", err)) 
    8. 
  
  
  
  
  8.     } 
    9. 
  
  
  
  
  9.     return id 
    10. 
  
  
  
  
  10. } 
    11.

当前标题：如何在Go的函数中得到调用者函数名?
标题网址：http://www.shufengxianlan.com/qtweb/news33/342583.html

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

广告

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

猜你还喜欢下面的内容

手机网站建设知识

同城分类信息

新型地坪材料　　 　优化排名　　 　网站制作价格　　 　手机APP开发　　 　四川广汉锦华　　 　成都做网站　　 　成都微信小程序开发　　 　企业网站设计　　 　注册域名　　 　注册域名　　 　成都包装设计公司　　 　一带一路　　 　成都石膏隔墙板　　 　成都LED显示屏　　 　雪茄烟　　 　重庆网站建设网络公司　　 　美美搬家　　 　郫县门窗定制　　 　混凝土搅拌车　　 　青羊总部基地