在Golang中如何实现递归

在 Golang 中实现递归时，使用匿名函数会导致循环引用错误。为了解决这个问题，可以采用“前向声明”的方式，即先声明函数变量，再赋值函数体。这允许函数在定义完成前通过其名称进行调用，从而实现递归。例如： ```go // 前向声明函数 var myfunc func(arg) result // 定义函数体 myfunc = func(arg) result { // ... do something ... // now we can call the function recursively return myfunc(arg) } ```

我有下面的代码，我正在尝试进行递归。然而，go 编译器抱怨循环引用。 当然我有一个循环引用；这是一个递归。

我尝试将递归移入主函数并移出。同样的问题。我怎样才能实现这个递归？错误行是： return lookup(deref.interface()) // 递归错误 '循环定义'

christianb@christianb-mac terraform-provider% go build
# github.com/terraform-provider/pkg/foo/repositories.go:773:5: initialization loop:
        /users/christianb/dev/terraform-provider/pkg/foo/repositories.go:773:5: lookup refers to
        /users/christianb/dev/terraform-provider/pkg/foo/repositories.go:774:18: glob..func6.1 refers to
        /users/christianb/dev/terraform-provider/pkg/foo/artifactory/repositories.go:773:5: lookup

type AutoMapper func(field reflect.StructField, thing reflect.Value) map[string]interface{}

var lookup = func() func(payload interface{}) map[string]interface{} {
    var handlePtr = func(field reflect.StructField, thing reflect.Value) map[string]interface{} {
        deref := reflect.Indirect(thing)
        if deref.CanAddr() {
            if deref.Kind() == reflect.Struct {
                return lookup(deref.Interface()) // recursion error 'cyclic definition'
            }
            return map[string]interface{}{
                field.Tag.Get("hcl"): deref.Interface(),
            }
        }
        return map[string]interface{}{}
    }
    var checkForHcl = func(mapper AutoMapper) AutoMapper {
        return func(field reflect.StructField, thing reflect.Value) map[string]interface{} {
            if field.Tag.Get("hcl") != "" {
                return mapper(field, thing)
            }
            return map[string]interface{}{}
        }
    }
    lk := map[reflect.Kind]AutoMapper{}

    find := func(payload interface{}) map[string]interface{} {
        values := map[string]interface{}{}
        var t = reflect.TypeOf(payload)
        var v = reflect.ValueOf(payload)
        if t.Kind() == reflect.Ptr {
            t = t.Elem()
            v = v.Elem()
        }
        for i := 0; i < t.NumField(); i++ {
            field := t.Field(i)
            thing := v.Field(i)
            for key, value := range lk[thing.Kind()](field, thing) {
                values[key] = value
            }

        }
        return values
    }
    lk[reflect.Struct] = checkForHcl(func(f reflect.StructField, t reflect.Value) map[string]interface{} {
        return find(t.Interface())
    })
    lk[reflect.Slice] = checkForHcl(func(field reflect.StructField, thing reflect.Value) map[string]interface{} {
        return map[string]interface{}{
            field.Tag.Get("hcl"): thing.Interface().([]string),
        }
    })
    lk[reflect.Ptr] = checkForHcl(handlePtr)
    return find
}()

正确答案

您的函数无法通过名称引用自身，因为它是一个匿名函数。它只有在被分配给变量 lookup 后才会被命名。从词法上来说，只有在完全解析所分配的值后才会发生这种情况。这与普通的 func 声明不同，其中名称立即可用（这使得递归更加清晰）：

func myfunc(arg) result {
    // ... do something ...
    // now we can call the function recursively
    return myfunc(arg)
}

就您而言，常规的 func 声明不起作用，因此您需要某种“前向声明”来使名称可用，这需要少量重复：

// forward declare the function
var myfunc func(arg) result

myfunc = func(arg) result {
    // ... do something ...
    // now we can call the function recursively
    return myfunc(arg)
}

要在全局上下文中执行相同的操作，请参阅 Burak's answer.

问题是初始化循环，而不是递归。您正在引用该变量定义中的变量。你可以这样做：

var lookup func() func(payload interface{}) map[string]interface{}

func init() {
   lookup=func() func(payload interface{}) map[string]interface{} {...}
}

到这里，我们也就讲完了《在Golang中如何实现递归》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！