Question

为了帮助调试GO程序，我想编写两个将在进入和退出时调用的通用函数，它们将分别打印输入和输出参数的值：

Equals()

功能是否等同于printInputParameters(input ...interface{}) printOutputParameters(output ...interface{})？我查看了运行时包，但没有找到这样的函数。

例如，假设我有两个具有不同输入参数和输出参数的函数

os.Args()

我希望能够做到以下

func f1(int i, float f) (e error) {
    ... some code here
}

func f2(s string, b []byte) (u uint64, e error) {
     .. some code here
}

Answer 1

你不能在Go中执行此操作，因为无法在当前goroutine中获取当前活动函数的堆栈帧。这样做并非不可能，因为我将在下面进一步说明，但问题是没有公共API来可靠地完成这项工作。在引发panic时打印的堆栈跟踪中可以看到它可以完成：在这种情况下，堆栈上的所有值都被转储。

如果您对如何实际生成堆栈跟踪感兴趣，请查看运行时包中的genstacktrace。

至于问题的解决方案，您可以将源代码解析路由为already suggested。如果您有冒险精神，可以解析runtime.Stack提供的堆栈跟踪。但要注意，有很多缺点，你会很快意识到任何解决方案都比这个更好。

要解析堆栈跟踪，只需获取先前调用的函数的行（从printInputParameters的角度来看），获取该函数的名称并根据反射提供的参数类型解析参数值。各种函数调用的堆栈跟踪输出的一些示例：

main.Test1(0x2) // Test1(int64(2))
main.Test1(0xc820043ed5, 0x3, 0x3) // Test1([]byte{'A','B','C'})
main.Test1(0x513350, 0x4) // Test1("AAAA")

您可以看到复杂类型（不适合寄存器的类型）可能会使用多个参数＆＃39;。例如，字符串是指向数据和长度的指针。因此，您必须使用unsafe包来访问这些指针和反射，以便根据此数据创建值。

如果您想尝试自己，请参阅以下示例代码：

import (
    "fmt"
    "math"
    "reflect"
    "runtime"
    "strconv"
    "strings"
    "unsafe"
)

// Parses the second call's parameters in a stack trace of the form:
//
// goroutine 1 [running]:
// main.printInputs(0x4c4c60, 0x539038)
//  /.../go/src/debug/main.go:16 +0xe0
// main.Test1(0x2)
//  /.../go/src/debug/main.go:23
//
func parseParams(st string) (string, []uintptr) {

    line := 1
    start, stop := 0, 0
    for i, c := range st {
        if c == '\n' {
            line++
        }
        if line == 4 && c == '\n' {
            start = i + 1
        }
        if line == 5 && c == '\n' {
            stop = i
        }
    }

    call := st[start:stop]
    fname := call[0:strings.IndexByte(call, '(')]
    param := call[strings.IndexByte(call, '(')+1 : strings.IndexByte(call, ')')]
    params := strings.Split(param, ", ")
    parsedParams := make([]uintptr, len(params))

    for i := range params {
        iv, err := strconv.ParseInt(params[i], 0, 64)

        if err != nil {
            panic(err.Error())
        }

        parsedParams[i] = uintptr(iv)
    }

    return fname, parsedParams
}

func fromAddress(t reflect.Type, addr uintptr) reflect.Value {
    return reflect.NewAt(t, unsafe.Pointer(&addr)).Elem()
}

func printInputs(fn interface{}) {
    v := reflect.ValueOf(fn)
    vt := v.Type()
    b := make([]byte, 500)

    if v.Kind() != reflect.Func {
        return
    }

    runtime.Stack(b, false)

    name, params := parseParams(string(b))
    pidx := 0

    fmt.Print(name + "(")
    for i := 0; i < vt.NumIn(); i++ {
        t := vt.In(i)
        switch t.Kind() {
        case reflect.Int64:
        case reflect.Int:
            // Just use the value from the stack
            fmt.Print(params[pidx], ",")
            pidx++
        case reflect.Float64:
            fmt.Print(math.Float64frombits(uint64(params[pidx])), ",")
            pidx++
        case reflect.Slice:
            // create []T pointing to slice content
            data := reflect.ArrayOf(int(params[pidx+2]), t.Elem())
            svp := reflect.NewAt(data, unsafe.Pointer(params[pidx]))
            fmt.Printf("%v,", svp.Elem())
            pidx += 3
        case reflect.String:
            sv := fromAddress(t, params[pidx])
            fmt.Printf("%v,", sv)
            pidx += 2
        case reflect.Map:
            // points to hmap struct
            mv := fromAddress(t,params[pidx])
            fmt.Printf("%v,", mv)
            pidx++
        } /* switch */
    }
    fmt.Println(")")
}

测试：

func Test1(in int, b []byte, in2 int, m string) {
    printInputs(Test1)
}

func main() {
    b := []byte{'A', 'B', 'C'}
    s := "AAAA"
    Test1(2, b, 9, s)
}

输出：

main.Test1(2,[65 66 67],9,"AAAA",)

可以找到on github的稍高级版本：

go get github.com/githubnemo/pdump

Answer 2

通常打印您的功能＆＃39;参数，你可以这样做：

func printInputParameters(input ...interface{}) {
    fmt.Printf("Args: %v", input)
}

printInputParameters为a variadic function，input的类型为[]interface{}。

是否有等效的函数os.Args（）？

2 个答案: