Question

我写了一个使用闭包的函数“ iterPermutation”。我想从关闭中返回数组和布尔值，而我做不到。因此只尝试了数组，但仍然给出错误

不能使用func文字（类型func（）[] int）作为返回类型[] int 论点

我想像使用iterPermutation

<receiver
        android:name=".NetworkReceiver">
        <intent-filter>
            <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
        </intent-filter>
    </receiver>

Answer 1

描述Return statements的Golang规范：

一个或多个返回值可以在“返回”中明确列出声明。每个表达式都必须是单值且可分配给函数结果类型的对应元素。

用于置换的函数应包含两个值，其中一个返回数组，另一个返回布尔值。由于您要从函数return中分配两个变量：

a := []int{0,1,2,3,4}
nextPermutation, exists := iterPermutation(a) // it should return two values one for nextPermutation which is an array and other is exists which might be a boolean value.
for exists {
    nextPermutation()
}

对于以下错误：

“不能使用func文字（类型func（）[] int）作为返回类型[] int 论点”

您将返回包含在置换的闭包函数中的func（）文字以及布尔值，因此将返回类型更改为：

package main

func main(){
    a := []int{0,1,2,3,4}
    nextPermutation, _ := iterPermutation(a)
        nextPermutation()
}

func iterPermutation(a []int) ((func() []int), bool) { // return both values
    return func() []int {
        i := len(a) - 2

        for i >= 0 && a[i+1] <= a[i] {
            i--
        }
        if i < 0 {
            return a
        }

        j := len(a) - 1
        for j >= 0 && a[j] <= a[i] {
            j--
        }

        a[i], a[j] = a[j], a[i]

        for k, l := i, len(a)-1; k < l; k, l = k+1, l-1 {
            a[k], a[l] = a[l], a[k]
        }
        return a
    }, true // add boolean value to return from the function.
}

Playground上的有效答案

Answer 2

我将忽略闭包内部的“置换”逻辑，而将重点放在您需要了解的几个概念上，这样它就可以像计划使用代码一样工作。如果我错了，请纠正我，但是您想从关闭中获取项目数组，直到exists为假，对吧？

首先，要正确编译nextPermutation, exists := iterPermutation(a)，iterPermutation需要返回两个值，如下所示：

func iterPermutation(a []int) (func() []int, bool) {
   exists := true
   return func() []int {
      //rest of your code
      if i < 0 {
        exists = false
        return a
      }
      //rest of your code
   }, exists
}

您面临的下一个问题是，使用上述方法，您将拥有exists值。由于您要返回exists的值，因此对exists的任何更改都不会传播到iterPermutation的范围之外。您可以通过返回指针来解决此问题。这是实现它的一种方法：

a := []int{0,1,2,3,4}
nextPermutation, check := iterPermutation(a)

while check.Exists {
   nextPermutation()
}

type Check struct {
    Exists bool 
}

func iterPermutation(a []int) (func() []int, *Check) {
check:= &Check{
          Exists: true,
}   
return func() []int {
        i := len(a) - 2

        for i >= 0 && a[i+1] <= a[i] {
            i--
        }
        if i < 0 {
        check.Exists = false //this is put here as an example
            return a
        }

        j := len(a) - 1
        for j >= 0 && a[j] <= a[i] {
            j--
        }

        a[i], a[j] = a[j], a[i]

        for k, l := i, len(a)-1; k < l; k, l = k+1, l-1 {
            a[k], a[l] = a[l], a[k]
        }
        return a
    }, check
}

当返回Check类型的指针时，在iterPermutation或闭包中对其的任何更改也将在这些变量之外可见，因为您正在访问内存引用。

使用闭包在Go中编写下一个置换，我的代码有什么问题

2 个答案: