golang通用数据结构操作工具插件库just的使用

Golang通用数据结构操作工具插件库just的使用

just是一个Golang工具库,包含了许多帮助简化项目中常见操作的实用功能。

主要功能

  • 过滤切片和映射
  • 对集合应用函数
  • 提供Null[any]类型用于API和sql.DB查询中的可选字段

最有用的函数

  • SliceIter:允许使用特殊的IterContext迭代切片,提供IsFirstIsLast等方法
  • SliceMapSliceMapErr:将一个切片映射到另一个切片,适用于适配器
  • NewPool:使用泛型的sync.Pool
  • ChanAdapt:创建通道的适配版本
  • ContextWithTimeout:使用上下文和超时运行函数
  • ErrAs:帮助处理错误
  • SliceChunk:迭代分块
  • SliceChain:将多个切片连接成一个
  • StrSplitByChars:按字符分割字符串

示例代码

SliceMap示例

package main

import (
	"fmt"
	"github.com/kazhuravlev/just"
)

func main() {
	// 将字符串切片转换为长度切片
	names := []string{"Alice", "Bob", "Charlie"}
	nameLengths := just.SliceMap(names, func(name string) int {
		return len(name)
	})
	
	fmt.Println(nameLengths) // 输出: [5 3 7]
}

SliceIter示例

package main

import (
	"fmt"
	"github.com/kazhuravlev/just"
)

func main() {
	numbers := []int{10, 20, 30, 40}
	
	just.SliceIter(numbers, func(ctx just.IterContext[int], num int) {
		if ctx.IsFirst() {
			fmt.Println("开始迭代:")
		}
		
		fmt.Printf("索引: %d, 值: %d", ctx.Index(), num)
		
		if !ctx.IsLast() {
			fmt.Print(" | ")
		} else {
			fmt.Println("\n迭代结束")
		}
	})
	
	// 输出:
	// 开始迭代:
	// 索引: 0, 值: 10 | 索引: 1, 值: 20 | 索引: 2, 值: 30 | 索引: 3, 值: 40
	// 迭代结束
}

SliceChunk示例

package main

import (
	"fmt"
	"github.com/kazhuravlev/just"
)

func main() {
	data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	chunks := just.SliceChunk(data, 3)
	
	for _, chunk := range chunks {
		fmt.Println(chunk)
	}
	
	// 输出:
	// [1 2 3]
	// [4 5 6]
	// [7 8 9]
}

NewPool示例

package main

import (
	"fmt"
	"github.com/kazhuravlev/just"
)

func main() {
	// 创建一个字符串池
	stringPool := just.NewPool(func() string {
		return "" // 初始化新字符串
	})
	
	// 从池中获取字符串
	str := stringPool.Get()
	str = "Hello, World!"
	
	// 使用后放回池中
	stringPool.Put(str)
	
	// 再次获取
	str2 := stringPool.Get()
	fmt.Println(str2) // 可能是之前的值或新初始化的空字符串
}

ContextWithTimeout示例

package main

import (
	"context"
	"fmt"
	"time"
	"github.com/kazhuravlev/just"
)

func longRunningTask(ctx context.Context) error {
	select {
	case <-time.After(2 * time.Second):
		fmt.Println("任务完成")
		return nil
	case <-ctx.Done():
		fmt.Println("任务取消")
		return ctx.Err()
	}
}

func main() {
	err := just.ContextWithTimeout(1*time.Second, longRunningTask)
	fmt.Println("错误:", err) // 输出: 错误: context deadline exceeded
}

just库包含了许多其他有用的函数,建议查看官方文档获取完整的功能列表和更多示例。


更多关于golang通用数据结构操作工具插件库just的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang通用数据结构操作工具插件库just的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Just - Go语言通用数据结构操作工具库

Just 是一个轻量级的 Go 语言工具库,提供了一系列方便的数据结构操作方法,可以简化日常开发中对集合、字典、字符串等常见数据结构的操作。

主要功能

1. 集合操作

import "github.com/kataras/just"

// 切片去重
func ExampleDistinct() {
    slice := []int{1, 2, 2, 3, 4, 4, 5}
    unique := just.Distinct(slice)
    fmt.Println(unique) // [1 2 3 4 5]
}

// 切片过滤
func ExampleFilter() {
    numbers := []int{1, 2, 3, 4, 5, 6}
    even := just.Filter(numbers, func(n int) bool {
        return n%2 == 0
    })
    fmt.Println(even) // [2 4 6]
}

// 切片映射转换
func ExampleMap() {
    numbers := []int{1, 2, 3}
    squared := just.Map(numbers, func(n int) int {
        return n * n
    })
    fmt.Println(squared) // [1 4 9]
}

2. 字典操作

// 字典映射转换
func ExampleMapDict() {
    dict := map[string]int{"a": 1, "b": 2, "c": 3}
    result := just.MapDict(dict, func(k string, v int) (string, string) {
        return k, fmt.Sprintf("value-%d", v)
    })
    fmt.Println(result) // map[a:value-1 b:value-2 c:value-3]
}

// 字典过滤
func ExampleFilterDict() {
    dict := map[string]int{"a": 1, "b": 2, "c": 3, "d": 4}
    filtered := just.FilterDict(dict, func(k string, v int) bool {
        return v > 2
    })
    fmt.Println(filtered) // map[c:3 d:4]
}

3. 字符串处理

// 字符串截取
func ExampleSubstring() {
    str := "hello world"
    sub := just.Substring(str, 6, 5)
    fmt.Println(sub) // "world"
}

// 字符串分割
func ExampleSplit() {
    str := "a,b,c,d"
    parts := just.Split(str, ",")
    fmt.Println(parts) // ["a" "b" "c" "d"]
}

// 字符串连接
func ExampleJoin() {
    parts := []string{"a", "b", "c"}
    joined := just.Join(parts, "-")
    fmt.Println(joined) // "a-b-c"
}

4. 其他实用工具

// 条件判断
func ExampleIf() {
    result := just.If(true, "yes", "no")
    fmt.Println(result) // "yes"
}

// 空值处理
func ExampleDefault() {
    var s string
    val := just.Default(s, "default")
    fmt.Println(val) // "default"
}

// 错误处理简化
func ExampleTry() {
    err := just.Try(func() error {
        // 可能会出错的代码
        return nil
    })
    if err != nil {
        fmt.Println("Error:", err)
    }
}

安装

go get github.com/kataras/just

优势特点

  1. 类型安全 - 使用泛型实现,保证类型安全
  2. 零依赖 - 不依赖其他第三方库
  3. 高性能 - 经过优化,性能接近原生操作
  4. 简洁API - 方法命名直观,易于理解和使用

使用场景

  • 快速处理数据集合的过滤、映射、去重等操作
  • 简化字典数据的转换和处理
  • 字符串的常见操作封装
  • 简化日常开发中的样板代码

Just 库非常适合在需要频繁操作数据结构的项目中作为辅助工具使用,可以显著减少重复代码,提高开发效率。

回到顶部