Question

假设我想编写一个函数来检查谓词是否与切片中的元素匹配：

func IsIn(array []T, pred func(elt T) bool) bool {
    for _, obj := range array {
        if pred(obj) { return true;}
    }
    return false;
}

显然，之前的代码无法编译，因为T不存在。我可以用这样的interface{}替换它：

func IsIn(array[]interface{}, pred func(elt interface{}) bool) bool {
    ...
}

我很高兴让谓词执行演员：

IsIn([]interface{}{1,2,3,4}, func(o interface{}) {return o.(int) == 3; });

但是，该函数不接受任何不属于[]interface{}类型的数组：

IsIn([]int{1,2,3,4}, func(o interface{}) { return o.(int) == 3; }) // DO NOT COMPILE

同样地：

func IsIn(arr interface, pred func(o interface{}) bool) bool {
    for _, o := range arr.([]interface{}) { ... }
}
IsIn([]int{1,2,3,4}, func(o interface{}) { return o.(int) == 3; }) // PANICS AT RUNTIME (cannot cast []int to []interface)

另一种方法是为每种数组类型设置类型函数：

IsInInt(arr []int, pred func(i int) bool) { ... }
IsInStr(arr []string, pred func(s string) bool) { ... }
...

但似乎有很多代码重复。

有没有人想出一个处理这种情况的好方法？

修改

感谢jnml关于Go反射的精彩提示，我认为通过将每个'iterable'转换为一个频道，我找到了表达这些模式的好方法：

func iter(obj interface{}) chan interface{} {
    c := make(chan interface{})
    v := reflect.ValueOf(obj)
    if (v.Kind() == reflect.Array || v.Kind() == reflect.Slice) {
        go func() {
            for i := 0; i < v.Len(); i++ {
                c<-v.Index(i).Interface()
            }
            close(c)
        }()
    } else if v.Kind() == reflect.Chan {
        go func() {
            x, ok := v.Recv()
            for ok {
                c<-x.Interface()
                x,ok = v.Recv()
            }
            close(c)
        }()
    } else if (... whatever iteration protocol you have ...) {
    } else {
        panic("Cannot iterate !")
    }
    return c;
}

我的初始示例使用on the playground重写。

非常感谢jnml和ANisus提供帮助！

Answer 1

例如：

package main

import (
        "fmt"
        "reflect"
)

func checkSlice(slice interface{}, predicate func(reflect.Value) bool) bool {
        v := reflect.ValueOf(slice)
        if v.Kind() != reflect.Slice {
                panic("not a slice")
        }

        for i := 0; i < v.Len(); i++ {
                if predicate(v.Index(i)) {
                        return true
                }
        }

        return false
}

func main() {
        a := []int{1, 2, 3, 4, 42, 278, 314}
        fmt.Println(checkSlice(a, func(v reflect.Value) bool { return v.Int() == 42 }))

        b := []float64{1.2, 3.4, -2.5}
        fmt.Println(checkSlice(b, func(v reflect.Value) bool { return v.Float() > 4 }))
}

Playground

输出：

true
false

Answer 2

我不能说它是最惯用语。但是一个惯用的解决方案就是在sort包中做;定义数组的接口：

type Interface interface {
    Len() int
    Equal(i int, v interface{}) bool
}

func IsIn(array Interface, value interface{}) bool {
    for i := 0; i < array.Len(); i++ {
    if array.Equal(i, value) {
            return true
        }
    }
    return false;
}

只要您的数组实现此接口，您就可以使用IsIn（）。

他可以找到here

的工作示例

在Go中实现泛型函数的惯用方法

2 个答案: