samber/lo 是一个非常流行的 Go 语言库，它提供了一些常用的函数式编程风格的工具函数，使得 Go 代码更加简洁、优雅。该库的设计理念是减少代码冗余，简化开发过程，尤其是在处理常见的数据结构和算法时。
lo 这个库的名字来源于 "Lazily Optimized" 的缩写，但它本身并不涉及延迟计算或优化策略。它的目标是提供一系列常见操作的简便方法，尤其是集合类型（如切片、映射、通道等）的操作。
Life is like a journey
lo 库提供了很多类似于其他语言（如 JavaScript、Python）中的函数式编程方法，如 map, filter, reduce, flatten, groupBy 等操作。lo 库的方法是建立在 Go 标准库数据结构的基础上，避免了不必要的依赖。你可以通过 Go 的包管理工具安装该库：
go get github.com/samber/lo
Map：将给定的函数应用到切片中的每个元素，并返回新的切片。
slice := []int{1, 2, 3, 4}
result := lo.Map(slice, func(v int, _ int) int {
return v * v
})
fmt.Println(result) // 输出：[1, 4, 9, 16]
Filter：对切片进行筛选，返回满足条件的元素组成的新切片。
slice := []int{1, 2, 3, 4, 5}
result := lo.Filter(slice, func(v int, _ int) bool {
return v%2 == 0
})
fmt.Println(result) // 输出：[2, 4]
Reduce：对切片中的元素进行归约，通常用于累加或者组合元素。
slice := []int{1, 2, 3, 4}
sum := lo.Reduce(slice, func(acc int, v int) int {
return acc + v
}, 0)
fmt.Println(sum) // 输出：10
Flatten：将嵌套的切片进行展平，转换为一维切片。
slice := [][]int{
{1, 2},
{3, 4},
{5, 6},
}
result := lo.Flatten(slice)
fmt.Println(result) // 输出：[1 2 3 4 5 6]
GroupBy：将切片中的元素按指定条件进行分组，返回一个映射。
slice := []int{1, 2, 3, 4, 5, 6}
result := lo.GroupBy(slice, func(v int) string {
if v%2 == 0 {
return "even"
}
return "odd"
})
fmt.Println(result) // 输出：map[even:[2 4 6] odd:[1 3 5]]
Some：检查切片中的任意元素是否满足条件。
slice := []int{1, 2, 3, 4, 5}
result := lo.Some(slice, func(v int) bool {
return v > 3
})
fmt.Println(result) // 输出：true
All：检查切片中的所有元素是否满足条件。
slice := []int{2, 4, 6, 8}
result := lo.All(slice, func(v int) bool {
return v%2 == 0
})
fmt.Println(result) // 输出：true
Distinct：去除切片中的重复元素，返回去重后的新切片。
slice := []int{1, 2, 2, 3, 4, 4, 5}
result := lo.Distinct(slice)
fmt.Println(result) // 输出：[1 2 3 4 5]
Includes：检查切片中是否包含某个元素。
slice := []int{1, 2, 3, 4, 5}
result := lo.Includes(slice, 3)
fmt.Println(result) // 输出：true
Zip：将两个切片“压缩”成一个包含配对元素的切片。
a := []int{1, 2, 3}
b := []string{"a", "b", "c"}
result := lo.Zip(a, b)
fmt.Println(result) // 输出：[1 a 2 b 3 c]
package main
import (
"fmt"
"github.com/samber/lo"
)
func main() {
// 示例：Map
numbers := []int{1, 2, 3, 4}
squared := lo.Map(numbers, func(v int, _ int) int {
return v * v
})
fmt.Println(squared) // 输出：[1 4 9 16]
// 示例：Filter
evens := lo.Filter(numbers, func(v int, _ int) bool {
return v%2 == 0
})
fmt.Println(evens) // 输出：[2 4]
// 示例：Reduce
sum := lo.Reduce(numbers, func(acc, v int) int {
return acc + v
}, 0)
fmt.Println(sum) // 输出：10
}
IndexOf 函数查找元素在切片中的索引位置。
import "github.com/samber/lo"
index := lo.IndexOf([]int{1, 2, 3, 4}, 3)
// index: 2
Contains 函数判断元素是否存在于切片中。
import "github.com/samber/lo"
exists := lo.Contains([]int{1, 2, 3, 4}, 3)
// exists: true
ToMap 函数将切片转换为映射，指定键和值的生成方式。
import "github.com/samber/lo"
people := []struct {
Name string
Age int
}{
{"Alice", 30},
{"Bob", 25},
}
nameToAge := lo.ToMap(people, func(p struct{ Name string; Age int }) (string, int) {
return p.Name, p.Age
})
// nameToAge: map[string]int{"Alice": 30, "Bob": 25}
CamelCase 函数将字符串转换为驼峰式。
import "github.com/samber/lo"
camel := lo.CamelCase("hello_world_example")
// camel: "HelloWorldExample"
SnakeCase 函数将字符串转换为蛇形命名法。
import "github.com/samber/lo"
snake := lo.SnakeCase("HelloWorldExample")
// snake: "hello_world_example"
samber/lo 提供了并发版本的函数，位于 github.com/samber/lo/parallel，用于在并发环境下执行集合操作。
Map 函数并发地对切片中的每个元素执行回调函数，并将结果收集到新的切片中。
import lop "github.com/samber/lo/parallel"
result := lop.Map([]int{1, 2, 3, 4}, func(x int, index int) int {
return x * 2
})
// result: []int{2, 4, 6, 8}
Filter 函数并发地对切片中的每个元素执行回调函数，返回满足条件的元素组成的新的切片。
import lop "github.com/samber/lo/parallel"
even := lop.Filter([]int{1, 2, 3, 4}, func(x int, index int) bool {
return x%2 == 0
})
// even: []int{2, 4}
Try 函数捕获函数执行中的 panic，并返回是否成功执行。
import "github.com/samber/lo"
success := lo.Try(func() error {
// 可能会 panic 的代码
return nil
})
// success: true 或 false
Must 函数执行函数，如果返回错误，则 panic。
import "github.com/samber/lo"
result := lo.Must(time.Parse("2006-01-02", "2022-01-15"))
// result: time.Time 类型
RandomString 函数生成指定长度的随机字符串。
import "github.com/samber/lo"
randomStr := lo.RandomString(10, lo.LettersCharset)
// randomStr: "aBcDeFgHiJ"（示例）
PascalCase 函数将字符串转换为 PascalCase 格式。
import "github.com/samber/lo"
pascalCaseStr := lo.PascalCase("hello_world")
// pascalCaseStr: "HelloWorld"
lo 都能简化数据的处理。lo 是一个非常好的选择。map, filter, reduce 等），lo 可以帮助你写出更加简洁清晰的代码。samber/lo 库通过提供函数式编程工具，使得 Go 开发者能够更加简洁高效地处理数据集合。它适用于各种需要对切片、数组、映射等数据进行常见操作的场景，能显著提升代码的可读性和开发效率。
相当好用的库，一裤在手，天下我有！