5

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

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 反射的绝妙技巧，我想我找到了一种表达这些模式的好方法，通过将每个“可迭代”转换为通道：

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;
}

在操场上使用它重写了我最初的示例。

非常感谢jnml和ANisus的帮助！

4

2 回答 2

4

例如：

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 }))
}

操场

输出：

true
false
于 2013-08-07T11:34:46.853 回答
3

我不能说它是否是最惯用的。但是一种惯用的解决方案是在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()。

他可以在这里找到工作示例

于 2013-08-07T11:26:29.780 回答