github.com/samber/lo 库使用案例讲解

1.介绍

samber/lo 是一个 Go 语言的库，提供了一

组函数式编程风格的工具函数，旨在简化集合（如切片、映射等）的操作。这个库的灵感来自于 JavaScript 的 Lodash 库，因此它的 API 和使用方式与 Lodash 类似。以下是对 samber/lo 包的一些详细介绍，包括其功能、常用函数和示例。

2.主要功能

• 集合操作: 提供了对切片和映射的各种操作，如过滤、映射、查找、排序等。
• 函数式编程: 采用函数式编程风格，易于组合和链式调用。
• 类型安全: 使用 Go 的类型系统，确保在编译时检查类型。
• 简洁可读: 通过提供的工具函数，可以减少样板代码，提高代码的可读性。

3.常用函数 

(1).lo.Map

功能: 对切片中的每个元素应用给定函数，返回一个新的切片

示例

import "github.com/samber/lo"

nums := []int{1, 2, 3}
squares := lo.Map(nums, func(n int) int {
    return n * n
})
// squares: [1, 4, 9]

(2).lo.Filter

 功能: 过滤切片中的元素，返回符合条件的新切片

示例

evenNums := lo.Filter(nums, func(n int) bool {
    return n%2 == 0
})
// evenNums: [2]

(3).lo.Find

 功能:在切片中查找第一个符合条件的元素

示例

firstEven := lo.Find(nums, func(n int) bool {
    return n%2 == 0
})
// firstEven: 2

(4).lo.Reduce

 功能: 对切片进行归约操作，将切片的所有元素通过给定函数合并为一个值

示例

sum := lo.Reduce(nums, 0, func(acc, n int) int {
    return acc + n
})
// sum: 6

(5).lo.Unique

 功能:  返回切片中的唯一元素

示例

duplicates := []int{1, 2, 2, 3, 1}
unique := lo.Unique(duplicates)
// unique: [1, 2, 3]

(6).lo.GroupBy

 功能: 按照给定函数对切片进行分组

示例

type Person struct {
    Name string
    Age  int
}

people := []Person{{"Alice", 30}, {"Bob", 25}, {"Charlie", 30}}
grouped := lo.GroupBy(people, func(p Person) int {
    return p.Age
})
// grouped: map[30:[{Alice 30} {Charlie 30}] 25:[{Bob 25}]]

(7).lo.Ternary

功能:该函数实现了类似于三元表达式的功能

代码解析:

func Ternary[T any](condition bool, ifOutput T, elseOutput T) T {
	if condition {
		return ifOutput
	}

	return elseOutput
}
//代码解析:
1.func Ternary[T any](condition bool, ifOutput T, elseOutput T) T {:
    这是函数的定义：
        (1).Ternary 是函数的名称。
        (2).[T any] 表示这是一个泛型函数，其中 T 是一个类型参数，可以是任何类型（any 是 Go 1.18 及以后的版本中的类型约束，代表任意类型）。
        (3).condition bool 是一个布尔参数，用于决定返回哪个输出。
        (4).ifOutput T 是在条件为 true 时返回的值，类型为 T。
        (5).elseOutput T 是在条件为 false 时返回的值，类型为 T。
        (6).函数的返回值类型为 T。

2.if condition {:
    这里检查 condition 参数的值。如果 condition 为 true，则执行以下代码块。

3.return ifOutput:
    如果 condition 为 true，则返回 ifOutput。

4.return elseOutput:
    如果 condition 为 false（即没有进入 if 块），则执行这一行并返回 elseOutput。

总结:

         这个函数实现了一个简单的三元运算符逻辑，允许你根据布尔条件选择性地返回两个值中的一个。使用泛型使得这个函数能够接受任意类型的输入和输出，使其更具灵活性

示例:

 

func GetGroupByName(dbClient *gorm.DB, name string, fields ...string) (result *model.Group, err error) {
	err = dbClient.Model(&model.Group{}).Select(lo.Ternary(len(fields) == 0, []string{"*"}, fields)).Where("name = ?", name).Scan(&result).Error
	return
}

package main

import (
    "fmt"
)

func Ternary[T any](condition bool, ifOutput T, elseOutput T) T {
    if condition {
        return ifOutput
    }
    return elseOutput
}

func main() {
    // 使用 Ternary 函数
    result1 := Ternary(true, "Yes", "No")
    fmt.Println(result1) // 输出: Yes

    result2 := Ternary(false, 42, 0)
    fmt.Println(result2) // 输出: 0
}

(8).lo.Contains 

功能:lo.Contains 用于检查一个切片中是否包含某个特定的元素。如果切片中存在该元素，则返回 true，否则返回 false

示例

//slice: 要检查的切片。
//item: 要查找的元素
func Contains[T comparable](slice []T, item T) bool

package main

import (
    "fmt"
    "github.com/samber/lo"
)

func main() {
    nums := []int{1, 2, 3, 4, 5}
    
    exists := lo.Contains(nums, 3)
    fmt.Println(exists) // 输出: true

    notExists := lo.Contains(nums, 6)
    fmt.Println(notExists) // 输出: false
}

 

(9).lo.ContainsBy

功能:用于通过给定的条件函数检查切片中是否存在某个满足条件的元素。该函数允许你指定一个自定义的判断逻辑

示例

//lice: 要检查的切片。
//predicate: 一个返回布尔值的函数，用于判断切片中的每个元素是否满足特定条件
func ContainsBy[T any](slice []T, predicate func(T) bool) bool


package main

import (
    "fmt"
    "github.com/samber/lo"
)

func main() {
    nums := []int{1, 2, 3, 4, 5}
    
    exists := lo.ContainsBy(nums, func(n int) bool {
        return n > 3
    })
    fmt.Println(exists) // 输出: true

    notExists := lo.ContainsBy(nums, func(n int) bool {
        return n > 5
    })
    fmt.Println(notExists) // 输出: false
}

(10).lo.Map

功能:lo.Map 用于对切片中的每个元素应用给定的函数，并返回一个新的切片，包含函数输出的结果

示例

//slice: 要映射的切片。
//fn: 一个函数，对切片中的每个元素进行处理，并返回一个新值。
func Map[T any, U any](slice []T, fn func(T) U) []U

package main

import (
    "fmt"
    "github.com/samber/lo"
)

func main() {
    nums := []int{1, 2, 3, 4, 5}
    
    squares := lo.Map(nums, func(n int) int {
        return n * n
    })
    fmt.Println(squares) // 输出: [1 4 9 16 25]
}

4.安装 

要使用 samber/lo 包，可以通过 Go Modules 进行安装:

go get github.com/samber/lo

5.总结

samber/lo 包提供了一系列功能强大且易于使用的工具函数，能够极大地简化在 Go 中对集合的操作。其函数式编程的特性使得代码更加简洁和可读，非常适合需要处理大量数据的应用场景。如果你习惯于使用 Lodash 或者类似的库，samber/lo 将会是一个非常不错的选择