Golang 实现 .NET LINQ 式数据查询操作的插件库 go-linq 的使用

go-linq 是一个强大的 Go 语言集成查询(LINQ)库，它提供了类似 .NET LINQ 的功能。

特性

• 纯 Go 编写，无依赖
• 使用迭代器模式实现完整的惰性求值
• 并发安全
• 支持泛型函数，使代码更清晰且无需类型断言
• 支持数组、切片、映射、字符串、通道和自定义集合

安装

使用 Go modules 时，使用以下导入路径：

go get github.com/ahmetb/go-linq/v3

快速入门

使用方式就像链式调用方法一样简单：

From(slice) .Where(predicate) .Select(selector) .Union(data)

示例 1：查找所有 2015 年后生产的汽车车主

import . "github.com/ahmetb/go-linq/v3"

type Car struct {
    year int
    owner, model string
}

var owners []string

From(cars).Where(func(c interface{}) bool {
    return c.(Car).year >= 2015
}).Select(func(c interface{}) interface{} {
    return c.(Car).owner
}).ToSlice(&owners)

或者，你可以使用泛型函数（会有性能损失）：

var owners []string

From(cars).WhereT(func(c Car) bool {
    return c.year >= 2015
}).SelectT(func(c Car) string {
    return c.owner
}).ToSlice(&owners)

示例 2：查找写了最多书籍的作者

import . "github.com/ahmetb/go-linq/v3"

type Book struct {
    id      int
    title   string
    authors []string
}

author := From(books).SelectMany( // 将作者数组扁平化
    func(book interface{}) Query {
        return From(book.(Book).authors)
    }).GroupBy( // 按作者分组
    func(author interface{}) interface{} {
        return author // 作者作为键
    }, func(author interface{}) interface{} {
        return author // 作者作为值
    }).OrderByDescending( // 按组长度排序
    func(group interface{}) interface{} {
        return len(group.(Group).Group)
    }).Select( // 从组中获取作者
    func(group interface{}) interface{} {
        return group.(Group).Key
    }).First() // 取第一个作者

示例 3：实现一个自定义方法，只保留大于指定阈值的值

type MyQuery Query

func (q MyQuery) GreaterThan(threshold int) Query {
    return Query{
        Iterate: func() Iterator {
            next := q.Iterate()

            return func() (item interface{}, ok bool) {
                for item, ok = next(); ok; item, ok = next() {
                    if item.(int) > threshold {
                        return
                    }
                }

                return
            }
        },
    }
}

result := MyQuery(Range(1,10)).GreaterThan(5).Results()

泛型函数

虽然 Go 没有实现泛型，但通过一些反射技巧，你可以使用 go-linq 而无需处理 interface{} 和类型断言。这会带来性能损失(5-10 倍慢)，但会产生更清晰、更易读的代码。

带有 T 后缀的方法(如 WhereT)接受带有泛型类型的函数。所以不用：

.Select(func(v interface{}) interface{} {...})

你可以这样写：

.SelectT(func(v YourType) YourOtherType {...})

示例 4：在字符串句子切片中实现"MapReduce"以列出最常用的 5 个单词

var results []string

From(sentences).
    // 将句子拆分为单词
    SelectManyT(func(sentence string) Query {
        return From(strings.Split(sentence, " "))
    }).
    // 对单词分组
    GroupByT(
        func(word string) string { return word },
        func(word string) string { return word },
    ).
    // 按计数排序
    OrderByDescendingT(func(wordGroup Group) int {
        return len(wordGroup.Group)
    }).
    // 按单词排序
    ThenByT(func(wordGroup Group) string {
        return wordGroup.Key.(string)
    }).
    Take(5).  // 取前5个
    // 使用索引作为排名来投影单词
    SelectIndexedT(func(index int, wordGroup Group) string {
        return fmt.Sprintf("Rank: #%d, Word: %s, Counts: %d", index+1, wordGroup.Key, len(wordGroup.Group))
    }).
    ToSlice(&results)

发布说明

v3.2.0 (2020-12-29)
* Added FromChannelT().
* Added DefaultIfEmpty().

v3.1.0 (2019-07-09)
* Support for Go modules
* Added IndexOf()/IndexOfT().

v3.0.0 (2017-01-10)
* Breaking change: ToSlice() now overwrites existing slice starting
  from index 0 and grows/reslices it as needed.
* Generic methods support
  - You can now avoid type assertions and interface{}s
  - Functions with generic methods are named as "MethodNameT"
* Added ForEach(), ForEachIndexed() and AggregateWithSeedBy().

v2.0.0 (2016-09-02)
* IMPORTANT: This release is a BREAKING CHANGE.
* A COMPLETE REWRITE of go-linq with better performance and memory
  efficiency.
* API has significantly changed.