当前位置：首页 > 文章列表 > Golang > Go问答 > Go 泛型是否支持与 LINQ to Objects 的等效项？

Go 泛型是否支持与 LINQ to Objects 的等效项？

来源：stackoverflow 2024-02-18 13:18:23 0浏览收藏

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《Go 泛型是否支持与 LINQ to Objects 的等效项？》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

问题内容

随着 go 1.18 中添加泛型，现在是否有可能提出 c# 的 linq to objects 的等效项？

或者与 c# 泛型相比，go 的泛型在原则上缺乏某些东西，这会使这变得困难或不可能？

例如，原始 101 个 linq 示例中的第一个（“lownumbers”）现在可以使用大致如下的泛型在 go 中实现：

package main

import (
    "fmt"
)

type collection[T comparable] []T

func (input collection[T]) where(pred func(T) bool) collection[T] {
    result := collection[T]{}
    for _, j := range input {
        if pred(j) {
            result = append(result, j)
        }
    }
    return result
}

func main() {
    numbers := collection[int]{5, 4, 1, 3, 9, 8, 6, 7, 2, 0}
    lowNums := numbers.where(func(i int) bool { return i < 5 })
    fmt.Println("Numbers < 5:")
    fmt.Println(lowNums)
}

正确答案

（免责声明：我不是 c# 专家）

go 的参数多态性与 c# 或 java 中的泛型实现之间的一个显着区别是，go（仍然）没有针对类型参数的同变/反变的语法。

例如，在 c# 中，您可以使用实现 icomparer 的代码并传递派生容器类；或者在java中典型的predicate<？流 api 中的 super t>。在 go 中，类型必须完全匹配，并且使用不同类型参数实例化泛型类型会产生不同的命名类型，而这些命名类型不能相互分配。另请参阅：Why does Go not allow assigning one generic to another?

此外，go 不是 oo，因此没有继承的概念。您可能有实现接口的类型，甚至是参数化接口。一个人为的例子：

type equaler[t any] interface {
    equals(t) bool
}

type vector []int32

func (v vector) equals(other vector) bool {
    // some logic
}

因此，通过此代码，vector 实现了 equaler 的特定实例，即 equaler[vector]。需要明确的是，以下 var 声明可以编译：

var _ equaler[vector] = vector{}

因此，您可以在 t 中编写通用函数，并使用 t 实例化 equaler，并且您将能够传递任何实现 equaler 特定实例的内容：

func remove[e equaler[t], t any](es []e, v t) []e {
    for i, e := range es {
        if e.equals(v) {
            return append(es[:i], es[i+1:]...)
        }
    }
    return es
}

您可以使用任何 t 调用此函数，因此也可以使用任何具有 equals(t) 方法的 t 调用此函数：

// some other random type that implements equaler[t]
type mystring string

// implements equaler[string]
func (s mystring) equals(other string) bool {
    return strings.split(string(s), "-")[0] == other
}

func main() {
    vecs := []vector{{1, 2}, {3, 4, 5}, {6, 7}, {8}}
    fmt.println(remove(vecs, vector{6, 7})) 
    // prints [[1 2] [3 4 5] [8]]

    strs := []mystring{"foo-bar", "hello-world", "bar-baz"}
    fmt.println(remove(strs, "hello"))
    // prints [foo-bar bar-baz]
}

唯一的问题是只有定义的类型才能拥有方法，因此这种方法已经排除了所有复合非命名类型。

然而，为了部分救援，go 具有高阶函数，因此使用该函数和非命名类型编写类似流的 api 并非不可能，例如：

func Where[C ~[]T, T any](collection C, predicate func(T) bool) (out C) {
    for _, v := range collection {
        if predicate(v) {
            out = append(out, v)
        }
    }
    return 
}

func main() {
    // vecs declared earlier
    filtered := Where(vecs, func(v Vector) bool { return v[0] == 3})
    fmt.Printf("%T %v", filtered, filtered)
    // prints []main.Vector [[3 4 5]]
}

特别是在这里，您使用命名类型参数 c ~[]t 而不是仅仅定义 collection []t，以便您可以将其与命名和非命名类型一起使用。

演示中提供的代码：https://gotipplay.golang.org/p/mCM2TJ9qb3F

（选择参数化接口与高阶函数可能取决于您是否想要链接方法等，但 go 中的方法链接一开始并不常见。）

结论：这是否足以模仿 linq 或类似 stream 的 api，和/或启用大型通用库，只有实践才能证明。现有的功能非常强大，并且在语言设计者获得泛型的实际使用经验后，go 1.19 中的功能可能会变得更加强大。

是和否。

您几乎可以使用链接的 api 来实现这一目标。这适用于许多标准 linq 方法，例如 skip、take、where、first、last 等。

当您需要切换到流/流中的另一个通用类型时，不起作用。

go 泛型不允许方法拥有除定义它们的接口/结构之外的其他类型参数。例如你不能拥有一个 struct foo[t any] 然后再有一个方法 bar[o any] 这对于像 select 这样的方法是必需的，其中您有一种类型的输入和另一种类型的输出。

但是，如果您不使用链接而只使用普通函数。那么你就可以获得非常接近的功能。

我已经在这里完成了：https://github.com/asynkron/gofun

这是通过模拟协同例程实现的完全惰性可枚举实现。

这里不起作用的是像 zip 这样的函数，它需要同时枚举两个可枚举值。（虽然有很多方法可以破解它。但没什么好看的）