我正在尝试实现一个函数，该函数接受任何类型的元素和相同类型的 slice ，并在第二个中搜索第一个，将其位置作为结果，否则为 -1。

我不是 Go 专家，所以我的第一个想法是将要搜索的元素作为 interface{} 并将 slice 作为 []interface{} 传递，但它并没有真正奏效。

这是我尝试过的:

package main

import (
    "fmt"
)

func IsElementInListWithPos(element interface{}, list []interface{}) int {
    for i := range list {
        if list[i] == element {
            return i
        }
    }

    return -1
}

func main() {
    list1 := []int{1, 2, 3, 4, 5, 6}
    list2 := []string{"a", "b", "c", "d"}
    pos1 := IsElementInListWithPos(3, list1)
    pos2 := IsElementInListWithPos("a", list2)
    fmt.Println(pos1, pos2)
}

它给我以下错误:

cannot use list (type []int) as type []interface {} in argument to IsElementInListWithPos
cannot use list2 (type []string) as type []interface {} in argument to IsElementInListWithPos

知道如何在不实际使用两个不同函数的情况下解决这个问题吗？ 提前致谢。

最佳答案

sort package演示了如何使用接口(interface)以与类型无关的方式实现算法。

线性搜索需要两个基本操作，这两个操作取决于 haystack 元素类型，Len 和 Equal。所以我们可以编写以下 Haystack 接口(interface)和一个使用它的搜索函数:

type Haystack interface {
    Len() int
    Equal(int, interface{}) bool
}

func Search(haystack Haystack, needle interface{}) int {
    for i := 0; i < haystack.Len(); i++ {
        if haystack.Equal(i, needle) {
            return i
        }
    }
    return -1
}

这使得 Haystack 的编写实现变得简单，但不是类型安全的:

type Strings []string

func (s Strings) Len() int                        { return len(s) }
func (s Strings) Equal(i int, x interface{}) bool { return s[i] == x.(string) }

type Ints []int

func (s Ints) Len() int                        { return len(s) }
func (s Ints) Equal(i int, x interface{}) bool { return s[i] == x.(int) }

func main() {
    strings := []string{"b", "a", "c", "d"}
    fmt.Println(Search(Strings(strings), "c")) // 2
    fmt.Println(Search(Strings(strings), "e")) // -1

    ints := []int{2, 1, 3, 4}
    fmt.Println(Search(Ints(ints), 3)) // 2
    fmt.Println(Search(Ints(ints), 5)) // -1
}

注意 Equal 方法中的类型断言。为了使这种类型安全，我们必须去掉 Equal 的 interface{} 参数:

type Haystack interface {
    Len() int
    Equal(int) bool
}

func Search(haystack Haystack) int {
    for i := 0; i < haystack.Len(); i++ {
        if haystack.Equal(i) {
            return i
        }
    }
    return -1
}

type Strings struct {
    hs     []string
    needle string
}

func (s Strings) Len() int         { return len(s.hs) }
func (s Strings) Equal(i int) bool { return s.hs[i] == s.needle }

type Ints struct {
    hs     []int
    needle int
}

func (s Ints) Len() int         { return len(s.hs) }
func (s Ints) Equal(i int) bool { return s.hs[i] == s.needle }

func main() {
    strings := []string{"b", "a", "c", "d"}
    fmt.Println(Search(Strings{strings, "c"})) // 2
    fmt.Println(Search(Strings{strings, "e"})) // -1

    ints := []int{2, 1, 3, 4}
    fmt.Println(Search(Ints{ints, 3})) // 2
    fmt.Println(Search(Ints{ints, 5})) // -1
}

这使得接口(interface)实现和使用搜索功能变得更加复杂。

这个故事的寓意是，以这种方式使用接口(interface)需要足够复杂的算法才能避免麻烦。如果为特定类型编写接口(interface)实现比为算法编写具体实现更工作，那么只需编写您需要的具体函数:

func SearchStr(haystack []string, needle string) int {
    for i, x := range haystack {
        if x == needle {
            return i
        }
    }
    return -1
}

func SearchInt(haystack []int, needle int) int {
    for i, x := range haystack {
        if x == needle {
            return i
        }
    }
    return -1
}

func main() {
    strings := []string{"b", "a", "c", "d"}
    fmt.Println(SearchStr(strings, "c")) // 2
    fmt.Println(SearchStr(strings, "e")) // -1

    ints := []int{2, 1, 3, 4}
    fmt.Println(SearchInt(ints, 3)) // 2
    fmt.Println(SearchInt(ints, 5)) // -1
}

关于go - 在 Go 中的接口(interface){}片段上搜索接口(interface){}的函数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/58008539/