golang实用集合功能增强工具插件库go-underscore的使用

Golang实用集合功能增强工具插件库go-underscore的使用

Underscore.go

一个有用的Go工具集合,旨在提高程序员的工作效率。类似于underscore.js,但是用于Go语言。

警告

目前这个包正在大量变动中,作者正在整合来自各方的反馈。

主要功能示例

Each函数

Each函数将给定的迭代器函数应用于集合(切片或映射)的每个元素。

// var Each func(func(value interface{}, i interface{}), interface{})

var buffer bytes.Buffer

fn := func(s, i interface{}) {
  buffer.WriteString(s.(string))
}

s := []string{"a", "b", "c", "d", "e"}
Each(fn, s)

expect := "abcde"

e := un.Each(fn, s)

fmt.Printf("%#v\n", e) //"abcde"

类型化Each示例

var EachInt func(func(value, i int), []int)
MakeEach(&EachInt)

var sum int

fn := func(v, i int) {
  sum += v
}

i := []int{1, 2, 3, 4, 5}
EachInt(fn, i)

fmt.Printf("%#v\n", sum) //15

Map函数

Map函数将给定函数应用于切片的每个元素,返回结果切片。

// Map func(interface{}, func(interface{}) interface{}) []interface{}

s := []string{"a", "b", "c", "d"}

fn := func(s interface{}) interface{} {
  return s.(string) + "!"
}

m := un.Map(ToI(s), fn)
fmt.Println(m) //["a!", "b!", "c!", "d!"]

类型化Map示例

Map func([]A, func(A) B) []B

var SMap func([]string, func(string) string) []string
un.MakeMap(&SMap)

m := un.SMap(s, fn)
fmt.Println(m) //["a!", "b!", "c!", "d!"]

Partition函数

Partition函数根据提供的函数的评估结果分割切片或映射。

// Partition func(interface{}, func(interface{}) bool) ([]interface{}, []interface{})

s := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

fn := func(i interface{}) bool {
  return (i.(int) % 2) == 1
}

odd, even := un.Partition(s, fn)

fmt.Println(odd)  //[1, 3, 5, 7, 9]
fmt.Println(even) //[2, 4, 6, 8, 10]

类型化Partition示例

// Partition func([]A, func(A) bool) ([]A []A)

var IPartition func([]int, func(int) bool) ([]int, []int)

un.MakePartition(&IPartition)

s := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

fn := func(i int) bool {
  return (i % 2) == 1
}

odd, even := un.IPartition(s, fn)

fmt.Println(odd)  //[1, 3, 5, 7, 9]
fmt.Println(even) //[2, 4, 6, 8, 10]

Contains函数

Contains函数检查对象是否在切片中。

o := "a"
s := []string{"a", "b", "c"}

b := un.Contains(s, o)
fmt.Println(b) //true

ToI函数

ToI函数将任意类型的切片[]T转换为[]interface{}切片。

s := []int{1, 1, 3, 5, 8, 13}
i := un.ToI(s)

注意事项

虽然这种设计可能不完全符合Go语言的惯用方式,但它作为一个学习工具很有用,也适用于快速开发和后期优化。


更多关于golang实用集合功能增强工具插件库go-underscore的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang实用集合功能增强工具插件库go-underscore的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


go-underscore:Golang 实用集合功能增强工具库

go-underscore 是一个受 JavaScript 的 underscore.js 和 lodash 库启发的 Golang 工具库,它为 Go 的原生集合类型(如切片和映射)提供了许多实用的函数式编程方法。

主要功能

go-underscore 提供了以下主要功能:

  1. 集合操作(过滤、映射、归约等)
  2. 实用函数(查找、包含、分组等)
  3. 链式调用支持
  4. 并发安全操作

安装

go get github.com/ahl5esoft/golang-underscore

基本用法示例

1. 过滤操作

package main

import (
	"fmt"
	u "github.com/ahl5esoft/golang-underscore"
)

func main() {
	nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	
	// 过滤出偶数
	var evenNumbers []int
	u.Chain(nums).Filter(func(num int, _ int) bool {
		return num%2 == 0
	}).Value(&evenNumbers)
	
	fmt.Println(evenNumbers) // 输出: [2 4 6 8 10]
}

2. 映射操作

package main

import (
	"fmt"
	u "github.com/ahl5esoft/golang-underscore"
)

func main() {
	nums := []int{1, 2, 3, 4, 5}
	
	// 将每个数字平方
	var squares []int
	u.Chain(nums).Map(func(num int, _ int) int {
		return num * num
	}).Value(&squares)
	
	fmt.Println(squares) // 输出: [1 4 9 16 25]
}

3. 归约操作

package main

import (
	"fmt"
	u "github.com/ahl5esoft/golang-underscore"
)

func main() {
	nums := []int{1, 2, 3, 4, 5}
	
	// 计算总和
	var sum int
	u.Chain(nums).Reduce(func(acc, num int, _ int) int {
		return acc + num
	}, 0, &sum)
	
	fmt.Println(sum) // 输出: 15
}

4. 查找操作

package main

import (
	"fmt"
	u "github.com/ahl5esoft/golang-underscore"
)

func main() {
	users := []struct {
		ID   int
		Name string
	}{
		{1, "Alice"},
		{2, "Bob"},
		{3, "Charlie"},
	}
	
	// 查找ID为2的用户
	var user struct {
		ID   int
		Name string
	}
	found := u.Chain(users).Find(func(u struct {
		ID   int
		Name string
	}, _ int) bool {
		return u.ID == 2
	}).Value(&user)
	
	if found {
		fmt.Println(user.Name) // 输出: Bob
	}
}

5. 分组操作

package main

import (
	"fmt"
	u "github.com/ahl5esoft/golang-underscore"
)

func main() {
	users := []struct {
		Name string
		Age  int
	}{
		{"Alice", 25},
		{"Bob", 30},
		{"Charlie", 25},
		{"David", 30},
	}
	
	// 按年龄分组
	var grouped map[int][]string
	u.Chain(users).Group(func(u struct {
		Name string
		Age  int
	}, _ int) int {
		return u.Age
	}, &grouped)
	
	fmt.Println(grouped) // 输出: map[25:[Alice Charlie] 30:[Bob David]]
}

6. 链式调用

package main

import (
	"fmt"
	u "github.com/ahl5esoft/golang-underscore"
)

func main() {
	nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	
	// 链式操作:过滤偶数 -> 平方 -> 取前3个
	var result []int
	u.Chain(nums).Filter(func(num int, _ int) bool {
		return num%2 == 0
	}).Map(func(num int, _ int) int {
		return num * num
	}).Take(3).Value(&result)
	
	fmt.Println(result) // 输出: [4 16 36]
}

性能考虑

虽然 go-underscore 提供了便利的函数式操作,但在性能敏感的场景中,直接使用原生循环可能更高效。go-underscore 更适合在业务逻辑复杂、需要清晰表达意图的场景中使用。

总结

go-underscore 为 Golang 开发者提供了一套实用的集合操作工具,特别适合需要函数式编程风格的场景。它简化了常见的集合操作,使代码更加简洁易读。虽然性能上可能不如原生循环,但在大多数业务场景中,这种差异是可以接受的。

如果你经常需要处理复杂的集合操作,go-underscore 可以显著提高你的开发效率和代码可读性。

回到顶部