Merge branch 'v2' of github.com:duke-git/lancet into v2

* feat: add address.Smart and Decompose for parse CN address

* feat: add Xinjiang directly-administered county-level cities support

- Add '自治区直辖县级市' as a city-level unit (ID: 4043) in A2Data for Xinjiang
- Add 12 directly-administered county-level cities in A3Data (IDs: 4044-4055):
  * 石河子市 (Shihezi, 1976, 8th Division) - ID: 4044
  * 阿拉尔市 (Aral, 2002, 1st Division) - ID: 4045
  * 图木舒克市 (Tumxuk, 2002, 3rd Division) - ID: 4046
  * 五家渠市 (Wujiaqu, 2002, 6th Division) - ID: 4047
  * 北屯市 (Beitun, 2011, 10th Division) - ID: 4048
  * 铁门关市 (Tiemenguan, 2012, 2nd Division) - ID: 4049
  * 双河市 (Shuanghe, 2014, 5th Division) - ID: 4050
  * 可克达拉市 (Kokdala, 2015, 4th Division) - ID: 4051
  * 昆玉市 (Kunyu, 2016, 14th Division) - ID: 4052
  * 胡杨河市 (Huyanghe, 2019, 7th Division) - ID: 4053
  * 新星市 (Xinxing, 2021, 13th Division) - ID: 4054
  * 白杨市 (Baiyang, 2023, 9th Division) - ID: 4055
- All county-level cities are under PID 4043 (自治区直辖县级市)
- Add test case for Xinjiang Shihezi city address parsing
- Now supports parsing addresses like: 新疆石河子市北三路25小区

* docs: formated address data

* fix: parse repeat address error

* feat: update readme file

---------

Co-authored-by: Jiawen <im@linjiawen.com>

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+liberapay: Duke_Du
+patreon: DukeDu

.github/workflows/codecov.yml

@@ -3,11 +3,11 @@ on:
   push:
     branches:
       - main
-      # - v2
+      - rc
   pull_request:
     branches:
       - main
-      # - v2
+      - rc
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -17,8 +17,10 @@ jobs:
           fetch-depth: 2
       - uses: actions/setup-go@v2
         with:
-          go-version: "1.18"
+          go-version: "1.20"
       - name: Run coverage
         run: go test -v ./... -coverprofile=coverage.txt -covermode=atomic
+      - name: Run govet
+        run: go vet -v ./...
       - name: Upload coverage to Codecov
         run: bash <(curl -s https://codecov.io/bash)

.gitignore

@@ -8,5 +8,8 @@ fileutil/*.link
 fileutil/unzip/*
 fileutil/tempdir/*
 slice/testdata/*
-cryptor/*.pem
-test
+# cryptor/*.pem
+test
+docs/node_modules
+docs/.vitepress/cache
+docs/.vitepress/dist

CONTRIBUTION.md

@@ -0,0 +1,37 @@
+# Lancet Contribution Guide
+
+Hi! Thank you for choosing Lancet.
+
+Lancet is a powerful, efficient, and reusable util function library of go. It makes Go dev easier by taking the hassle out of working with concurrency, net, math, slice, string, etc.
+
+We are excited that you are interested in contributing to lancet. Before submitting your contribution though, please make sure to take a moment and read through the following guidelines.
+
+## Issue Guidelines
+
+- Issues are exclusively for bug reports, feature requests and design-related topics. Other questions may be closed directly.
+
+- Before submitting an issue, please check if similar problems have already been issued.
+
+- Please specify which version of Lancet and Go you are using, and provide OS information. [Go Playground](https://go.dev/play/) is recommended to build a live demo so that your issue can be reproduced clearly.
+
+## Pull Request Guidelines
+
+- Fork this repository to your own account. Do not create branches here.
+
+- Commit info should be formatted as `type(scope): info about commit`. eg. `fix(package): [scrollbar] fix xxx bug`.
+
+  1. type: type must be one of [chore, docs, feat, fix, refactor, release, test].
+
+  2. scope: scope must be one of [package, file, internal].
+
+  3. header: header must not be longer than 72 characters.
+
+- Rebase before creating a PR to keep commit history clear.
+
+- Before submitting a PR, please execute the unit test command: `go test -v ./...` to ensure that all unit test tasks should pass.
+
+- Make sure PRs are created to `rc` branch instead of other branch.
+
+- If your PR fixes a bug, please provide a description about the related bug.
+
+- If the PR is for a new feature, make sure to complete the relevant documentation (/lancet/docs/en/api/packages).

CONTRIBUTION.zh-CN.md

@@ -0,0 +1,37 @@
+# Lancet 贡献指南
+
+Hi! 首先感谢你使用 Lancet。
+
+lancet（柳叶刀）是一个功能强大、全面、高效、可复用的go语言工具函数库。它消除了处理并发、网络、数学、切片、字符串等的麻烦，使 Go 开发变得更容易。
+
+Lancet 的成长离不开大家的支持，如果你愿意为 Lancet 贡献代码或提供建议，请阅读以下内容。
+
+## Issue 规范
+
+- issue 仅用于提交 Bug 或 Feature 以及设计相关的内容，其它内容可能会被直接关闭。
+
+- 在提交 issue 之前，请搜索相关内容是否已被提出。
+
+- 请说明 Lancet 和 Go 的版本号，并提供操作系统信息。推荐使用 [Go Playground](https://go.dev/play/) 生成在线 demo，这能够更直观地重现问题。
+
+## Pull Request 规范
+
+- 请先 fork 一份到自己的项目下，不要直接在仓库下建分支。
+
+- commit 信息要以 `type(scope): 描述信息` 的形式填写，例如 `fix(package): [scrollbar] fix xxx bug`。
+
+  1. type: 必须是 chore, docs, feat, fix, refactor, release, test 其中的一个。
+
+  2. scope: 必须是 package, file, internal 其中的一个。
+
+  3. header: 描述信息不要超过 72 个字符。
+
+- 提交 PR 前请 rebase，确保 commit 记录的整洁。
+
+- 提交 PR 前请执行单元测试命令：go test -v ./...，确保所有单元测试任务通过。
+
+- 确保 PR 是提交到 `rc` 分支，而不是其他分支。
+
+- 如果是修复 bug，请在 PR 中给出描述信息。
+
+- 如果PR是新功能，确保完成相关文档(/lancet/docs/api/packages)。

algorithm/lrucache.go

@@ -44,7 +44,7 @@ func (l *LRUCache[K, V]) Get(key K) (V, bool) {
 
 	node, ok := l.cache[key]
 	if ok {
-		l.moveToHead(node)
+		l.moveToTail(node)
 		return node.value, true
 	}
 
@@ -66,7 +66,7 @@ func (l *LRUCache[K, V]) Put(key K, value V) {
 		}
 	} else {
 		node.value = value
-		l.moveToHead(node)
+		l.moveToTail(node)
 	}
 	l.length = len(l.cache)
 }
@@ -79,7 +79,7 @@ func (l *LRUCache[K, V]) Delete(key K) bool {
 		delete(l.cache, key)
 		return true
 	}
-
+	l.length = len(l.cache)
 	return false
 }
 
@@ -112,7 +112,7 @@ func (l *LRUCache[K, V]) deleteNode(node *lruNode[K, V]) K {
 	return node.key
 }
 
-func (l *LRUCache[K, V]) moveToHead(node *lruNode[K, V]) {
+func (l *LRUCache[K, V]) moveToTail(node *lruNode[K, V]) {
 	if l.tail == node {
 		return
 	}

algorithm/lrucache_test.go

@@ -8,7 +8,7 @@ import (
 
 func TestLRUCache(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestLRUCache")
+	assert := internal.NewAssert(t, "TestLRUCache")
 
 	cache := NewLRUCache[int, int](3)
 
@@ -16,19 +16,19 @@ func TestLRUCache(t *testing.T) {
 	cache.Put(2, 2)
 	cache.Put(3, 3)
 
-	asssert.Equal(3, cache.Len())
+	assert.Equal(3, cache.Len())
 
 	v, ok := cache.Get(1)
-	asssert.Equal(true, ok)
-	asssert.Equal(1, v)
+	assert.Equal(true, ok)
+	assert.Equal(1, v)
 
 	v, ok = cache.Get(2)
-	asssert.Equal(true, ok)
-	asssert.Equal(2, v)
+	assert.Equal(true, ok)
+	assert.Equal(2, v)
 
 	ok = cache.Delete(2)
-	asssert.Equal(true, ok)
+	assert.Equal(true, ok)
 
 	_, ok = cache.Get(2)
-	asssert.Equal(false, ok)
+	assert.Equal(false, ok)
 }

algorithm/search.go

@@ -4,7 +4,7 @@
 // Package algorithm contain some basic algorithm functions. eg. sort, search, list, linklist, stack, queue, tree, graph.
 package algorithm
 
-import "github.com/duke-git/lancet/v2/lancetconstraints"
+import "github.com/duke-git/lancet/v2/constraints"
 
 // Search algorithms see https://github.com/TheAlgorithms/Go/tree/master/search
 
@@ -23,7 +23,7 @@ func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int {
 // BinarySearch return the index of target within a sorted slice, use binary search (recursive call itself).
 // If not found return -1.
 // Play: https://go.dev/play/p/t6MeGiUSN47
-func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int {
+func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int {
 	if highIndex < lowIndex || len(sortedSlice) == 0 {
 		return -1
 	}
@@ -44,7 +44,7 @@ func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, com
 // BinaryIterativeSearch return the index of target within a sorted slice, use binary search (no recursive).
 // If not found return -1.
 // Play: https://go.dev/play/p/Anozfr8ZLH3
-func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int {
+func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int {
 	startIndex := lowIndex
 	endIndex := highIndex
 

algorithm/search_test.go

@@ -8,34 +8,34 @@ import (
 
 func TestLinearSearch(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestLinearSearch")
+	assert := internal.NewAssert(t, "TestLinearSearch")
 
 	numbers := []int{3, 4, 5, 3, 2, 1}
 	equalFunc := func(a, b int) bool {
 		return a == b
 	}
 
-	asssert.Equal(0, LinearSearch(numbers, 3, equalFunc))
-	asssert.Equal(-1, LinearSearch(numbers, 6, equalFunc))
+	assert.Equal(0, LinearSearch(numbers, 3, equalFunc))
+	assert.Equal(-1, LinearSearch(numbers, 6, equalFunc))
 }
 
 func TestBinarySearch(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestBinarySearch")
+	assert := internal.NewAssert(t, "TestBinarySearch")
 
 	sortedNumbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
 	comparator := &intComparator{}
 
-	asssert.Equal(4, BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
-	asssert.Equal(-1, BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
+	assert.Equal(4, BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
+	assert.Equal(-1, BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
 }
 
 func TestBinaryIterativeSearch(t *testing.T) {
-	asssert := internal.NewAssert(t, "TestBinaryIterativeSearch")
+	assert := internal.NewAssert(t, "TestBinaryIterativeSearch")
 
 	sortedNumbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
 	comparator := &intComparator{}
 
-	asssert.Equal(4, BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
-	asssert.Equal(-1, BinaryIterativeSearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
+	assert.Equal(4, BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
+	assert.Equal(-1, BinaryIterativeSearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
 }

algorithm/sort.go

@@ -3,24 +3,29 @@
 
 package algorithm
 
-import "github.com/duke-git/lancet/v2/lancetconstraints"
+import "github.com/duke-git/lancet/v2/constraints"
 
 // BubbleSort applys the bubble sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/GNdv7Jg2Taj
-func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func BubbleSort[T any](slice []T, comparator constraints.Comparator) {
 	for i := 0; i < len(slice); i++ {
+		breakTag := false
 		for j := 0; j < len(slice)-1-i; j++ {
 			isCurrGreatThanNext := comparator.Compare(slice[j], slice[j+1]) == 1
 			if isCurrGreatThanNext {
 				swap(slice, j, j+1)
+				breakTag = true
 			}
 		}
+		if !breakTag {
+			break
+		}
 	}
 }
 
 // InsertionSort applys the insertion sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/G5LJiWgJJW6
-func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func InsertionSort[T any](slice []T, comparator constraints.Comparator) {
 	for i := 0; i < len(slice); i++ {
 		for j := i; j > 0; j-- {
 			isPreLessThanCurrent := comparator.Compare(slice[j], slice[j-1]) == -1
@@ -35,7 +40,7 @@ func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 
 // SelectionSort applys the selection sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/oXovbkekayS
-func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func SelectionSort[T any](slice []T, comparator constraints.Comparator) {
 	for i := 0; i < len(slice); i++ {
 		min := i
 		for j := i + 1; j < len(slice); j++ {
@@ -49,7 +54,7 @@ func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 
 // ShellSort applys the shell sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/3ibkszpJEu3
-func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func ShellSort[T any](slice []T, comparator constraints.Comparator) {
 	size := len(slice)
 
 	gap := 1
@@ -69,11 +74,11 @@ func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 
 // QuickSort quick sorting for slice, lowIndex is 0 and highIndex is len(slice)-1.
 // Play: https://go.dev/play/p/7Y7c1Elk3ax
-func QuickSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func QuickSort[T any](slice []T, comparator constraints.Comparator) {
 	quickSort(slice, 0, len(slice)-1, comparator)
 }
 
-func quickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
+func quickSort[T any](slice []T, lowIndex, highIndex int, comparator constraints.Comparator) {
 	if lowIndex < highIndex {
 		p := partition(slice, lowIndex, highIndex, comparator)
 		quickSort(slice, lowIndex, p-1, comparator)
@@ -82,7 +87,7 @@ func quickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconst
 }
 
 // partition split slice into two parts
-func partition[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int {
+func partition[T any](slice []T, lowIndex, highIndex int, comparator constraints.Comparator) int {
 	p := slice[highIndex]
 	i := lowIndex
 	for j := lowIndex; j < highIndex; j++ {
@@ -99,7 +104,7 @@ func partition[T any](slice []T, lowIndex, highIndex int, comparator lancetconst
 
 // HeapSort applys the heap sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/u6Iwa1VZS_f
-func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func HeapSort[T any](slice []T, comparator constraints.Comparator) {
 	size := len(slice)
 
 	for i := size/2 - 1; i >= 0; i-- {
@@ -111,7 +116,7 @@ func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 	}
 }
 
-func sift[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
+func sift[T any](slice []T, lowIndex, highIndex int, comparator constraints.Comparator) {
 	i := lowIndex
 	j := 2*i + 1
 
@@ -133,11 +138,11 @@ func sift[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraint
 
 // MergeSort applys the merge sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/ydinn9YzUJn
-func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func MergeSort[T any](slice []T, comparator constraints.Comparator) {
 	mergeSort(slice, 0, len(slice)-1, comparator)
 }
 
-func mergeSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
+func mergeSort[T any](slice []T, lowIndex, highIndex int, comparator constraints.Comparator) {
 	if lowIndex < highIndex {
 		mid := (lowIndex + highIndex) / 2
 		mergeSort(slice, lowIndex, mid, comparator)
@@ -146,7 +151,7 @@ func mergeSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconst
 	}
 }
 
-func merge[T any](slice []T, lowIndex, midIndex, highIndex int, comparator lancetconstraints.Comparator) {
+func merge[T any](slice []T, lowIndex, midIndex, highIndex int, comparator constraints.Comparator) {
 	i := lowIndex
 	j := midIndex + 1
 	temp := []T{}
@@ -175,7 +180,7 @@ func merge[T any](slice []T, lowIndex, midIndex, highIndex int, comparator lance
 
 // CountSort applys the count sort algorithm to sort the collection, don't change the original collection data.
 // Play: https://go.dev/play/p/tB-Umgm0DrP
-func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
+func CountSort[T any](slice []T, comparator constraints.Comparator) []T {
 	size := len(slice)
 	out := make([]T, size)
 

algorithm/sort_test.go

@@ -16,7 +16,7 @@ type people struct {
 // PeopleAageComparator sort people slice by age field
 type peopleAgeComparator struct{}
 
-// Compare implements github.com/duke-git/lancet/v2/lancetconstraints/constraints.go/Comparator
+// Compare implements github.com/duke-git/lancet/v2/constraints/constraints.go/Comparator
 func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
 	p1, _ := v1.(people)
 	p2, _ := v2.(people)
@@ -47,7 +47,7 @@ func (c *intComparator) Compare(v1 any, v2 any) int {
 
 func TestBubbleSortForStructSlice(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestBubbleSortForStructSlice")
+	assert := internal.NewAssert(t, "TestBubbleSortForStructSlice")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -62,23 +62,23 @@ func TestBubbleSortForStructSlice(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestBubbleSortForIntSlice(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestBubbleSortForIntSlice")
+	assert := internal.NewAssert(t, "TestBubbleSortForIntSlice")
 
 	numbers := []int{2, 1, 5, 3, 6, 4}
 	comparator := &intComparator{}
 	BubbleSort(numbers, comparator)
 
-	asssert.Equal([]int{1, 2, 3, 4, 5, 6}, numbers)
+	assert.Equal([]int{1, 2, 3, 4, 5, 6}, numbers)
 }
 
 func TestInsertionSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestInsertionSort")
+	assert := internal.NewAssert(t, "TestInsertionSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -93,12 +93,12 @@ func TestInsertionSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestSelectionSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestSelectionSort")
+	assert := internal.NewAssert(t, "TestSelectionSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -113,12 +113,12 @@ func TestSelectionSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestShellSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestShellSort")
+	assert := internal.NewAssert(t, "TestShellSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -133,12 +133,12 @@ func TestShellSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestQuickSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestQuickSort")
+	assert := internal.NewAssert(t, "TestQuickSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -153,12 +153,12 @@ func TestQuickSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestHeapSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestHeapSort")
+	assert := internal.NewAssert(t, "TestHeapSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -173,12 +173,12 @@ func TestHeapSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestMergeSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestMergeSort")
+	assert := internal.NewAssert(t, "TestMergeSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -193,12 +193,12 @@ func TestMergeSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestCountSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestCountSort")
+	assert := internal.NewAssert(t, "TestCountSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -213,5 +213,5 @@ func TestCountSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", sortedPeopleByAge)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }

compare/compare.go

@@ -66,6 +66,7 @@ func GreaterOrEqual(left, right any) bool {
 }
 
 // InDelta checks if two values are equal or not within a delta.
+// Play: https://go.dev/play/p/TuDdcNtMkjo
 func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool {
 	return float64(mathutil.Abs(left-right)) <= delta
 }

compare/compare_internal.go

@@ -3,6 +3,7 @@ package compare
 import (
 	"bytes"
 	"encoding/json"
+	"math/big"
 	"reflect"
 	"time"
 
@@ -24,6 +25,13 @@ func compareValue(operator string, left, right any) bool {
 
 	case reflect.Struct, reflect.Slice, reflect.Map:
 		return compareRefValue(operator, left, right, leftType.Kind())
+
+	case reflect.Ptr:
+		if leftVal, ok := left.(*big.Int); ok {
+			if rightVal, ok := right.(*big.Int); ok {
+				return compareBigInt(operator, leftVal, rightVal)
+			}
+		}
 	}
 
 	return false
@@ -70,7 +78,7 @@ func compareRefValue(operator string, leftObj, rightObj any, kind reflect.Kind)
 
 			switch operator {
 			case equal:
-				if bytes.Compare(bytesObj1, bytesObj2) == 0 {
+				if bytes.Equal(bytesObj1, bytesObj2) {
 					return true
 				}
 			case lessThan:
@@ -155,169 +163,129 @@ func compareBasicValue(operator string, leftValue, rightValue any) bool {
 	}
 
 	switch leftVal := leftValue.(type) {
-	case json.Number:
-		if left, err := leftVal.Float64(); err == nil {
-			switch rightVal := rightValue.(type) {
-			case json.Number:
-				if right, err := rightVal.Float64(); err == nil {
-					switch operator {
-					case equal:
-						if left == right {
-							return true
-						}
-					case lessThan:
-						if left < right {
-							return true
-						}
-					case greaterThan:
-						if left > right {
-							return true
-						}
-					case lessOrEqual:
-						if left <= right {
-							return true
-						}
-					case greaterOrEqual:
-						if left >= right {
-							return true
-						}
-					}
-
-				}
-
-			case float32, float64, int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
-				right, err := convertor.ToFloat(rightValue)
-				if err != nil {
-					return false
-				}
-				switch operator {
-				case equal:
-					if left == right {
-						return true
-					}
-				case lessThan:
-					if left < right {
-						return true
-					}
-				case greaterThan:
-					if left > right {
-						return true
-					}
-				case lessOrEqual:
-					if left <= right {
-						return true
-					}
-				case greaterOrEqual:
-					if left >= right {
-						return true
-					}
-				}
-			}
-
+	case int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
+		left, err := convertor.ToBigInt(leftValue)
+		if err != nil {
+			return false
 		}
 
-	case float32, float64, int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
+		right, err := convertor.ToBigInt(rightValue)
+		if err != nil {
+			return false
+		}
+
+		return compareBigInt(operator, left, right)
+
+	case float32, float64:
 		left, err := convertor.ToFloat(leftValue)
 		if err != nil {
 			return false
 		}
-		switch rightVal := rightValue.(type) {
-		case json.Number:
-			if right, err := rightVal.Float64(); err == nil {
-				switch operator {
-				case equal:
-					if left == right {
-						return true
-					}
-				case lessThan:
-					if left < right {
-						return true
-					}
-				case greaterThan:
-					if left > right {
-						return true
-					}
-				case lessOrEqual:
-					if left <= right {
-						return true
-					}
-				case greaterOrEqual:
-					if left >= right {
-						return true
-					}
-				}
-			}
-		case float32, float64, int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
-			right, err := convertor.ToFloat(rightValue)
-			if err != nil {
-				return false
-			}
-
-			switch operator {
-			case equal:
-				if left == right {
-					return true
-				}
-			case lessThan:
-				if left < right {
-					return true
-				}
-			case greaterThan:
-				if left > right {
-					return true
-				}
-			case lessOrEqual:
-				if left <= right {
-					return true
-				}
-			case greaterOrEqual:
-				if left >= right {
-					return true
-				}
-			}
+		right, err := convertor.ToFloat(rightValue)
+		if err != nil {
+			return false
 		}
 
+		return compareFloats(operator, left, right)
+
 	case string:
 		left := leftVal
 		switch right := rightValue.(type) {
 		case string:
-			switch operator {
-			case equal:
-				if left == right {
-					return true
-				}
-			case lessThan:
-				if left < right {
-					return true
-				}
-			case greaterThan:
-				if left > right {
-					return true
-				}
-			case lessOrEqual:
-				if left <= right {
-					return true
-				}
-			case greaterOrEqual:
-				if left >= right {
-					return true
-				}
-			}
+			return compareStrings(operator, left, right)
 		}
 
 	case bool:
 		left := leftVal
 		switch right := rightValue.(type) {
 		case bool:
-			switch operator {
-			case equal:
-				if left == right {
-					return true
-				}
-			}
+			return compareBools(operator, left, right)
 		}
 
+	case json.Number:
+		if left, err := leftVal.Float64(); err == nil {
+			switch rightVal := rightValue.(type) {
+			case json.Number:
+				if right, err := rightVal.Float64(); err == nil {
+					return compareFloats(operator, left, right)
+				}
+			case float32, float64:
+				right, err := convertor.ToFloat(rightValue)
+				if err != nil {
+					return false
+				}
+				return compareFloats(operator, left, right)
+
+			case int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
+				right, err := convertor.ToBigInt(rightValue)
+				if err != nil {
+					return false
+				}
+				left, err := convertor.ToBigInt(left)
+				return compareBigInt(operator, left, right)
+			}
+		}
 	}
 
 	return false
 }
+
+// compareBigInt compares two big.Int values based on the operator
+func compareBigInt(operator string, left, right *big.Int) bool {
+	switch operator {
+	case equal:
+		return left.Cmp(right) == 0
+	case lessThan:
+		return left.Cmp(right) < 0
+	case greaterThan:
+		return left.Cmp(right) > 0
+	case lessOrEqual:
+		return left.Cmp(right) <= 0
+	case greaterOrEqual:
+		return left.Cmp(right) >= 0
+	}
+	return false
+}
+
+// compareFloats compares two float64 values based on the operator
+func compareFloats(operator string, left, right float64) bool {
+	switch operator {
+	case equal:
+		return left == right
+	case lessThan:
+		return left < right
+	case greaterThan:
+		return left > right
+	case lessOrEqual:
+		return left <= right
+	case greaterOrEqual:
+		return left >= right
+	}
+	return false
+}
+
+// compareStrings compares two string values based on the operator
+func compareStrings(operator string, left, right string) bool {
+	switch operator {
+	case equal:
+		return left == right
+	case lessThan:
+		return left < right
+	case greaterThan:
+		return left > right
+	case lessOrEqual:
+		return left <= right
+	case greaterOrEqual:
+		return left >= right
+	}
+	return false
+}
+
+// compareBools compares two boolean values based on the operator
+func compareBools(operator string, left, right bool) bool {
+	switch operator {
+	case equal:
+		return left == right
+	}
+	return false
+}

compare/compare_test.go

@@ -1,6 +1,8 @@
 package compare
 
 import (
+	"encoding/json"
+	"math/big"
 	"testing"
 	"time"
 
@@ -11,146 +13,191 @@ func TestEqual(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestEqual")
 
-	assert.Equal(true, Equal(1, 1))
-	assert.Equal(true, Equal(int64(1), int64(1)))
-	assert.Equal(true, Equal("a", "a"))
-	assert.Equal(true, Equal(true, true))
-	assert.Equal(true, Equal([]int{1, 2, 3}, []int{1, 2, 3}))
-	assert.Equal(true, Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"}))
-
-	assert.Equal(false, Equal(1, 2))
-	assert.Equal(false, Equal(1, int64(1)))
-	assert.Equal(false, Equal("a", "b"))
-	assert.Equal(false, Equal(true, false))
-	assert.Equal(false, Equal([]int{1, 2}, []int{1, 2, 3}))
-	assert.Equal(false, Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a"}))
-
-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	time3 := time1.Add(time.Second)
-
-	assert.Equal(false, Equal(time1, time2))
-	assert.Equal(true, Equal(time2, time3))
-
-	st1 := struct {
-		A string
-		B string
+	tests := []struct {
+		left  any
+		right any
+		want  bool
 	}{
-		A: "a",
-		B: "b",
+		{1, 1, true},
+		{int64(1), int64(1), true},
+		{"a", "a", true},
+		{true, true, true},
+		{[]int{1, 2, 3}, []int{1, 2, 3}, true},
+		{map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"}, true},
+		{1, 2, false},
+		{1, int64(1), false},
+		{"a", "b", false},
+		{true, false, false},
+		{[]int{1, 2}, []int{1, 2, 3}, false},
+		{map[int]string{1: "a", 2: "b"}, map[int]string{1: "a"}, false},
+		// {time.Now(), time.Now(), true},
+		// {time.Now(), time.Now().Add(time.Second), false},
+		{[]byte("hello"), []byte("hello"), true},
+		{[]byte("hello"), []byte("world"), false},
+		{json.Number("123"), json.Number("123"), true},
+		{json.Number("123"), json.Number("124"), false},
+
+		{big.NewInt(123), big.NewInt(123), true},
 	}
 
-	st2 := struct {
-		A string
-		B string
-	}{
-		A: "a",
-		B: "b",
+	for _, tt := range tests {
+		assert.Equal(tt.want, Equal(tt.left, tt.right))
 	}
 
-	st3 := struct {
-		A string
-		B string
-	}{
-		A: "a1",
-		B: "b",
-	}
-
-	assert.Equal(true, Equal(st1, st2))
-	assert.Equal(false, Equal(st1, st3))
 }
 
 func TestEqualValue(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestEqualValue")
 
-	assert.Equal(true, EqualValue(1, 1))
-	assert.Equal(true, EqualValue(int(1), int64(1)))
-	assert.Equal(true, EqualValue(1, "1"))
+	tests := []struct {
+		left  any
+		right any
+		want  bool
+	}{
+		{1, 1, true},
+		{int64(1), int64(1), true},
+		{"a", "a", true},
+		{true, true, true},
+		{[]int{1, 2, 3}, []int{1, 2, 3}, true},
+		{map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"}, true},
+		{1, 2, false},
+		{1, int64(1), true},
+		{"a", "b", false},
+		{true, false, false},
+		{[]int{1, 2}, []int{1, 2, 3}, false},
+	}
 
-	assert.Equal(false, EqualValue(1, "2"))
+	for _, tt := range tests {
+		assert.Equal(tt.want, EqualValue(tt.left, tt.right))
+	}
 }
 
 func TestLessThan(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestLessThan")
 
-	assert.Equal(true, LessThan(1, 2))
-	assert.Equal(true, LessThan(1.1, 2.2))
-	assert.Equal(true, LessThan("a", "b"))
+	tests := []struct {
+		left  any
+		right any
+		want  bool
+	}{
+		{1, 2, true},
+		{1.1, 2.2, true},
+		{"a", "b", true},
+		{time.Now(), time.Now().Add(time.Second), true},
+		{[]byte("hello1"), []byte("hello2"), true},
+		{json.Number("123"), json.Number("124"), true},
+		{645680099112988673, 645680099112988675, true},
+		{1, 1, false},
+		{1, int64(1), false},
+	}
 
-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	assert.Equal(true, LessThan(time1, time2))
-
-	assert.Equal(false, LessThan(1, 1))
-	assert.Equal(false, LessThan(1, int64(1)))
+	for _, tt := range tests {
+		assert.Equal(tt.want, LessThan(tt.left, tt.right))
+	}
 }
 
 func TestGreaterThan(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestGreaterThan")
 
-	assert.Equal(true, GreaterThan(2, 1))
-	assert.Equal(true, GreaterThan(2.2, 1.1))
-	assert.Equal(true, GreaterThan("b", "a"))
+	tests := []struct {
+		left  any
+		right any
+		want  bool
+	}{
+		{2, 1, true},
+		{2.2, 1.1, true},
+		{"b", "a", true},
+		{time.Now().Add(time.Second), time.Now(), true},
+		{[]byte("hello2"), []byte("hello1"), true},
+		{json.Number("124"), json.Number("123"), true},
+		{645680099112988675, 645680099112988673, true},
+		{1, 1, false},
+		{1, int64(1), false},
+	}
 
-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	assert.Equal(true, GreaterThan(time2, time1))
+	for _, tt := range tests {
+		assert.Equal(tt.want, GreaterThan(tt.left, tt.right))
+	}
 
-	assert.Equal(false, GreaterThan(1, 2))
-	assert.Equal(false, GreaterThan(int64(2), 1))
-	assert.Equal(false, GreaterThan("b", "c"))
 }
 
 func TestLessOrEqual(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestLessOrEqual")
 
-	assert.Equal(true, LessOrEqual(1, 2))
-	assert.Equal(true, LessOrEqual(1, 1))
-	assert.Equal(true, LessOrEqual(1.1, 2.2))
-	assert.Equal(true, LessOrEqual("a", "b"))
+	tests := []struct {
+		left  any
+		right any
+		want  bool
+	}{
+		{1, 2, true},
+		{1, 1, true},
+		{1.1, 2.2, true},
+		{"a", "b", true},
+		{time.Now(), time.Now().Add(time.Second), true},
+		{[]byte("hello1"), []byte("hello2"), true},
+		{json.Number("123"), json.Number("124"), true},
+		{645680099112988673, 645680099112988675, true},
+		{2, 1, false},
+		{1, int64(2), false},
+	}
 
-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	assert.Equal(true, LessOrEqual(time1, time2))
-
-	assert.Equal(false, LessOrEqual(2, 1))
-	assert.Equal(false, LessOrEqual(1, int64(2)))
+	for _, tt := range tests {
+		assert.Equal(tt.want, LessOrEqual(tt.left, tt.right))
+	}
 }
 
 func TestGreaterOrEqual(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestGreaterThan")
 
-	assert.Equal(true, GreaterOrEqual(2, 1))
-	assert.Equal(true, GreaterOrEqual(1, 1))
-	assert.Equal(true, GreaterOrEqual(2.2, 1.1))
-	assert.Equal(true, GreaterOrEqual("b", "b"))
+	tests := []struct {
+		left  any
+		right any
+		want  bool
+	}{
+		{2, 1, true},
+		{1, 1, true},
+		{2.2, 1.1, true},
+		{"b", "b", true},
+		{time.Now().Add(time.Second), time.Now(), true},
+		{[]byte("hello2"), []byte("hello1"), true},
+		{json.Number("124"), json.Number("123"), true},
+		{645680099112988675, 645680099112988673, true},
+		{1, 2, false},
+		{int64(2), 1, false},
+		{"b", "c", false},
+	}
 
-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	assert.Equal(true, GreaterOrEqual(time2, time1))
-
-	assert.Equal(false, GreaterOrEqual(1, 2))
-	assert.Equal(false, GreaterOrEqual(int64(2), 1))
-	assert.Equal(false, GreaterOrEqual("b", "c"))
+	for _, tt := range tests {
+		assert.Equal(tt.want, GreaterOrEqual(tt.left, tt.right))
+	}
 }
 
 func TestInDelta(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestInDelta")
 
-	assert.Equal(true, InDelta(1, 1, 0))
-	assert.Equal(false, InDelta(1, 2, 0))
+	tests := []struct {
+		left  float64
+		right float64
+		delta float64
+		want  bool
+	}{
+		{1, 1, 0, true},
+		{1, 2, 0, false},
+		{2.0 / 3.0, 0.66667, 0.001, true},
+		{2.0 / 3.0, 0.0, 0.001, false},
+		{float64(74.96) - float64(20.48), 54.48, 0, false},
+		{float64(74.96) - float64(20.48), 54.48, 1e-14, true},
+		{float64(float32(80.45)), float64(80.45), 0, false},
+		{float64(float32(80.45)), float64(80.45), 1e-5, true},
+	}
 
-	assert.Equal(true, InDelta(2.0/3.0, 0.66667, 0.001))
-	assert.Equal(false, InDelta(2.0/3.0, 0.0, 0.001))
-
-	assert.Equal(false, InDelta(float64(74.96)-float64(20.48), 54.48, 0))
-	assert.Equal(true, InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14))
-	assert.Equal(false, InDelta(float64(float32(80.45)), float64(80.45), 0))
-	assert.Equal(true, InDelta(float64(float32(80.45)), float64(80.45), 1e-5))
+	for _, tt := range tests {
+		assert.Equal(tt.want, InDelta(tt.left, tt.right, tt.delta))
+	}
 }

concurrency/channel.go

@@ -157,10 +157,10 @@ func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)
 // Play: https://go.dev/play/p/qmWSy1NVF-Y
 func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T {
 	valStream := make(chan T)
-
 	go func() {
 		defer close(valStream)
-
+		wg := sync.WaitGroup{}
+		defer wg.Wait()
 		for {
 			var stream <-chan T
 			select {
@@ -169,19 +169,22 @@ func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-c
 					return
 				}
 				stream = maybeStream
+				wg.Add(1)
 			case <-ctx.Done():
 				return
 			}
 
-			for val := range c.OrDone(ctx, stream) {
-				select {
-				case valStream <- val:
-				case <-ctx.Done():
+			go func() {
+				defer wg.Done()
+				for val := range c.OrDone(ctx, stream) {
+					select {
+					case valStream <- val:
+					case <-ctx.Done():
+					}
 				}
-			}
+			}()
 		}
 	}()
-
 	return valStream
 }
 

concurrency/channel_example_test.go

@@ -3,6 +3,7 @@ package concurrency
 import (
 	"context"
 	"fmt"
+	"log"
 	"time"
 )
 
@@ -168,7 +169,8 @@ func ExampleChannel_Tee() {
 func ExampleChannel_Bridge() {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-
+	m1 := make(map[int]int)
+	m2 := make(map[int]int)
 	c := NewChannel[int]()
 	genVals := func() <-chan <-chan int {
 		out := make(chan (<-chan int))
@@ -177,6 +179,7 @@ func ExampleChannel_Bridge() {
 			for i := 1; i <= 5; i++ {
 				stream := make(chan int, 1)
 				stream <- i
+				m1[i]++
 				close(stream)
 				out <- stream
 			}
@@ -185,12 +188,171 @@ func ExampleChannel_Bridge() {
 	}
 
 	for v := range c.Bridge(ctx, genVals()) {
-		fmt.Println(v)
+		m2[v]++
+	}
+	for k, v := range m1 {
+		fmt.Println(m2[k] == v)
 	}
 	// Output:
-	// 1
-	// 2
-	// 3
-	// 4
-	// 5
+	// true
+	// true
+	// true
+	// true
+	// true
+}
+
+func ExampleKeyedLocker_Do() {
+	locker := NewKeyedLocker[string](2 * time.Second)
+
+	task := func() {
+		fmt.Println("Executing task...")
+		time.Sleep(1 * time.Second)
+		fmt.Println("Task completed.")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	if err := locker.Do(ctx, "mykey", task); err != nil {
+		log.Fatalf("Error executing task: %v\n", err)
+	} else {
+		fmt.Println("Task successfully executed.")
+	}
+
+	ctx2, cancel2 := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel2()
+
+	if err := locker.Do(ctx2, "mykey", task); err != nil {
+		log.Fatalf("Error executing task: %v\n", err)
+	} else {
+		fmt.Println("Task successfully executed.")
+	}
+
+	// Output:
+	// Executing task...
+	// Task completed.
+	// Task successfully executed.
+	// Executing task...
+	// Task completed.
+	// Task successfully executed.
+}
+
+func ExampleRWKeyedLocker_Lock() {
+	locker := NewRWKeyedLocker[string](2 * time.Second)
+
+	// Simulate a key
+	key := "resource_key"
+
+	fn := func() {
+		fmt.Println("Starting write operation...")
+		// Simulate write operation, assuming it takes 2 seconds
+		time.Sleep(200 * time.Millisecond)
+		fmt.Println("Write operation completed!")
+	}
+
+	// Acquire the write lock and execute the operation
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+	defer cancel()
+
+	// Execute the lock operation with a 3-second timeout
+	err := locker.Lock(ctx, key, fn)
+	if err != nil {
+		return
+	}
+
+	//output:
+	//Starting write operation...
+	//Write operation completed!
+}
+
+func ExampleRWKeyedLocker_RLock() {
+	locker := NewRWKeyedLocker[string](2 * time.Second)
+
+	// Simulate a key
+	key := "resource_key"
+
+	fn := func() {
+		fmt.Println("Starting write operation...")
+		// Simulate write operation, assuming it takes 2 seconds
+		time.Sleep(200 * time.Millisecond)
+		fmt.Println("Write operation completed!")
+	}
+
+	// Acquire the write lock and execute the operation
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+	defer cancel()
+
+	// Execute the lock operation with a 3-second timeout
+	err := locker.RLock(ctx, key, fn)
+	if err != nil {
+		return
+	}
+
+	//output:
+	//Starting write operation...
+	//Write operation completed!
+}
+
+func ExampleTryKeyedLocker() {
+	locker := NewTryKeyedLocker[string]()
+
+	key := "resource_key"
+
+	if locker.TryLock(key) {
+		fmt.Println("Lock acquired")
+		time.Sleep(1 * time.Second)
+		// Unlock after work is done
+		locker.Unlock(key)
+		fmt.Println("Lock released")
+	} else {
+		fmt.Println("Lock failed")
+	}
+
+	//output:
+	//Lock acquired
+	//Lock released
+}
+
+func ExampleTryKeyedLocker_TryLock() {
+	locker := NewTryKeyedLocker[string]()
+
+	key := "resource_key"
+
+	done := make(chan struct{})
+	go func() {
+		if locker.TryLock(key) {
+			time.Sleep(2 * time.Second)
+			locker.Unlock(key)
+		}
+		close(done)
+	}()
+
+	time.Sleep(100 * time.Millisecond)
+
+	if locker.TryLock(key) {
+		fmt.Println("Lock acquired")
+		locker.Unlock(key)
+	} else {
+		fmt.Println("Lock failed")
+	}
+
+	// wait for the goroutine to finish
+	<-done
+
+	fmt.Println("Retrying...")
+	time.Sleep(100 * time.Millisecond)
+
+	if locker.TryLock(key) {
+		fmt.Println("Lock acquired")
+		locker.Unlock(key)
+		fmt.Println("Lock released")
+	} else {
+		fmt.Println("Lock failed")
+	}
+
+	// Output:
+	// Lock failed
+	// Retrying...
+	// Lock acquired
+	// Lock released
 }

concurrency/channel_test.go

@@ -169,7 +169,8 @@ func TestTee(t *testing.T) {
 func TestBridge(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestBridge")
-
+	m1 := make(map[int]int)
+	m2 := make(map[int]int)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
@@ -181,6 +182,7 @@ func TestBridge(t *testing.T) {
 			for i := 0; i < 10; i++ {
 				stream := make(chan int, 1)
 				stream <- i
+				m1[i]++
 				close(stream)
 				chanStream <- stream
 			}
@@ -188,9 +190,11 @@ func TestBridge(t *testing.T) {
 		return chanStream
 	}
 
-	index := 0
 	for val := range c.Bridge(ctx, genVals()) {
-		assert.Equal(index, val)
-		index++
+		m2[val]++
+	}
+
+	for k, v := range m1 {
+		assert.Equal(m2[k], v)
 	}
 }

concurrency/keyed_locker.go

@@ -0,0 +1,257 @@
+// Copyright 2025 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel, locker.
+package concurrency
+
+import (
+	"context"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// KeyedLocker is a simple implementation of a keyed locker that allows for non-blocking lock acquisition.
+type KeyedLocker[K comparable] struct {
+	locks sync.Map
+	ttl   time.Duration
+}
+
+type lockEntry struct {
+	mu    sync.Mutex
+	ref   int32
+	timer atomic.Pointer[time.Timer]
+}
+
+// NewKeyedLocker creates a new KeyedLocker with the specified TTL for lock expiration.
+// The TTL is used to automatically release locks that are no longer held.
+// Play: https://go.dev/play/p/GzeyC33T5rw
+func NewKeyedLocker[K comparable](ttl time.Duration) *KeyedLocker[K] {
+	return &KeyedLocker[K]{ttl: ttl}
+}
+
+// Do acquires a lock for the specified key and executes the provided function.
+// It returns an error if the context is canceled before the function completes.
+// Play: https://go.dev/play/p/GzeyC33T5rw
+func (l *KeyedLocker[K]) Do(ctx context.Context, key K, fn func()) error {
+	entry := l.acquire(key)
+	defer l.release(key, entry, key)
+
+	done := make(chan struct{})
+
+	go func() {
+		entry.mu.Lock()
+		defer entry.mu.Unlock()
+
+		select {
+		case <-ctx.Done():
+		default:
+			fn()
+		}
+		close(done)
+	}()
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-done:
+		return nil
+	}
+}
+
+// acquire tries to acquire a lock for the specified key.
+func (l *KeyedLocker[K]) acquire(key K) *lockEntry {
+	lock, _ := l.locks.LoadOrStore(key, &lockEntry{})
+	entry := lock.(*lockEntry)
+
+	atomic.AddInt32(&entry.ref, 1)
+	if t := entry.timer.Swap(nil); t != nil {
+		t.Stop()
+	}
+
+	return entry
+}
+
+// release releases the lock for the specified key.
+func (l *KeyedLocker[K]) release(key K, entry *lockEntry, rawKey K) {
+	if atomic.AddInt32(&entry.ref, -1) == 0 {
+		entry.mu.Lock()
+		defer entry.mu.Unlock()
+
+		if entry.ref == 0 {
+			if t := entry.timer.Swap(nil); t != nil {
+				t.Stop()
+			}
+
+			l.locks.Delete(rawKey)
+		} else {
+			if entry.timer.Load() == nil {
+				t := time.AfterFunc(l.ttl, func() {
+					l.release(key, entry, rawKey)
+				})
+				entry.timer.Store(t)
+			}
+		}
+	}
+}
+
+// RWKeyedLocker is a read-write version of KeyedLocker.
+type RWKeyedLocker[K comparable] struct {
+	locks sync.Map
+	ttl   time.Duration
+}
+
+type rwLockEntry struct {
+	mu    sync.RWMutex
+	ref   int32
+	timer atomic.Pointer[time.Timer]
+}
+
+// NewRWKeyedLocker creates a new RWKeyedLocker with the specified TTL for lock expiration.
+// The TTL is used to automatically release locks that are no longer held.
+// Play: https://go.dev/play/p/CkaJWWwZm9
+func NewRWKeyedLocker[K comparable](ttl time.Duration) *RWKeyedLocker[K] {
+	return &RWKeyedLocker[K]{ttl: ttl}
+}
+
+// RLock acquires a read lock for the specified key and executes the provided function.
+// It returns an error if the context is canceled before the function completes.
+// Play: https://go.dev/play/p/ZrCr8sMo77T
+func (l *RWKeyedLocker[K]) RLock(ctx context.Context, key K, fn func()) error {
+	entry := l.acquire(key)
+	defer l.release(entry, key)
+
+	done := make(chan struct{})
+
+	go func() {
+		entry.mu.RLock()
+		defer entry.mu.RUnlock()
+
+		select {
+		case <-ctx.Done():
+		default:
+			fn()
+		}
+		close(done)
+	}()
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-done:
+		return nil
+	}
+}
+
+// Lock acquires a write lock for the specified key and executes the provided function.
+// It returns an error if the context is canceled before the function completes.
+// Play: https://go.dev/play/p/WgAcXbOPKGk
+func (l *RWKeyedLocker[K]) Lock(ctx context.Context, key K, fn func()) error {
+	entry := l.acquire(key)
+	defer l.release(entry, key)
+
+	done := make(chan struct{})
+
+	go func() {
+		entry.mu.Lock()
+		defer entry.mu.Unlock()
+
+		select {
+		case <-ctx.Done():
+		default:
+			fn()
+		}
+		close(done)
+	}()
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-done:
+		return nil
+	}
+}
+
+// acquire tries to acquire a read lock for the specified key.
+func (l *RWKeyedLocker[K]) acquire(key K) *rwLockEntry {
+	actual, _ := l.locks.LoadOrStore(key, &rwLockEntry{})
+	entry := actual.(*rwLockEntry)
+	atomic.AddInt32(&entry.ref, 1)
+
+	if t := entry.timer.Swap(nil); t != nil {
+		t.Stop()
+	}
+	return entry
+}
+
+// release releases the lock for the specified key.
+func (l *RWKeyedLocker[K]) release(entry *rwLockEntry, rawKey K) {
+	if atomic.AddInt32(&entry.ref, -1) == 0 {
+		timer := time.AfterFunc(l.ttl, func() {
+			if atomic.LoadInt32(&entry.ref) == 0 {
+				l.locks.Delete(rawKey)
+			}
+		})
+		entry.timer.Store(timer)
+	}
+}
+
+// TryKeyedLocker is a non-blocking version of KeyedLocker.
+// It allows for trying to acquire a lock without blocking if the lock is already held.
+type TryKeyedLocker[K comparable] struct {
+	mu    sync.Mutex
+	locks map[K]*casMutex
+}
+
+// NewTryKeyedLocker creates a new TryKeyedLocker.
+// Play: https://go.dev/play/p/VG9qLvyetE2
+func NewTryKeyedLocker[K comparable]() *TryKeyedLocker[K] {
+	return &TryKeyedLocker[K]{locks: make(map[K]*casMutex)}
+}
+
+// TryLock tries to acquire a lock for the specified key.
+// It returns true if the lock was acquired, false otherwise.
+// Play: https://go.dev/play/p/VG9qLvyetE2
+func (l *TryKeyedLocker[K]) TryLock(key K) bool {
+	l.mu.Lock()
+
+	lock, ok := l.locks[key]
+	if !ok {
+		lock = &casMutex{}
+		l.locks[key] = lock
+	}
+	l.mu.Unlock()
+
+	return lock.TryLock()
+}
+
+// Unlock releases the lock for the specified key.
+// Play: https://go.dev/play/p/VG9qLvyetE2
+func (l *TryKeyedLocker[K]) Unlock(key K) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	lock, ok := l.locks[key]
+	if ok {
+		lock.Unlock()
+		if lock.lock == 0 {
+			delete(l.locks, key)
+		}
+	}
+}
+
+// casMutex is a simple mutex that uses atomic operations to provide a non-blocking lock.
+type casMutex struct {
+	lock int32
+}
+
+// TryLock tries to acquire the lock without blocking.
+// It returns true if the lock was acquired, false otherwise.
+func (m *casMutex) TryLock() bool {
+	return atomic.CompareAndSwapInt32(&m.lock, 0, 1)
+}
+
+// Unlock releases the lock.
+func (m *casMutex) Unlock() {
+	atomic.StoreInt32(&m.lock, 0)
+}

concurrency/keyed_locker_test.go

@@ -0,0 +1,230 @@
+package concurrency
+
+import (
+	"context"
+	"strconv"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestKeyedLocker_SerialExecutionSameKey(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestKeyedLocker_SerialExecutionSameKey")
+
+	locker := NewKeyedLocker[string](100 * time.Millisecond)
+
+	var result []int
+	var mu sync.Mutex
+
+	wg := sync.WaitGroup{}
+	for i := 0; i < 5; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			err := locker.Do(context.Background(), "key1", func() {
+				time.Sleep(10 * time.Millisecond)
+				mu.Lock()
+				defer mu.Unlock()
+				result = append(result, i)
+			})
+
+			assert.IsNil(err)
+		}(i)
+	}
+	wg.Wait()
+
+	assert.Equal(5, len(result))
+}
+
+func TestKeyedLocker_ParallelExecutionDifferentKeys(t *testing.T) {
+	locker := NewKeyedLocker[string](100 * time.Millisecond)
+
+	start := time.Now()
+	wg := sync.WaitGroup{}
+	for i := 0; i < 5; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			key := "key" + strconv.Itoa(i)
+			locker.Do(context.Background(), key, func() {
+				time.Sleep(50 * time.Millisecond)
+			})
+		}(i)
+	}
+	wg.Wait()
+	elapsed := time.Since(start)
+
+	if elapsed > 100*time.Millisecond {
+		t.Errorf("parallel execution took too long: %s", elapsed)
+	}
+}
+
+func TestKeyedLocker_ContextTimeout(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestKeyedLocker_ContextTimeout")
+
+	locker := NewKeyedLocker[string](100 * time.Millisecond)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
+	defer cancel()
+
+	// Lock key before calling
+	go func() {
+		_ = locker.Do(context.Background(), "key-timeout", func() {
+			time.Sleep(50 * time.Millisecond)
+		})
+	}()
+
+	time.Sleep(1 * time.Millisecond) // ensure lock is acquired first
+
+	err := locker.Do(ctx, "key-timeout", func() {
+		t.Error("should not execute")
+	})
+
+	assert.IsNotNil(err)
+}
+
+func TestKeyedLocker_LockReleaseAfterTTL(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestKeyedLocker_LockReleaseAfterTTL")
+
+	locker := NewKeyedLocker[string](50 * time.Millisecond)
+
+	err := locker.Do(context.Background(), "ttl-key", func() {})
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	// Wait for TTL to pass
+	time.Sleep(100 * time.Millisecond)
+
+	err = locker.Do(context.Background(), "ttl-key", func() {})
+	assert.IsNil(err)
+}
+
+func TestRWKeyedLocker_LockAndUnlock(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestKeyedLocker_LockReleaseAfterTTL")
+
+	locker := NewRWKeyedLocker[string](500 * time.Millisecond)
+
+	var locked bool
+	err := locker.Lock(context.Background(), "key1", func() {
+		locked = true
+	})
+
+	assert.IsNil(err)
+	assert.Equal(true, locked)
+}
+
+func TestRWKeyedLocker_RLockParallel(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestKeyedLocker_LockReleaseAfterTTL")
+
+	locker := NewRWKeyedLocker[string](1 * time.Second)
+
+	var mu sync.Mutex
+	var count int
+	wg := sync.WaitGroup{}
+
+	for i := 0; i < 5; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			err := locker.RLock(context.Background(), "shared-key", func() {
+				time.Sleep(10 * time.Millisecond)
+				mu.Lock()
+				count++
+				mu.Unlock()
+			})
+
+			assert.IsNil(err)
+		}()
+	}
+
+	wg.Wait()
+
+	assert.Equal(5, count)
+}
+
+func TestRWKeyedLocker_LockTimeout(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestRWKeyedLocker_LockTimeout")
+
+	locker := NewRWKeyedLocker[string](1 * time.Second)
+
+	start := make(chan struct{})
+
+	go func() {
+		locker.Lock(context.Background(), "key-timeout", func() {
+			close(start)
+			time.Sleep(200 * time.Millisecond)
+		})
+	}()
+
+	<-start
+	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+	defer cancel()
+
+	err := locker.Lock(ctx, "key-timeout", func() {
+		t.Error("should not reach here")
+	})
+
+	assert.IsNotNil(err)
+}
+
+func TestTryKeyedLocker_SimpleLockUnlock(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestTryKeyedLocker_SimpleLockUnlock")
+
+	locker := NewTryKeyedLocker[string]()
+
+	ok := locker.TryLock("key1")
+	assert.Equal(true, ok)
+
+	ok = locker.TryLock("key1")
+	assert.Equal(false, ok)
+
+	locker.Unlock("key1")
+
+	ok = locker.TryLock("key1")
+	assert.Equal(true, ok)
+
+	locker.Unlock("key1")
+}
+
+func TestTryKeyedLocker_ParallelTry(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestTryKeyedLocker_ParallelTry")
+
+	locker := NewTryKeyedLocker[string]()
+
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	var count int
+
+	for i := 0; i < 5; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			ok := locker.TryLock("key" + strconv.Itoa(i))
+			mu.Lock()
+			if ok {
+				count++
+			}
+			mu.Unlock()
+			time.Sleep(10 * time.Millisecond)
+			if ok {
+				locker.Unlock("key" + strconv.Itoa(i))
+			}
+		}(i)
+	}
+
+	wg.Wait()
+
+	assert.Equal(5, count)
+	assert.Equal(0, len(locker.locks))
+}

condition/condition.go

@@ -49,9 +49,7 @@ func Or[T, U any](a T, b U) bool {
 // Xor returns true if a or b but not both is truthy.
 // Play: https://go.dev/play/p/gObZrW7ZbG8
 func Xor[T, U any](a T, b U) bool {
-	valA := Bool(a)
-	valB := Bool(b)
-	return (valA || valB) && valA != valB
+	return Bool(a) != Bool(b)
 }
 
 // Nor returns true if neither a nor b is truthy.
@@ -63,9 +61,7 @@ func Nor[T, U any](a T, b U) bool {
 // Xnor returns true if both a and b or neither a nor b are truthy.
 // Play: https://go.dev/play/p/OuDB9g51643
 func Xnor[T, U any](a T, b U) bool {
-	valA := Bool(a)
-	valB := Bool(b)
-	return (valA && valB) || (!valA && !valB)
+	return Bool(a) == Bool(b)
 }
 
 // Nand returns false if both a and b are truthy.
@@ -76,10 +72,17 @@ func Nand[T, U any](a T, b U) bool {
 
 // TernaryOperator checks the value of param `isTrue`, if true return ifValue else return elseValue.
 // Play: https://go.dev/play/p/ElllPZY0guT
-func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U {
+func Ternary[T, U any](isTrue T, ifValue U, elseValue U) U {
 	if Bool(isTrue) {
 		return ifValue
 	} else {
 		return elseValue
 	}
 }
+
+// TernaryOperator checks the value of param `isTrue`, if true return ifValue else return elseValue.
+// Play: https://go.dev/play/p/ElllPZY0guT
+// Deprecated: Use Ternary instead.
+func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U {
+	return Ternary(isTrue, ifValue, elseValue)
+}

condition/condition_example_test.go

@@ -148,13 +148,13 @@ func ExampleNand() {
 	// false
 }
 
-func ExampleTernaryOperator() {
+func ExampleTernary() {
 	conditionTrue := 2 > 1
-	result1 := TernaryOperator(conditionTrue, 0, 1)
+	result1 := Ternary(conditionTrue, 0, 1)
 	fmt.Println(result1)
 
 	conditionFalse := 2 > 3
-	result2 := TernaryOperator(conditionFalse, 0, 1)
+	result2 := Ternary(conditionFalse, 0, 1)
 	fmt.Println(result2)
 
 	// Output:

condition/condition_test.go

@@ -124,13 +124,13 @@ func TestNand(t *testing.T) {
 	assert.Equal(false, Nand(1, 1))
 }
 
-func TestTernaryOperator(t *testing.T) {
+func TestTernary(t *testing.T) {
 	t.Parallel()
 
-	assert := internal.NewAssert(t, "TernaryOperator")
+	assert := internal.NewAssert(t, "TestTernary")
 
 	trueValue := "1"
 	falseValue := "0"
 
-	assert.Equal(trueValue, TernaryOperator(true, trueValue, falseValue))
+	assert.Equal(trueValue, Ternary(true, trueValue, falseValue))
 }

constraints/constraints.go

@@ -1,8 +1,8 @@
 // Copyright 2021 dudaodong@gmail.com. All rights reserved.
 // Use of this source code is governed by MIT license
 
-// Package lancetconstraints contain some comstomer constraints.
-package lancetconstraints
+// Package constraints contain some custom interface.
+package constraints
 
 // Comparator is for comparing two values
 type Comparator interface {

convertor/convertor.go

@@ -6,6 +6,7 @@ package convertor
 
 import (
 	"bytes"
+	"encoding/base64"
 	"encoding/binary"
 	"encoding/gob"
 	"encoding/json"
@@ -13,6 +14,7 @@ import (
 	"fmt"
 	"io"
 	"math"
+	"math/big"
 	"reflect"
 	"strconv"
 	"strings"
@@ -73,7 +75,7 @@ func ToBytes(value any) ([]byte, error) {
 // ToChar convert string to char slice.
 // Play: https://go.dev/play/p/JJ1SvbFkVdM
 func ToChar(s string) []string {
-	c := make([]string, 0)
+	c := make([]string, 0, len(s))
 	if len(s) == 0 {
 		c = append(c, "")
 	}
@@ -106,6 +108,13 @@ func ToString(value any) string {
 	if value == nil {
 		return ""
 	}
+	rv := reflect.ValueOf(value)
+	if rv.Kind() == reflect.Ptr {
+		if rv.IsNil() {
+			return ""
+		}
+		return ToString(rv.Elem().Interface())
+	}
 
 	switch val := value.(type) {
 	case float32:
@@ -141,12 +150,8 @@ func ToString(value any) string {
 		if err != nil {
 			return ""
 		}
-		return string(b)
 
-		// todo: maybe we should't supprt other type conversion
-		// v := reflect.ValueOf(value)
-		// log.Panicf("Unsupported data type: %s ", v.String())
-		// return ""
+		return string(b)
 	}
 }
 
@@ -223,6 +228,42 @@ func ToPointer[T any](value T) *T {
 	return &value
 }
 
+// ToPointers convert a slice of values to a slice of pointers.
+// Play: https://go.dev/play/p/ZUoXd2i5ZkV
+func ToPointers[T any](values []T) []*T {
+	result := make([]*T, len(values))
+	for i := range values {
+		result[i] = &values[i]
+	}
+	return result
+}
+
+// FromPointer returns the value pointed to by the pointer.
+// Play: https://go.dev/play/p/wAp90V7Zu6g
+func FromPointer[T any](ptr *T) T {
+	if ptr == nil {
+		var zeroValue T
+		return zeroValue
+	}
+
+	return *ptr
+}
+
+// FromPointers convert a slice of pointers to a slice of values.
+// Play: https://go.dev/play/p/qIPsyYtNy3Q
+func FromPointers[T any](pointers []*T) []T {
+	result := make([]T, len(pointers))
+	for i, ptr := range pointers {
+		if ptr == nil {
+			var zeroValue T
+			result[i] = zeroValue
+		} else {
+			result[i] = *ptr
+		}
+	}
+	return result
+}
+
 // ToMap convert a slice of structs to a map based on iteratee function.
 // Play: https://go.dev/play/p/tVFy7E-t24l
 func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V {
@@ -394,3 +435,124 @@ func GbkToUtf8(bs []byte) ([]byte, error) {
 	b, err := io.ReadAll(r)
 	return b, err
 }
+
+// ToStdBase64 convert data to standard base64 encoding.
+// Play: https://go.dev/play/p/_fLJqJD3NMo
+func ToStdBase64(value any) string {
+	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
+		return ""
+	}
+	switch v := value.(type) {
+	case []byte:
+		return base64.StdEncoding.EncodeToString(v)
+	case string:
+		return base64.StdEncoding.EncodeToString([]byte(v))
+	case error:
+		return base64.StdEncoding.EncodeToString([]byte(v.Error()))
+	default:
+		marshal, err := json.Marshal(v)
+		if err != nil {
+			return ""
+		}
+		return base64.StdEncoding.EncodeToString(marshal)
+	}
+}
+
+// ToUrlBase64 convert data to URL base64 encoding.
+// Play: https://go.dev/play/p/C_d0GlvEeUR
+func ToUrlBase64(value any) string {
+	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
+		return ""
+	}
+	switch v := value.(type) {
+	case []byte:
+		return base64.URLEncoding.EncodeToString(v)
+	case string:
+		return base64.URLEncoding.EncodeToString([]byte(v))
+	case error:
+		return base64.URLEncoding.EncodeToString([]byte(v.Error()))
+	default:
+		marshal, err := json.Marshal(v)
+		if err != nil {
+			return ""
+		}
+		return base64.URLEncoding.EncodeToString(marshal)
+	}
+}
+
+// ToRawStdBase64 convert data to raw standard base64 encoding.
+// Play: https://go.dev/play/p/wSAr3sfkDcv
+func ToRawStdBase64(value any) string {
+	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
+		return ""
+	}
+	switch v := value.(type) {
+	case []byte:
+		return base64.RawStdEncoding.EncodeToString(value.([]byte))
+	case string:
+		return base64.RawStdEncoding.EncodeToString([]byte(value.(string)))
+	case error:
+		return base64.RawStdEncoding.EncodeToString([]byte(value.(error).Error()))
+	default:
+		marshal, err := json.Marshal(v)
+		if err != nil {
+			return ""
+		}
+		return base64.RawStdEncoding.EncodeToString(marshal)
+	}
+}
+
+// ToRawUrlBase64 convert data to raw URL base64 encoding.
+// Play: https://go.dev/play/p/HwdDPFcza1O
+func ToRawUrlBase64(value any) string {
+	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
+		return ""
+	}
+	switch v := value.(type) {
+	case []byte:
+		return base64.RawURLEncoding.EncodeToString(value.([]byte))
+	case string:
+		return base64.RawURLEncoding.EncodeToString([]byte(value.(string)))
+	case error:
+		return base64.RawURLEncoding.EncodeToString([]byte(value.(error).Error()))
+	default:
+		marshal, err := json.Marshal(v)
+		if err != nil {
+			return ""
+		}
+		return base64.RawURLEncoding.EncodeToString(marshal)
+	}
+}
+
+// ToBigInt converts an integer of any supported type (int, int64, uint64, etc.) to *big.Int
+// Play: https://go.dev/play/p/X3itkCxwB_x
+func ToBigInt[T any](v T) (*big.Int, error) {
+	result := new(big.Int)
+
+	switch v := any(v).(type) {
+	case int:
+		result.SetInt64(int64(v)) // Convert to int64 for big.Int
+	case int8:
+		result.SetInt64(int64(v))
+	case int16:
+		result.SetInt64(int64(v))
+	case int32:
+		result.SetInt64(int64(v))
+	case int64:
+		result.SetInt64(v)
+	case uint:
+		result.SetUint64(uint64(v)) // Convert to uint64 for big.Int
+	case uint8:
+		result.SetUint64(uint64(v))
+	case uint16:
+		result.SetUint64(uint64(v))
+	case uint32:
+		result.SetUint64(uint64(v))
+	case uint64:
+		result.SetUint64(v)
+	default:
+		return nil, fmt.Errorf("unsupported type: %T", v)
+	}
+
+	return result, nil
+}

convertor/convertor_example_test.go

@@ -1,6 +1,7 @@
 package convertor
 
 import (
+	"errors"
 	"fmt"
 	"reflect"
 	"strconv"
@@ -168,6 +169,45 @@ func ExampleToPointer() {
 	// 123
 }
 
+func ExampleToPointers() {
+	strs := []string{"a", "b", "c"}
+	pointerStrs := ToPointers(strs)
+	fmt.Println(*pointerStrs[0])
+	fmt.Println(*pointerStrs[1])
+	fmt.Println(*pointerStrs[2])
+
+	// Output:
+	// a
+	// b
+	// c
+}
+
+func ExampleFromPointer() {
+	str := "abc"
+	strPtr := &str
+	result := FromPointer(strPtr)
+	fmt.Println(result)
+
+	// Output:
+	// abc
+}
+
+func ExampleFromPointers() {
+	strs := []string{"a", "b", "c"}
+	strPtr := []*string{&strs[0], &strs[1], &strs[2]}
+
+	result := FromPointers(strPtr)
+
+	fmt.Println(result[0])
+	fmt.Println(result[1])
+	fmt.Println(result[2])
+
+	// Output:
+	// a
+	// b
+	// c
+}
+
 func ExampleToMap() {
 	type Message struct {
 		name string
@@ -391,3 +431,191 @@ func ExampleGbkToUtf8() {
 	// true
 	// hello
 }
+
+func ExampleToStdBase64() {
+	// if you want to see the result, please use 'base64.StdEncoding.DecodeString()' to decode the result
+
+	afterEncode := ToStdBase64(nil)
+	fmt.Println(afterEncode)
+
+	stringVal := "hello"
+	afterEncode = ToStdBase64(stringVal)
+	fmt.Println(afterEncode)
+
+	byteSliceVal := []byte("hello")
+	afterEncode = ToStdBase64(byteSliceVal)
+	fmt.Println(afterEncode)
+
+	intVal := 123
+	afterEncode = ToStdBase64(intVal)
+	fmt.Println(afterEncode)
+
+	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+		A string
+		B int
+	}{"hello", 3}}
+	afterEncode = ToStdBase64(mapVal)
+	fmt.Println(afterEncode)
+
+	floatVal := 123.456
+	afterEncode = ToStdBase64(floatVal)
+	fmt.Println(afterEncode)
+
+	boolVal := true
+	afterEncode = ToStdBase64(boolVal)
+	fmt.Println(afterEncode)
+
+	errVal := errors.New("err")
+	afterEncode = ToStdBase64(errVal)
+	fmt.Println(afterEncode)
+
+	// Output:
+	//
+	// aGVsbG8=
+	// aGVsbG8=
+	// MTIz
+	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
+	// MTIzLjQ1Ng==
+	// dHJ1ZQ==
+	// ZXJy
+}
+
+func ExampleToUrlBase64() {
+	// if you want to see the result, please use 'base64.URLEncoding.DecodeString()' to decode the result
+
+	stringVal := "hello"
+	afterEncode := ToUrlBase64(stringVal)
+	fmt.Println(afterEncode)
+
+	byteSliceVal := []byte("hello")
+	afterEncode = ToUrlBase64(byteSliceVal)
+	fmt.Println(afterEncode)
+
+	intVal := 123
+	afterEncode = ToUrlBase64(intVal)
+	fmt.Println(afterEncode)
+
+	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+		A string
+		B int
+	}{"hello", 3}}
+	afterEncode = ToUrlBase64(mapVal)
+	fmt.Println(afterEncode)
+
+	floatVal := 123.456
+	afterEncode = ToUrlBase64(floatVal)
+	fmt.Println(afterEncode)
+
+	boolVal := true
+	afterEncode = ToUrlBase64(boolVal)
+	fmt.Println(afterEncode)
+
+	errVal := errors.New("err")
+	afterEncode = ToUrlBase64(errVal)
+	fmt.Println(afterEncode)
+
+	// Output:
+	// aGVsbG8=
+	// aGVsbG8=
+	// MTIz
+	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
+	// MTIzLjQ1Ng==
+	// dHJ1ZQ==
+	// ZXJy
+}
+
+func ExampleToRawStdBase64() {
+	// if you want to see the result, please use 'base64.RawStdEncoding.DecodeString()' to decode the result
+	stringVal := "hello"
+	afterEncode := ToRawStdBase64(stringVal)
+	fmt.Println(afterEncode)
+
+	byteSliceVal := []byte("hello")
+	afterEncode = ToRawStdBase64(byteSliceVal)
+	fmt.Println(afterEncode)
+
+	intVal := 123
+	afterEncode = ToRawStdBase64(intVal)
+	fmt.Println(afterEncode)
+
+	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+		A string
+		B int
+	}{"hello", 3}}
+	afterEncode = ToRawStdBase64(mapVal)
+	fmt.Println(afterEncode)
+
+	floatVal := 123.456
+	afterEncode = ToRawStdBase64(floatVal)
+	fmt.Println(afterEncode)
+
+	boolVal := true
+	afterEncode = ToRawStdBase64(boolVal)
+	fmt.Println(afterEncode)
+
+	errVal := errors.New("err")
+	afterEncode = ToRawStdBase64(errVal)
+	fmt.Println(afterEncode)
+
+	// Output:
+	// aGVsbG8
+	// aGVsbG8
+	// MTIz
+	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
+	// MTIzLjQ1Ng
+	// dHJ1ZQ
+	// ZXJy
+}
+
+func ExampleToRawUrlBase64() {
+	// if you want to see the result, please use 'base64.RawURLEncoding.DecodeString()' to decode the result
+
+	stringVal := "hello"
+	afterEncode := ToRawUrlBase64(stringVal)
+	fmt.Println(afterEncode)
+
+	byteSliceVal := []byte("hello")
+	afterEncode = ToRawUrlBase64(byteSliceVal)
+	fmt.Println(afterEncode)
+
+	intVal := 123
+	afterEncode = ToRawUrlBase64(intVal)
+	fmt.Println(afterEncode)
+
+	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+		A string
+		B int
+	}{"hello", 3}}
+	afterEncode = ToRawUrlBase64(mapVal)
+	fmt.Println(afterEncode)
+
+	floatVal := 123.456
+	afterEncode = ToRawUrlBase64(floatVal)
+	fmt.Println(afterEncode)
+
+	boolVal := true
+	afterEncode = ToRawUrlBase64(boolVal)
+	fmt.Println(afterEncode)
+
+	errVal := errors.New("err")
+	afterEncode = ToRawUrlBase64(errVal)
+	fmt.Println(afterEncode)
+
+	// Output:
+	// aGVsbG8
+	// aGVsbG8
+	// MTIz
+	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
+	// MTIzLjQ1Ng
+	// dHJ1ZQ
+	// ZXJy
+}
+
+func ExampleToBigInt() {
+	n := 9876543210
+	bigInt, _ := ToBigInt(n)
+
+	fmt.Println(bigInt)
+	// Output:
+	// 9876543210
+}

convertor/convertor_internal.go

@@ -99,7 +99,7 @@ func (c *cloner) cloneArray(v reflect.Value) reflect.Value {
 	for i := 0; i < v.Len(); i++ {
 		val := c.clone(v.Index(i))
 
-		if val.IsValid() {
+		if !val.IsValid() {
 			continue
 		}
 

convertor/convertor_test.go

@@ -1,11 +1,16 @@
 package convertor
 
 import (
+	"encoding/base64"
+	"errors"
 	"fmt"
+	"io"
+	"math/big"
 	"reflect"
 	"strconv"
 	"testing"
 	"unicode/utf8"
+	"unsafe"
 
 	"github.com/duke-git/lancet/v2/internal"
 	"github.com/duke-git/lancet/v2/slice"
@@ -137,13 +142,24 @@ func TestToString(t *testing.T) {
 	}
 	aStruct := TestStruct{Name: "TestStruct"}
 
+	i32Val := int32(123)
+	i64Val := int64(123)
+	iZeroVal := 0
+	fVal := 12.3
+	sVal := "abc"
+	var iNilPointer *int
+	var sNilPointer *string
+
 	cases := []any{
 		"", nil,
 		int(0), int8(1), int16(-1), int32(123), int64(123),
 		uint(123), uint8(123), uint16(123), uint32(123), uint64(123),
 		float64(12.3), float32(12.3),
 		true, false,
-		[]int{1, 2, 3}, aMap, aStruct, []byte{104, 101, 108, 108, 111}}
+		[]int{1, 2, 3}, aMap, aStruct, []byte{104, 101, 108, 108, 111},
+		&i32Val, &i64Val, &fVal, &sVal, &aStruct, iNilPointer, sNilPointer,
+		&iZeroVal,
+	}
 
 	expected := []string{
 		"", "",
@@ -152,6 +168,8 @@ func TestToString(t *testing.T) {
 		"12.3", "12.3",
 		"true", "false",
 		"[1,2,3]", "{\"a\":1,\"b\":2,\"c\":3}", "{\"Name\":\"TestStruct\"}", "hello",
+		"123", "123", "12.3", "abc", "{\"Name\":\"TestStruct\"}", "", "",
+		"0",
 	}
 
 	for i := 0; i < len(cases); i++ {
@@ -284,6 +302,75 @@ func TestToPointer(t *testing.T) {
 	assert.Equal(*result, 123)
 }
 
+func TestToPointers(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestToPointers")
+
+	intVals := []int{1, 2, 3}
+	result := ToPointers(intVals)
+
+	assert.Equal(3, len(result))
+	assert.Equal(1, *result[0])
+	assert.Equal(2, *result[1])
+	assert.Equal(3, *result[2])
+
+	stringVals := []string{"a", "b", "c"}
+	resultStr := ToPointers(stringVals)
+	assert.Equal(3, len(resultStr))
+	assert.Equal("a", *resultStr[0])
+	assert.Equal("b", *resultStr[1])
+	assert.Equal("c", *resultStr[2])
+}
+
+func TestFromPointer(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestFromPointer")
+
+	intVal := 123
+	pointer := &intVal
+	result := FromPointer(pointer)
+
+	assert.Equal(123, result)
+
+	stringVal := "abc"
+	stringPointer := &stringVal
+	resultStr := FromPointer(stringPointer)
+
+	assert.Equal("abc", resultStr)
+}
+
+func TestFromPointers(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestFromPointers")
+
+	intPointers := []*int{new(int), new(int), new(int)}
+	*intPointers[0] = 1
+	*intPointers[1] = 2
+	*intPointers[2] = 3
+
+	result := FromPointers(intPointers)
+
+	assert.Equal(3, len(result))
+	assert.Equal(1, result[0])
+	assert.Equal(2, result[1])
+	assert.Equal(3, result[2])
+
+	stringPointers := []*string{new(string), new(string), new(string)}
+	*stringPointers[0] = "a"
+	*stringPointers[1] = "b"
+	*stringPointers[2] = "c"
+
+	resultStr := FromPointers(stringPointers)
+
+	assert.Equal(3, len(resultStr))
+	assert.Equal("a", resultStr[0])
+	assert.Equal("b", resultStr[1])
+	assert.Equal("c", resultStr[2])
+}
+
 func TestEncodeByte(t *testing.T) {
 	t.Parallel()
 
@@ -337,6 +424,7 @@ func TestDeepClone(t *testing.T) {
 			Nil:   nil,
 			// unexported: "can't be cloned",
 		},
+		[]interface{}{1, &Struct{Str: "test"}, Struct{Str: "test2"}},
 	}
 
 	for i, item := range cases {
@@ -460,3 +548,359 @@ func TestGbkToUtf8(t *testing.T) {
 	assert.Equal(true, utf8.Valid(utf8Data))
 	assert.Equal("hello", string(utf8Data))
 }
+
+func TestToStdBase64(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestToStdBase64")
+
+	r1 := ToStdBase64("abc")
+	d1, _ := base64.StdEncoding.DecodeString(r1)
+	assert.Equal("abc", string(d1))
+
+	r2 := ToStdBase64([]byte("abc"))
+	d2, _ := base64.StdEncoding.DecodeString(r2)
+	assert.Equal("abc", string(d2))
+
+	r3 := ToStdBase64(123)
+	d3, _ := base64.StdEncoding.DecodeString(r3)
+	assert.Equal("123", string(d3))
+
+	r4 := ToStdBase64(11.11)
+	d4, _ := base64.StdEncoding.DecodeString(r4)
+	assert.Equal("11.11", string(d4))
+
+	r5 := ToStdBase64(map[string]any{"name": "duke", "quantity": 1})
+	d5, _ := base64.StdEncoding.DecodeString(r5)
+	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
+
+	r6 := ToStdBase64([]int64{7, 5, 9, 4, 23})
+	d6, _ := base64.StdEncoding.DecodeString(r6)
+	assert.Equal("[7,5,9,4,23]", string(d6))
+
+	r7 := ToStdBase64([]string{"7", "5", "9", "4", "23"})
+	d7, _ := base64.StdEncoding.DecodeString(r7)
+	assert.Equal("[\"7\",\"5\",\"9\",\"4\",\"23\"]", string(d7))
+
+	r8 := ToStdBase64(nil)
+	d8, _ := base64.StdEncoding.DecodeString(r8)
+	assert.Equal("", string(d8))
+
+	ch := make(chan int, 3)
+	ch <- 1
+	ch <- 2
+	r9 := ToStdBase64(ch)
+	d9, _ := base64.StdEncoding.DecodeString(r9)
+	assert.Equal("", string(d9))
+
+	r10 := ToStdBase64(io.EOF)
+	d10, _ := base64.StdEncoding.DecodeString(r10)
+	assert.Equal("EOF", string(d10))
+
+	r11 := ToStdBase64(errors.New("test"))
+	d11, _ := base64.StdEncoding.DecodeString(r11)
+	assert.Equal("test", string(d11))
+
+	typedNil := (*int)(nil)
+	r12 := ToStdBase64(typedNil)
+	d12, _ := base64.StdEncoding.DecodeString(r12)
+	assert.Equal("", string(d12))
+
+	type nilInterface interface {
+	}
+	var nI nilInterface = nil
+	d13, _ := base64.StdEncoding.DecodeString(ToStdBase64(nI))
+	assert.Equal("", string(d13))
+
+	var p unsafe.Pointer
+	d14, _ := base64.StdEncoding.DecodeString(ToStdBase64(p))
+	assert.Equal("", string(d14))
+}
+
+func TestToUrlBase64(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestToUrlBase64")
+
+	r1 := ToUrlBase64("abc")
+	d1, _ := base64.URLEncoding.DecodeString(r1)
+	assert.Equal("abc", string(d1))
+
+	r2 := ToUrlBase64([]byte("abc"))
+	d2, _ := base64.URLEncoding.DecodeString(r2)
+	assert.Equal("abc", string(d2))
+
+	r3 := ToUrlBase64(123)
+	d3, _ := base64.URLEncoding.DecodeString(r3)
+	assert.Equal("123", string(d3))
+
+	r4 := ToUrlBase64(11.11)
+	d4, _ := base64.URLEncoding.DecodeString(r4)
+	assert.Equal("11.11", string(d4))
+
+	r5 := ToUrlBase64(map[string]any{"name": "duke", "quantity": 1})
+	d5, _ := base64.URLEncoding.DecodeString(r5)
+	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
+
+	r6 := ToUrlBase64([]int64{7, 5, 9, 4, 23})
+	d6, _ := base64.URLEncoding.DecodeString(r6)
+	assert.Equal("[7,5,9,4,23]", string(d6))
+
+	r7 := ToUrlBase64([]string{"7", "5", "9", "4", "23"})
+	d7, _ := base64.URLEncoding.DecodeString(r7)
+	assert.Equal("[\"7\",\"5\",\"9\",\"4\",\"23\"]", string(d7))
+
+	r8 := ToUrlBase64(nil)
+	d8, _ := base64.URLEncoding.DecodeString(r8)
+	assert.Equal("", string(d8))
+
+	ch := make(chan int, 3)
+	ch <- 1
+	ch <- 2
+	r9 := ToUrlBase64(ch)
+	d9, _ := base64.URLEncoding.DecodeString(r9)
+	assert.Equal("", string(d9))
+
+	r10 := ToUrlBase64(io.EOF)
+	d10, _ := base64.URLEncoding.DecodeString(r10)
+	assert.Equal("EOF", string(d10))
+
+	r11 := ToUrlBase64(errors.New("test"))
+	d11, _ := base64.URLEncoding.DecodeString(r11)
+	assert.Equal("test", string(d11))
+
+	typedNil := (*int)(nil)
+	r12 := ToUrlBase64(typedNil)
+	d12, _ := base64.URLEncoding.DecodeString(r12)
+	assert.Equal("", string(d12))
+
+	type nilInterface interface {
+	}
+	var nI nilInterface = nil
+	d13, _ := base64.URLEncoding.DecodeString(ToUrlBase64(nI))
+	assert.Equal("", string(d13))
+
+	var p unsafe.Pointer
+	d14, _ := base64.URLEncoding.DecodeString(ToUrlBase64(p))
+	assert.Equal("", string(d14))
+
+	r15 := ToUrlBase64("4+3/4?=")
+	d15, _ := base64.URLEncoding.DecodeString(r15)
+	assert.Equal("4+3/4?=", string(d15))
+}
+
+func TestToRawStdBase64(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestToRawStdBase64")
+
+	r1 := ToRawStdBase64("abc")
+	d1, _ := base64.RawStdEncoding.DecodeString(r1)
+	assert.Equal("abc", string(d1))
+
+	r2 := ToRawStdBase64([]byte("abc"))
+	d2, _ := base64.RawStdEncoding.DecodeString(r2)
+	assert.Equal("abc", string(d2))
+
+	r3 := ToRawStdBase64(123)
+	d3, _ := base64.RawStdEncoding.DecodeString(r3)
+	assert.Equal("123", string(d3))
+
+	r4 := ToRawStdBase64(11.11)
+	d4, _ := base64.RawStdEncoding.DecodeString(r4)
+	assert.Equal("11.11", string(d4))
+
+	r5 := ToRawStdBase64(map[string]any{"name": "duke", "quantity": 1})
+	d5, _ := base64.RawStdEncoding.DecodeString(r5)
+	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
+
+	r6 := ToRawStdBase64([]int64{7, 5, 9, 4, 23})
+	d6, _ := base64.RawStdEncoding.DecodeString(r6)
+	assert.Equal("[7,5,9,4,23]", string(d6))
+
+	r7 := ToRawStdBase64([]string{"7", "5", "9", "4", "23"})
+	d7, _ := base64.RawStdEncoding.DecodeString(r7)
+	assert.Equal("[\"7\",\"5\",\"9\",\"4\",\"23\"]", string(d7))
+
+	r8 := ToRawStdBase64(nil)
+	d8, _ := base64.RawStdEncoding.DecodeString(r8)
+	assert.Equal("", string(d8))
+
+	ch := make(chan int, 3)
+	ch <- 1
+	ch <- 2
+	r9 := ToRawStdBase64(ch)
+	d9, _ := base64.RawStdEncoding.DecodeString(r9)
+	assert.Equal("", string(d9))
+
+	r10 := ToRawStdBase64(io.EOF)
+	d10, _ := base64.RawStdEncoding.DecodeString(r10)
+	assert.Equal("EOF", string(d10))
+
+	r11 := ToRawStdBase64(errors.New("test"))
+	d11, _ := base64.RawStdEncoding.DecodeString(r11)
+	assert.Equal("test", string(d11))
+
+	typedNil := (*int)(nil)
+	r12 := ToRawStdBase64(typedNil)
+	d12, _ := base64.RawStdEncoding.DecodeString(r12)
+	assert.Equal("", string(d12))
+
+	type nilInterface interface {
+	}
+	var nI nilInterface = nil
+	d13, _ := base64.RawStdEncoding.DecodeString(ToRawStdBase64(nI))
+	assert.Equal("", string(d13))
+
+	var p unsafe.Pointer
+	d14, _ := base64.RawStdEncoding.DecodeString(ToRawStdBase64(p))
+	assert.Equal("", string(d14))
+}
+
+func TestToRawUrlBase64(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestToRawUrlBase64")
+
+	r1 := ToRawUrlBase64("abc")
+	d1, _ := base64.RawURLEncoding.DecodeString(r1)
+	assert.Equal("abc", string(d1))
+
+	r2 := ToRawUrlBase64([]byte("abc"))
+	d2, _ := base64.RawURLEncoding.DecodeString(r2)
+	assert.Equal("abc", string(d2))
+
+	r3 := ToRawUrlBase64(123)
+	d3, _ := base64.RawURLEncoding.DecodeString(r3)
+	assert.Equal("123", string(d3))
+
+	r4 := ToRawUrlBase64(11.11)
+	d4, _ := base64.RawURLEncoding.DecodeString(r4)
+	assert.Equal("11.11", string(d4))
+
+	r5 := ToRawUrlBase64(map[string]any{"name": "duke", "quantity": 1})
+	d5, _ := base64.RawURLEncoding.DecodeString(r5)
+	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
+
+	r6 := ToRawUrlBase64([]int64{7, 5, 9, 4, 23})
+	d6, _ := base64.RawURLEncoding.DecodeString(r6)
+	assert.Equal("[7,5,9,4,23]", string(d6))
+
+	r7 := ToRawUrlBase64([]string{"7", "5", "9", "4", "23"})
+	d7, _ := base64.RawURLEncoding.DecodeString(r7)
+	assert.Equal("[\"7\",\"5\",\"9\",\"4\",\"23\"]", string(d7))
+
+	r8 := ToRawUrlBase64(nil)
+	d8, _ := base64.RawURLEncoding.DecodeString(r8)
+	assert.Equal("", string(d8))
+
+	ch := make(chan int, 3)
+	ch <- 1
+	ch <- 2
+	r9 := ToRawUrlBase64(ch)
+	d9, _ := base64.RawURLEncoding.DecodeString(r9)
+	assert.Equal("", string(d9))
+
+	r10 := ToRawUrlBase64(io.EOF)
+	d10, _ := base64.RawURLEncoding.DecodeString(r10)
+	assert.Equal("EOF", string(d10))
+
+	r11 := ToRawUrlBase64(errors.New("test"))
+	d11, _ := base64.RawURLEncoding.DecodeString(r11)
+	assert.Equal("test", string(d11))
+
+	typedNil := (*int)(nil)
+	r12 := ToRawUrlBase64(typedNil)
+	d12, _ := base64.RawURLEncoding.DecodeString(r12)
+	assert.Equal("", string(d12))
+
+	type nilInterface interface {
+	}
+	var nI nilInterface = nil
+	d13, _ := base64.RawURLEncoding.DecodeString(ToRawUrlBase64(nI))
+	assert.Equal("", string(d13))
+
+	var p unsafe.Pointer
+	d14, _ := base64.RawURLEncoding.DecodeString(ToRawUrlBase64(p))
+	assert.Equal("", string(d14))
+
+	r15 := ToRawUrlBase64("4+3/4?=")
+	d15, _ := base64.RawURLEncoding.DecodeString(r15)
+	assert.Equal("4+3/4?=", string(d15))
+}
+
+func TestToBigInt(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestToBigInt")
+
+	tests := []struct {
+		name   string
+		input  any
+		want   *big.Int
+		hasErr bool
+	}{
+		{
+			name:  "int",
+			input: 42,
+			want:  big.NewInt(42),
+		},
+		{
+			name:  "int8",
+			input: int8(127),
+			want:  big.NewInt(127),
+		},
+		{
+			name:  "int16",
+			input: int16(32000),
+			want:  big.NewInt(32000),
+		},
+		{
+			name:  "int32",
+			input: int32(123456),
+			want:  big.NewInt(123456),
+		},
+		{
+			name:  "int64",
+			input: int64(987654321),
+			want:  big.NewInt(987654321),
+		},
+		{
+			name:  "uint",
+			input: uint(987654321),
+			want:  big.NewInt(987654321),
+		},
+		{
+			name:  "uint8",
+			input: uint8(255),
+			want:  big.NewInt(255),
+		},
+		{
+			name:  "uint16",
+			input: uint16(65535),
+			want:  big.NewInt(65535),
+		},
+		{
+			name:  "uint32",
+			input: uint32(4294967295),
+			want:  big.NewInt(4294967295),
+		},
+		{
+			name:  "uint64",
+			input: uint64(18446744073709551615),
+			want:  new(big.Int).SetUint64(18446744073709551615),
+		},
+		{
+			name:   "unsupported type",
+			input:  3.14, // Unsupported type
+			hasErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ToBigInt(tt.input)
+			if (err != nil) != tt.hasErr {
+				t.Errorf("ToBigInt() error = %v, hasErr %v", err, tt.hasErr)
+				return
+			}
+
+			assert.Equal(tt.want, got)
+		})
+	}
+}

cryptor/basic.go

@@ -6,7 +6,6 @@
 package cryptor
 
 import (
-	"bufio"
 	"crypto/hmac"
 	"crypto/md5"
 	"crypto/sha1"
@@ -66,34 +65,37 @@ func Md5ByteWithBase64(data []byte) string {
 
 // Md5File return the md5 value of file.
 func Md5File(filename string) (string, error) {
-	if fileInfo, err := os.Stat(filename); err != nil {
-		return "", err
-	} else if fileInfo.IsDir() {
-		return "", nil
-	}
-
 	file, err := os.Open(filename)
 	if err != nil {
 		return "", err
 	}
 	defer file.Close()
 
-	hash := md5.New()
-
-	chunkSize := 65536
-	for buf, reader := make([]byte, chunkSize), bufio.NewReader(file); ; {
-		n, err := reader.Read(buf)
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return "", err
-		}
-		hash.Write(buf[:n])
+	stat, err := file.Stat()
+	if err != nil {
+		return "", err
+	}
+	if stat.IsDir() {
+		return "", nil
 	}
 
-	checksum := fmt.Sprintf("%x", hash.Sum(nil))
-	return checksum, nil
+	hash := md5.New()
+	buf := make([]byte, 65536) // 64KB
+
+	for {
+		n, err := file.Read(buf)
+		if err != nil && err != io.EOF {
+			return "", err
+		}
+		if n > 0 {
+			hash.Write(buf[:n])
+		}
+		if err == io.EOF {
+			break
+		}
+	}
+
+	return fmt.Sprintf("%x", hash.Sum(nil)), nil
 }
 
 // HmacMd5 return the hmac hash of string use md5.
@@ -105,7 +107,7 @@ func HmacMd5(str, key string) string {
 }
 
 // HmacMd5WithBase64 return the hmac hash of string use md5 with base64.
-// todo
+// https://go.dev/play/p/UY0ng2AefFC
 func HmacMd5WithBase64(data, key string) string {
 	h := hmac.New(md5.New, []byte(key))
 	h.Write([]byte(data))

cryptor/crypto.go

@@ -8,11 +8,13 @@ package cryptor
 
 import (
 	"bytes"
+	"crypto"
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/des"
 	"crypto/rand"
 	"crypto/rsa"
+	"crypto/sha256"
 	"crypto/x509"
 	"encoding/pem"
 	"io"
@@ -23,26 +25,30 @@ import (
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/jT5irszHx-j
 func AesEcbEncrypt(data, key []byte) []byte {
-	size := len(key)
-	if size != 16 && size != 24 && size != 32 {
-		panic("key length shoud be 16 or 24 or 32")
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
 	}
 
-	length := (len(data) + aes.BlockSize) / aes.BlockSize
-	plain := make([]byte, length*aes.BlockSize)
+	blockSize := aes.BlockSize
+	dataLen := len(data)
+	padding := blockSize - (dataLen % blockSize)
+	paddedLen := dataLen + padding
 
-	copy(plain, data)
+	paddedData := make([]byte, paddedLen)
+	copy(paddedData, data)
 
-	pad := byte(len(plain) - len(data))
-	for i := len(data); i < len(plain); i++ {
-		plain[i] = pad
+	for i := dataLen; i < paddedLen; i++ {
+		paddedData[i] = byte(padding)
 	}
 
-	encrypted := make([]byte, len(plain))
-	cipher, _ := aes.NewCipher(generateAesKey(key, size))
+	cipher, err := aes.NewCipher(generateAesKey(key, len(key)))
+	if err != nil {
+		panic("aes: failed to create cipher: " + err.Error())
+	}
 
-	for bs, be := 0, cipher.BlockSize(); bs <= len(data); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
-		cipher.Encrypt(encrypted[bs:be], plain[bs:be])
+	encrypted := make([]byte, paddedLen)
+	for bs := 0; bs < paddedLen; bs += blockSize {
+		cipher.Encrypt(encrypted[bs:], paddedData[bs:])
 	}
 
 	return encrypted
@@ -52,64 +58,109 @@ func AesEcbEncrypt(data, key []byte) []byte {
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/jT5irszHx-j
 func AesEcbDecrypt(encrypted, key []byte) []byte {
-	size := len(key)
-	if size != 16 && size != 24 && size != 32 {
-		panic("key length shoud be 16 or 24 or 32")
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
 	}
-	cipher, _ := aes.NewCipher(generateAesKey(key, size))
+
+	blockSize := aes.BlockSize
+	if len(encrypted)%blockSize != 0 {
+		panic("aes: encrypted data length is not a multiple of block size")
+	}
+
+	cipher, err := aes.NewCipher(generateAesKey(key, len(key)))
+	if err != nil {
+		panic("aes: failed to create cipher: " + err.Error())
+	}
+
 	decrypted := make([]byte, len(encrypted))
-
-	for bs, be := 0, cipher.BlockSize(); bs < len(encrypted); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
-		cipher.Decrypt(decrypted[bs:be], encrypted[bs:be])
+	for i := 0; i < len(encrypted); i += blockSize {
+		cipher.Decrypt(decrypted[i:], encrypted[i:])
 	}
 
-	trim := 0
-	if len(decrypted) > 0 {
-		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
+	if len(decrypted) == 0 {
+		return nil
+	}
+	padding := int(decrypted[len(decrypted)-1])
+	if padding == 0 || padding > blockSize {
+		panic("aes: invalid PKCS#7 padding")
+	}
+	for i := len(decrypted) - padding; i < len(decrypted); i++ {
+		if decrypted[i] != byte(padding) {
+			panic("aes: invalid PKCS#7 padding content")
+		}
 	}
 
-	return decrypted[:trim]
+	return decrypted[:len(decrypted)-padding]
 }
 
 // AesCbcEncrypt encrypt data with key use AES CBC algorithm
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/IOq_g8_lKZD
 func AesCbcEncrypt(data, key []byte) []byte {
-	block, _ := aes.NewCipher(key)
-	data = pkcs7Padding(data, block.BlockSize())
-
-	encrypted := make([]byte, aes.BlockSize+len(data))
-	iv := encrypted[:aes.BlockSize]
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
 	}
 
-	mode := cipher.NewCBCEncrypter(block, iv)
-	mode.CryptBlocks(encrypted[aes.BlockSize:], data)
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic("aes: failed to create cipher: " + err.Error())
+	}
 
-	return encrypted
+	padding := aes.BlockSize - len(data)%aes.BlockSize
+	padded := append(data, bytes.Repeat([]byte{byte(padding)}, padding)...)
+
+	iv := make([]byte, aes.BlockSize)
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic("aes: failed to generate IV: " + err.Error())
+	}
+
+	encrypted := make([]byte, len(padded))
+	mode := cipher.NewCBCEncrypter(block, iv)
+	mode.CryptBlocks(encrypted, padded)
+
+	return append(iv, encrypted...)
 }
 
 // AesCbcDecrypt decrypt data with key use AES CBC algorithm
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/IOq_g8_lKZD
 func AesCbcDecrypt(encrypted, key []byte) []byte {
-	block, _ := aes.NewCipher(key)
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
+	}
+
+	if len(encrypted) < aes.BlockSize {
+		panic("aes: ciphertext too short")
+	}
+
+	if len(encrypted)%aes.BlockSize != 0 {
+		panic("aes: ciphertext is not a multiple of the block size")
+	}
 
 	iv := encrypted[:aes.BlockSize]
-	encrypted = encrypted[aes.BlockSize:]
+	ciphertext := encrypted[aes.BlockSize:]
 
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic("aes: failed to create cipher: " + err.Error())
+	}
+
+	decrypted := make([]byte, len(ciphertext))
 	mode := cipher.NewCBCDecrypter(block, iv)
-	mode.CryptBlocks(encrypted, encrypted)
+	mode.CryptBlocks(decrypted, ciphertext)
 
-	decrypted := pkcs7UnPadding(encrypted)
-	return decrypted
+	return pkcs7UnPadding(decrypted)
 }
 
 // AesCtrCrypt encrypt data with key use AES CTR algorithm
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/SpaZO0-5Nsp
+// deprecated: use AesCtrEncrypt and AesCtrDecrypt instead.
 func AesCtrCrypt(data, key []byte) []byte {
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
+	}
+
 	block, _ := aes.NewCipher(key)
 
 	iv := bytes.Repeat([]byte("1"), block.BlockSize())
@@ -121,111 +172,234 @@ func AesCtrCrypt(data, key []byte) []byte {
 	return dst
 }
 
+// AesCtrEncrypt encrypt data with key use AES CTR algorithm
+// len(key) should be 16, 24 or 32.
+// Play: https://go.dev/play/p/x6pjPAvThRz
+func AesCtrEncrypt(data, key []byte) []byte {
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
+	}
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic("aes: failed to create cipher: " + err.Error())
+	}
+
+	iv := make([]byte, aes.BlockSize)
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic("aes: failed to generate IV: " + err.Error())
+	}
+
+	stream := cipher.NewCTR(block, iv)
+	ciphertext := make([]byte, len(data))
+	stream.XORKeyStream(ciphertext, data)
+
+	return append(iv, ciphertext...)
+}
+
+// AesCtrDecrypt decrypt data with key use AES CTR algorithm
+// len(key) should be 16, 24 or 32.
+// Play: https://go.dev/play/p/x6pjPAvThRz
+func AesCtrDecrypt(encrypted, key []byte) []byte {
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
+	}
+	if len(encrypted) < aes.BlockSize {
+		panic("aes: invalid ciphertext length")
+	}
+
+	iv := encrypted[:aes.BlockSize]
+	ciphertext := encrypted[aes.BlockSize:]
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic("aes: failed to create cipher: " + err.Error())
+	}
+
+	stream := cipher.NewCTR(block, iv)
+	plaintext := make([]byte, len(ciphertext))
+	stream.XORKeyStream(plaintext, ciphertext)
+
+	return plaintext
+}
+
 // AesCfbEncrypt encrypt data with key use AES CFB algorithm
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/tfkF10B13kH
 func AesCfbEncrypt(data, key []byte) []byte {
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
+	}
+
 	block, err := aes.NewCipher(key)
 	if err != nil {
-		panic(err)
+		panic("aes: failed to create cipher: " + err.Error())
 	}
 
-	encrypted := make([]byte, aes.BlockSize+len(data))
-	iv := encrypted[:aes.BlockSize]
-
+	iv := make([]byte, aes.BlockSize)
 	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
+		panic("aes: failed to generate IV: " + err.Error())
 	}
 
+	ciphertext := make([]byte, len(data))
 	stream := cipher.NewCFBEncrypter(block, iv)
-	stream.XORKeyStream(encrypted[aes.BlockSize:], data)
+	stream.XORKeyStream(ciphertext, data)
 
-	return encrypted
+	return append(iv, ciphertext...)
 }
 
 // AesCfbDecrypt decrypt data with key use AES CFB algorithm
 // len(encrypted) should be great than 16, len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/tfkF10B13kH
 func AesCfbDecrypt(encrypted, key []byte) []byte {
-	if len(encrypted) < aes.BlockSize {
-		panic("encrypted data is too short")
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
+	}
+
+	if len(encrypted) < aes.BlockSize {
+		panic("aes: encrypted data too short")
 	}
 
-	block, _ := aes.NewCipher(key)
 	iv := encrypted[:aes.BlockSize]
-	encrypted = encrypted[aes.BlockSize:]
+	ciphertext := encrypted[aes.BlockSize:]
 
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic("aes: failed to create cipher: " + err.Error())
+	}
+
+	plaintext := make([]byte, len(ciphertext))
 	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(plaintext, ciphertext)
 
-	stream.XORKeyStream(encrypted, encrypted)
-
-	return encrypted
+	return plaintext
 }
 
 // AesOfbEncrypt encrypt data with key use AES OFB algorithm
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/VtHxtkUj-3F
 func AesOfbEncrypt(data, key []byte) []byte {
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
+	}
+
 	block, err := aes.NewCipher(key)
 	if err != nil {
-		panic(err)
+		panic("aes: failed to create cipher: " + err.Error())
 	}
 
-	data = pkcs7Padding(data, aes.BlockSize)
-	encrypted := make([]byte, aes.BlockSize+len(data))
-	iv := encrypted[:aes.BlockSize]
+	iv := make([]byte, aes.BlockSize)
 	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
+		panic("aes: failed to generate IV: " + err.Error())
 	}
 
+	ciphertext := make([]byte, len(data))
 	stream := cipher.NewOFB(block, iv)
-	stream.XORKeyStream(encrypted[aes.BlockSize:], data)
+	stream.XORKeyStream(ciphertext, data)
 
-	return encrypted
+	return append(iv, ciphertext...)
 }
 
 // AesOfbDecrypt decrypt data with key use AES OFB algorithm
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/VtHxtkUj-3F
 func AesOfbDecrypt(data, key []byte) []byte {
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic(err)
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
+	}
+
+	if len(data) < aes.BlockSize {
+		panic("aes: encrypted data too short")
 	}
 
 	iv := data[:aes.BlockSize]
-	data = data[aes.BlockSize:]
-	if len(data)%aes.BlockSize != 0 {
-		return nil
+	ciphertext := data[aes.BlockSize:]
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic("aes: failed to create cipher: " + err.Error())
 	}
 
-	decrypted := make([]byte, len(data))
-	mode := cipher.NewOFB(block, iv)
-	mode.XORKeyStream(decrypted, data)
+	plaintext := make([]byte, len(ciphertext))
+	stream := cipher.NewOFB(block, iv)
+	stream.XORKeyStream(plaintext, ciphertext)
 
-	decrypted = pkcs7UnPadding(decrypted)
+	return plaintext
+}
 
-	return decrypted
+// AesGcmEncrypt encrypt data with key use AES GCM algorithm
+// Play: https://go.dev/play/p/rUt0-DmsPCs
+func AesGcmEncrypt(data, key []byte) []byte {
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
+	}
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic("aes: failed to create cipher: " + err.Error())
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		panic("aes: failed to create GCM: " + err.Error())
+	}
+
+	nonce := make([]byte, gcm.NonceSize())
+	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+		panic("aes: failed to generate nonce: " + err.Error())
+	}
+
+	ciphertext := gcm.Seal(nil, nonce, data, nil)
+
+	return append(nonce, ciphertext...)
+}
+
+// AesGcmDecrypt decrypt data with key use AES GCM algorithm
+// Play: https://go.dev/play/p/rUt0-DmsPCs
+func AesGcmDecrypt(data, key []byte) []byte {
+	if !isAesKeyLengthValid(len(key)) {
+		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
+	}
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic("aes: failed to create cipher: " + err.Error())
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		panic("aes: failed to create GCM: " + err.Error())
+	}
+
+	nonceSize := gcm.NonceSize()
+	if len(data) < nonceSize {
+		panic("aes: ciphertext too short")
+	}
+
+	nonce, ciphertext := data[:nonceSize], data[nonceSize:]
+	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
+	if err != nil {
+		panic("aes: decryption failed: " + err.Error())
+	}
+
+	return plaintext
 }
 
 // DesEcbEncrypt encrypt data with key use DES ECB algorithm
 // len(key) should be 8.
 // Play: https://go.dev/play/p/8qivmPeZy4P
 func DesEcbEncrypt(data, key []byte) []byte {
-	length := (len(data) + des.BlockSize) / des.BlockSize
-	plain := make([]byte, length*des.BlockSize)
-	copy(plain, data)
-
-	pad := byte(len(plain) - len(data))
-	for i := len(data); i < len(plain); i++ {
-		plain[i] = pad
+	cipher, err := des.NewCipher(generateDesKey(key))
+	if err != nil {
+		panic("des: failed to create cipher: " + err.Error())
 	}
 
-	encrypted := make([]byte, len(plain))
-	cipher, _ := des.NewCipher(generateDesKey(key))
+	blockSize := cipher.BlockSize()
+	padded := pkcs5Padding(data, blockSize)
+	encrypted := make([]byte, len(padded))
 
-	for bs, be := 0, cipher.BlockSize(); bs <= len(data); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
-		cipher.Encrypt(encrypted[bs:be], plain[bs:be])
+	for i := 0; i < len(padded); i += blockSize {
+		cipher.Encrypt(encrypted[i:], padded[i:])
 	}
 
 	return encrypted
@@ -235,37 +409,50 @@ func DesEcbEncrypt(data, key []byte) []byte {
 // len(key) should be 8.
 // Play: https://go.dev/play/p/8qivmPeZy4P
 func DesEcbDecrypt(encrypted, key []byte) []byte {
-	cipher, _ := des.NewCipher(generateDesKey(key))
+	cipher, err := des.NewCipher(generateDesKey(key))
+	if err != nil {
+		panic("des: failed to create cipher: " + err.Error())
+	}
+
+	blockSize := cipher.BlockSize()
+	if len(encrypted)%blockSize != 0 {
+		panic("des: invalid encrypted data length")
+	}
+
 	decrypted := make([]byte, len(encrypted))
-
-	for bs, be := 0, cipher.BlockSize(); bs < len(encrypted); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
-		cipher.Decrypt(decrypted[bs:be], encrypted[bs:be])
+	for i := 0; i < len(encrypted); i += blockSize {
+		cipher.Decrypt(decrypted[i:], encrypted[i:])
 	}
 
-	trim := 0
-	if len(decrypted) > 0 {
-		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
-	}
-
-	return decrypted[:trim]
+	// Remove padding
+	return pkcs5UnPadding(decrypted)
 }
 
 // DesCbcEncrypt encrypt data with key use DES CBC algorithm
 // len(key) should be 8.
 // Play: https://go.dev/play/p/4cC4QvWfe3_1
 func DesCbcEncrypt(data, key []byte) []byte {
-	block, _ := des.NewCipher(key)
-	data = pkcs7Padding(data, block.BlockSize())
+	if len(key) != 8 {
+		panic("des: key length must be 8 bytes")
+	}
 
-	encrypted := make([]byte, des.BlockSize+len(data))
-	iv := encrypted[:des.BlockSize]
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic("des: failed to create cipher: " + err.Error())
+	}
+
+	blockSize := block.BlockSize()
+	data = pkcs7Padding(data, blockSize)
+
+	encrypted := make([]byte, blockSize+len(data))
+	iv := encrypted[:blockSize]
 
 	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
+		panic("des: failed to generate IV: " + err.Error())
 	}
 
 	mode := cipher.NewCBCEncrypter(block, iv)
-	mode.CryptBlocks(encrypted[des.BlockSize:], data)
+	mode.CryptBlocks(encrypted[blockSize:], data)
 
 	return encrypted
 }
@@ -274,22 +461,39 @@ func DesCbcEncrypt(data, key []byte) []byte {
 // len(key) should be 8.
 // Play: https://go.dev/play/p/4cC4QvWfe3_1
 func DesCbcDecrypt(encrypted, key []byte) []byte {
-	block, _ := des.NewCipher(key)
+	if len(key) != 8 {
+		panic("des: key length must be 8 bytes")
+	}
 
-	iv := encrypted[:des.BlockSize]
-	encrypted = encrypted[des.BlockSize:]
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic("des: failed to create cipher: " + err.Error())
+	}
+
+	blockSize := block.BlockSize()
+	if len(encrypted) < blockSize || len(encrypted)%blockSize != 0 {
+		panic("des: invalid encrypted data length")
+	}
+
+	iv := encrypted[:blockSize]
+	ciphertext := encrypted[blockSize:]
 
 	mode := cipher.NewCBCDecrypter(block, iv)
-	mode.CryptBlocks(encrypted, encrypted)
+	mode.CryptBlocks(ciphertext, ciphertext)
 
-	decrypted := pkcs7UnPadding(encrypted)
-	return decrypted
+	return pkcs7UnPadding(ciphertext)
 }
 
 // DesCtrCrypt encrypt data with key use DES CTR algorithm
 // len(key) should be 8.
 // Play: https://go.dev/play/p/9-T6OjKpcdw
+// deprecated: use DesCtrEncrypt and DesCtrDecrypt instead.
 func DesCtrCrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 8 {
+		panic("key length shoud be 8")
+	}
+
 	block, _ := des.NewCipher(key)
 
 	iv := bytes.Repeat([]byte("1"), block.BlockSize())
@@ -301,20 +505,83 @@ func DesCtrCrypt(data, key []byte) []byte {
 	return dst
 }
 
+// DesCtrEncrypt encrypt data with key use DES CTR algorithm
+// len(key) should be 8.
+// Play: https://go.dev/play/p/S6p_WHCgH1d
+func DesCtrEncrypt(data, key []byte) []byte {
+	if len(key) != 8 {
+		panic("des: key length must be 8 bytes")
+	}
+
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic("des: failed to create cipher: " + err.Error())
+	}
+
+	iv := make([]byte, block.BlockSize())
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic("des: failed to generate IV: " + err.Error())
+	}
+
+	stream := cipher.NewCTR(block, iv)
+
+	encrypted := make([]byte, len(data))
+	stream.XORKeyStream(encrypted, data)
+
+	// 返回前缀包含 IV，便于解密
+	return append(iv, encrypted...)
+}
+
+// DesCtrDecrypt decrypt data with key use DES CTR algorithm
+// len(key) should be 8.
+// Play: https://go.dev/play/p/S6p_WHCgH1d
+func DesCtrDecrypt(encrypted, key []byte) []byte {
+	if len(key) != 8 {
+		panic("des: key length must be 8 bytes")
+	}
+
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic("des: failed to create cipher: " + err.Error())
+	}
+
+	blockSize := block.BlockSize()
+	if len(encrypted) < blockSize {
+		panic("des: ciphertext too short")
+	}
+
+	iv := encrypted[:blockSize]
+	ciphertext := encrypted[blockSize:]
+
+	stream := cipher.NewCTR(block, iv)
+
+	decrypted := make([]byte, len(ciphertext))
+	stream.XORKeyStream(decrypted, ciphertext)
+
+	return decrypted
+}
+
 // DesCfbEncrypt encrypt data with key use DES CFB algorithm
 // len(key) should be 8.
 // Play: https://go.dev/play/p/y-eNxcFBlxL
 func DesCfbEncrypt(data, key []byte) []byte {
+	if len(key) != 8 {
+		panic("des: key length must be 8 bytes")
+	}
+
 	block, err := des.NewCipher(key)
 	if err != nil {
-		panic(err)
+		panic("des: failed to create cipher: " + err.Error())
+	}
+
+	iv := make([]byte, des.BlockSize)
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic("des: failed to generate IV: " + err.Error())
 	}
 
 	encrypted := make([]byte, des.BlockSize+len(data))
-	iv := encrypted[:des.BlockSize]
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
-	}
+
+	copy(encrypted[:des.BlockSize], iv)
 
 	stream := cipher.NewCFBEncrypter(block, iv)
 	stream.XORKeyStream(encrypted[des.BlockSize:], data)
@@ -326,34 +593,51 @@ func DesCfbEncrypt(data, key []byte) []byte {
 // len(encrypted) should be great than 16, len(key) should be 8.
 // Play: https://go.dev/play/p/y-eNxcFBlxL
 func DesCfbDecrypt(encrypted, key []byte) []byte {
-	block, _ := des.NewCipher(key)
-	if len(encrypted) < des.BlockSize {
-		panic("encrypted data is too short")
+	if len(key) != 8 {
+		panic("des: key length must be 8 bytes")
 	}
+
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic("des: failed to create cipher: " + err.Error())
+	}
+
+	if len(encrypted) < des.BlockSize {
+		panic("des: encrypted data too short")
+	}
+
 	iv := encrypted[:des.BlockSize]
-	encrypted = encrypted[des.BlockSize:]
+	ciphertext := encrypted[des.BlockSize:]
 
 	stream := cipher.NewCFBDecrypter(block, iv)
-	stream.XORKeyStream(encrypted, encrypted)
+	stream.XORKeyStream(ciphertext, ciphertext)
 
-	return encrypted
+	return ciphertext
 }
 
 // DesOfbEncrypt encrypt data with key use DES OFB algorithm
-// len(key) should be 16, 24 or 32.
+// len(key) should be 8.
 // Play: https://go.dev/play/p/74KmNadjN1J
 func DesOfbEncrypt(data, key []byte) []byte {
+	if len(key) != 8 {
+		panic("des: key length must be 8 bytes")
+	}
+
 	block, err := des.NewCipher(key)
 	if err != nil {
-		panic(err)
+		panic("des: failed to create cipher: " + err.Error())
 	}
+
 	data = pkcs7Padding(data, des.BlockSize)
-	encrypted := make([]byte, des.BlockSize+len(data))
-	iv := encrypted[:des.BlockSize]
+
+	iv := make([]byte, des.BlockSize)
 	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
+		panic("des: failed to generate IV: " + err.Error())
 	}
 
+	encrypted := make([]byte, des.BlockSize+len(data))
+	copy(encrypted[:des.BlockSize], iv)
+
 	stream := cipher.NewOFB(block, iv)
 	stream.XORKeyStream(encrypted[des.BlockSize:], data)
 
@@ -364,20 +648,25 @@ func DesOfbEncrypt(data, key []byte) []byte {
 // len(key) should be 8.
 // Play: https://go.dev/play/p/74KmNadjN1J
 func DesOfbDecrypt(data, key []byte) []byte {
+	if len(key) != 8 {
+		panic("des: key length must be 8 bytes")
+	}
+
 	block, err := des.NewCipher(key)
 	if err != nil {
-		panic(err)
+		panic("des: failed to create cipher: " + err.Error())
+	}
+
+	if len(data) < des.BlockSize {
+		panic("des: encrypted data too short")
 	}
 
 	iv := data[:des.BlockSize]
-	data = data[des.BlockSize:]
-	if len(data)%des.BlockSize != 0 {
-		return nil
-	}
+	ciphertext := data[des.BlockSize:]
 
-	decrypted := make([]byte, len(data))
-	mode := cipher.NewOFB(block, iv)
-	mode.XORKeyStream(decrypted, data)
+	stream := cipher.NewOFB(block, iv)
+	decrypted := make([]byte, len(ciphertext))
+	stream.XORKeyStream(decrypted, ciphertext)
 
 	decrypted = pkcs7UnPadding(decrypted)
 
@@ -440,7 +729,7 @@ func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error {
 }
 
 // RsaEncrypt encrypt data with ras algorithm.
-// Play: https://go.dev/play/p/rDqTT01SPkZ
+// Play: https://go.dev/play/p/7_zo6mrx-eX
 func RsaEncrypt(data []byte, pubKeyFileName string) []byte {
 	file, err := os.Open(pubKeyFileName)
 	if err != nil {
@@ -470,11 +759,12 @@ func RsaEncrypt(data []byte, pubKeyFileName string) []byte {
 	if err != nil {
 		panic(err)
 	}
+
 	return cipherText
 }
 
 // RsaDecrypt decrypt data with ras algorithm.
-// Play: https://go.dev/play/p/rDqTT01SPkZ
+// Play: https://go.dev/play/p/7_zo6mrx-eX
 func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
 	file, err := os.Open(privateKeyFileName)
 	if err != nil {
@@ -503,5 +793,67 @@ func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
 	if err != nil {
 		panic(err)
 	}
+
 	return plainText
 }
+
+// GenerateRsaKeyPair create rsa private and public key.
+// Play: https://go.dev/play/p/sSVmkfENKMz
+func GenerateRsaKeyPair(keySize int) (*rsa.PrivateKey, *rsa.PublicKey) {
+	privateKey, _ := rsa.GenerateKey(rand.Reader, keySize)
+	return privateKey, &privateKey.PublicKey
+}
+
+// RsaEncryptOAEP encrypts the given data with RSA-OAEP.
+// Play: https://go.dev/play/p/sSVmkfENKMz
+func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error) {
+	encryptedBytes, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, &key, data, label)
+	if err != nil {
+		return nil, err
+	}
+
+	return encryptedBytes, nil
+}
+
+// RsaDecryptOAEP decrypts the data with RSA-OAEP.
+// Play: https://go.dev/play/p/sSVmkfENKMz
+func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte, error) {
+	decryptedBytes, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, &key, ciphertext, label)
+	if err != nil {
+		return nil, err
+	}
+
+	return decryptedBytes, nil
+}
+
+// RsaSign signs the data with RSA.
+// Play: https://go.dev/play/p/qhsbf8BJ6Mf
+func RsaSign(hash crypto.Hash, data []byte, privateKeyFileName string) ([]byte, error) {
+	privateKey, err := loadRasPrivateKey(privateKeyFileName)
+	if err != nil {
+		return nil, err
+	}
+
+	hashed, err := hashData(hash, data)
+	if err != nil {
+		return nil, err
+	}
+
+	return rsa.SignPKCS1v15(rand.Reader, privateKey, hash, hashed)
+}
+
+// RsaVerifySign verifies the signature of the data with RSA.
+// Play: https://go.dev/play/p/qhsbf8BJ6Mf
+func RsaVerifySign(hash crypto.Hash, data, signature []byte, pubKeyFileName string) error {
+	publicKey, err := loadRsaPublicKey(pubKeyFileName)
+	if err != nil {
+		return err
+	}
+
+	hashed, err := hashData(hash, data)
+	if err != nil {
+		return err
+	}
+
+	return rsa.VerifyPKCS1v15(publicKey, hash, hashed, signature)
+}

cryptor/crypto_example_test.go

@@ -1,6 +1,9 @@
 package cryptor
 
-import "fmt"
+import (
+	"crypto"
+	"fmt"
+)
 
 func ExampleAesEcbEncrypt() {
 	data := "hello"
@@ -71,6 +74,32 @@ func ExampleAesCtrCrypt() {
 	// hello
 }
 
+func ExampleAesCtrEncrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	enCrypt := AesCtrEncrypt([]byte(data), []byte(key))
+	deCrypt := AesCtrDecrypt(enCrypt, []byte(key))
+
+	fmt.Println(string(deCrypt))
+
+	// Output:
+	// hello
+}
+
+func ExampleAesCtrDecrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	enCrypt := AesCtrEncrypt([]byte(data), []byte(key))
+	deCrypt := AesCtrDecrypt(enCrypt, []byte(key))
+
+	fmt.Println(string(deCrypt))
+
+	// Output:
+	// hello
+}
+
 func ExampleAesCfbEncrypt() {
 	data := "hello"
 	key := "abcdefghijklmnop"
@@ -127,6 +156,34 @@ func ExampleAesOfbDecrypt() {
 	// hello
 }
 
+func ExampleAesGcmEncrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesGcmEncrypt([]byte(data), []byte(key))
+
+	decrypted := AesGcmDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleAesGcmDecrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesGcmEncrypt([]byte(data), []byte(key))
+
+	decrypted := AesGcmDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
 func ExampleDesEcbEncrypt() {
 	data := "hello"
 	key := "abcdefgh"
@@ -196,6 +253,19 @@ func ExampleDesCtrCrypt() {
 	// hello
 }
 
+func ExampleDesCtrDecrypt() {
+	data := "hello"
+	key := "abcdefgh"
+
+	enCrypt := DesCtrEncrypt([]byte(data), []byte(key))
+	deCrypt := DesCtrDecrypt(enCrypt, []byte(key))
+
+	fmt.Println(string(deCrypt))
+
+	// Output:
+	// hello
+}
+
 func ExampleDesCfbEncrypt() {
 	data := "hello"
 	key := "abcdefgh"
@@ -254,7 +324,7 @@ func ExampleDesOfbDecrypt() {
 
 func ExampleGenerateRsaKey() {
 	// Create ras private and public pem file
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
 	if err != nil {
 		return
 	}
@@ -267,14 +337,14 @@ func ExampleGenerateRsaKey() {
 
 func ExampleRsaEncrypt() {
 	// Create ras private and public pem file
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
 	if err != nil {
 		return
 	}
 
 	data := []byte("hello")
-	encrypted := RsaEncrypt(data, "rsa_public.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
+	encrypted := RsaEncrypt(data, "rsa_public_example.pem")
+	decrypted := RsaDecrypt(encrypted, "rsa_private_example.pem")
 
 	fmt.Println(string(decrypted))
 
@@ -284,14 +354,14 @@ func ExampleRsaEncrypt() {
 
 func ExampleRsaDecrypt() {
 	// Create ras private and public pem file
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
 	if err != nil {
 		return
 	}
 
 	data := []byte("hello")
-	encrypted := RsaEncrypt(data, "rsa_public.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
+	encrypted := RsaEncrypt(data, "rsa_public_example.pem")
+	decrypted := RsaDecrypt(encrypted, "rsa_private_example.pem")
 
 	fmt.Println(string(decrypted))
 
@@ -484,3 +554,71 @@ func ExampleSha512WithBase64() {
 	// Output:
 	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
 }
+
+func ExampleRsaEncryptOAEP() {
+	pri, pub := GenerateRsaKeyPair(1024)
+
+	data := []byte("hello world")
+	label := []byte("123456")
+
+	encrypted, err := RsaEncryptOAEP(data, label, *pub)
+	if err != nil {
+		return
+	}
+
+	decrypted, err := RsaDecryptOAEP([]byte(encrypted), label, *pri)
+	if err != nil {
+		return
+	}
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello world
+}
+
+func ExampleRsaSign() {
+	data := []byte("This is a test data for RSA signing")
+	hash := crypto.SHA256
+
+	privateKey := "./rsa_private_example.pem"
+	publicKey := "./rsa_public_example.pem"
+
+	signature, err := RsaSign(hash, data, privateKey)
+	if err != nil {
+		return
+	}
+
+	err = RsaVerifySign(hash, data, signature, publicKey)
+	if err != nil {
+		return
+	}
+
+	fmt.Println("ok")
+
+	// Output:
+	// ok
+}
+
+func ExampleRsaVerifySign() {
+	data := []byte("This is a test data for RSA signing")
+	hash := crypto.SHA256
+
+	privateKey := "./rsa_private_example.pem"
+	publicKey := "./rsa_public_example.pem"
+
+	signature, err := RsaSign(hash, data, privateKey)
+	if err != nil {
+		return
+	}
+
+	err = RsaVerifySign(hash, data, signature, publicKey)
+	if err != nil {
+		return
+	}
+
+	fmt.Println("ok")
+
+	// Output:
+	// ok
+}

cryptor/crypto_internal.go

@@ -1,6 +1,17 @@
 package cryptor
 
-import "bytes"
+import (
+	"bytes"
+	"crypto"
+	"crypto/rsa"
+	"crypto/sha256"
+	"crypto/sha512"
+	"crypto/x509"
+	"encoding/pem"
+	"errors"
+	"os"
+	"strings"
+)
 
 func generateAesKey(key []byte, size int) []byte {
 	genKey := make([]byte, size)
@@ -35,3 +46,139 @@ func pkcs7UnPadding(src []byte) []byte {
 	unPadding := int(src[length-1])
 	return src[:(length - unPadding)]
 }
+
+func pkcs5Padding(data []byte, blockSize int) []byte {
+	padding := blockSize - len(data)%blockSize
+	padText := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(data, padText...)
+}
+
+func pkcs5UnPadding(data []byte) []byte {
+	length := len(data)
+	if length == 0 {
+		return nil
+	}
+	padLen := int(data[length-1])
+	if padLen == 0 || padLen > length {
+		return nil
+	}
+	return data[:length-padLen]
+}
+
+func isAesKeyLengthValid(n int) bool {
+	return n == 16 || n == 24 || n == 32
+}
+
+// loadRsaPrivateKey loads and parses a PEM encoded private key file.
+func loadRsaPublicKey(filename string) (*rsa.PublicKey, error) {
+	pubKeyData, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	block, _ := pem.Decode(pubKeyData)
+	if block == nil {
+		return nil, errors.New("failed to decode PEM block containing the public key")
+	}
+
+	var pubKey *rsa.PublicKey
+	blockType := strings.ToUpper(block.Type)
+
+	if blockType == "RSA PUBLIC KEY" {
+		pubKey, err = x509.ParsePKCS1PublicKey(block.Bytes)
+		if err != nil {
+			key, err := x509.ParsePKIXPublicKey(block.Bytes)
+			if err != nil {
+				return nil, err
+			}
+
+			var ok bool
+			pubKey, ok = key.(*rsa.PublicKey)
+			if !ok {
+				return nil, errors.New("failed to parse RSA private key")
+			}
+		}
+	} else if blockType == "PUBLIC KEY" {
+		key, err := x509.ParsePKIXPublicKey(block.Bytes)
+		if err != nil {
+			return nil, err
+		}
+
+		var ok bool
+		pubKey, ok = key.(*rsa.PublicKey)
+		if !ok {
+			return nil, errors.New("failed to parse RSA private key")
+		}
+
+	} else {
+		return nil, errors.New("unsupported key type")
+	}
+
+	return pubKey, nil
+}
+
+// loadRsaPrivateKey loads and parses a PEM encoded private key file.
+func loadRasPrivateKey(filename string) (*rsa.PrivateKey, error) {
+	priKeyData, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	block, _ := pem.Decode(priKeyData)
+	if block == nil {
+		return nil, errors.New("failed to decode PEM block containing the private key")
+	}
+
+	var privateKey *rsa.PrivateKey
+	blockType := strings.ToUpper(block.Type)
+
+	// PKCS#1 format
+	if blockType == "RSA PRIVATE KEY" {
+		privateKey, err = x509.ParsePKCS1PrivateKey(block.Bytes)
+		if err != nil {
+			return nil, err
+		}
+	} else if blockType == "PRIVATE KEY" { // PKCS#8 format
+		priKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
+		if err != nil {
+			return nil, err
+		}
+		var ok bool
+		privateKey, ok = priKey.(*rsa.PrivateKey)
+		if !ok {
+			return nil, errors.New("failed to parse RSA private key")
+		}
+	} else {
+		return nil, errors.New("unsupported key type")
+	}
+
+	return privateKey, nil
+}
+
+// hashData returns the hash value of the data, using the specified hash function
+func hashData(hash crypto.Hash, data []byte) ([]byte, error) {
+	if !hash.Available() {
+		return nil, errors.New("unsupported hash algorithm")
+	}
+
+	var hashed []byte
+
+	switch hash {
+	case crypto.SHA224:
+		h := sha256.Sum224(data)
+		hashed = h[:]
+	case crypto.SHA256:
+		h := sha256.Sum256(data)
+		hashed = h[:]
+	case crypto.SHA384:
+		h := sha512.Sum384(data)
+		hashed = h[:]
+	case crypto.SHA512:
+		h := sha512.Sum512(data)
+		hashed = h[:]
+	default:
+		return nil, errors.New("unsupported hash algorithm")
+	}
+
+	return hashed, nil
+}

cryptor/crypto_test.go

@@ -1,12 +1,13 @@
 package cryptor
 
 import (
+	"crypto"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
 )
 
-func TestAesEcbEncrypt(t *testing.T) {
+func TestAesEcbCrypt(t *testing.T) {
 	t.Parallel()
 
 	data := "hello world"
@@ -15,11 +16,11 @@ func TestAesEcbEncrypt(t *testing.T) {
 	aesEcbEncrypt := AesEcbEncrypt([]byte(data), []byte(key))
 	aesEcbDecrypt := AesEcbDecrypt(aesEcbEncrypt, []byte(key))
 
-	assert := internal.NewAssert(t, "TestAesEcbEncrypt")
+	assert := internal.NewAssert(t, "TestAesEcbCrypt")
 	assert.Equal(data, string(aesEcbDecrypt))
 }
 
-func TestAesCbcEncrypt(t *testing.T) {
+func TestAesCbcCrypt(t *testing.T) {
 	t.Parallel()
 
 	data := "hello world"
@@ -28,7 +29,7 @@ func TestAesCbcEncrypt(t *testing.T) {
 	aesCbcEncrypt := AesCbcEncrypt([]byte(data), []byte(key))
 	aesCbcDecrypt := AesCbcDecrypt(aesCbcEncrypt, []byte(key))
 
-	assert := internal.NewAssert(t, "TestAesCbcEncrypt")
+	assert := internal.NewAssert(t, "TestAesCbcCrypt")
 	assert.Equal(data, string(aesCbcDecrypt))
 }
 
@@ -38,14 +39,14 @@ func TestAesCtrCrypt(t *testing.T) {
 	data := "hello world"
 	key := "abcdefghijklmnop"
 
-	aesCtrCrypt := AesCtrCrypt([]byte(data), []byte(key))
-	aesCtrDeCrypt := AesCtrCrypt(aesCtrCrypt, []byte(key))
+	aesCtrCrypt := AesCtrEncrypt([]byte(data), []byte(key))
+	aesCtrDeCrypt := AesCtrDecrypt(aesCtrCrypt, []byte(key))
 
 	assert := internal.NewAssert(t, "TestAesCtrCrypt")
 	assert.Equal(data, string(aesCtrDeCrypt))
 }
 
-func TestAesCfbEncrypt(t *testing.T) {
+func TestAesCfbCrypt(t *testing.T) {
 	t.Parallel()
 
 	data := "hello world"
@@ -54,11 +55,11 @@ func TestAesCfbEncrypt(t *testing.T) {
 	aesCfbEncrypt := AesCfbEncrypt([]byte(data), []byte(key))
 	aesCfbDecrypt := AesCfbDecrypt(aesCfbEncrypt, []byte(key))
 
-	assert := internal.NewAssert(t, "TestAesCfbEncrypt")
+	assert := internal.NewAssert(t, "TestAesCfbCrypt")
 	assert.Equal(data, string(aesCfbDecrypt))
 }
 
-func TestAesOfbEncrypt(t *testing.T) {
+func TestAesOfbCrypt(t *testing.T) {
 	t.Parallel()
 
 	data := "hello world"
@@ -71,7 +72,7 @@ func TestAesOfbEncrypt(t *testing.T) {
 	assert.Equal(data, string(aesOfbDecrypt))
 }
 
-func TestDesEcbEncrypt(t *testing.T) {
+func TestDesEcbCrypt(t *testing.T) {
 	t.Parallel()
 
 	data := "hello world"
@@ -84,7 +85,7 @@ func TestDesEcbEncrypt(t *testing.T) {
 	assert.Equal(data, string(desEcbDecrypt))
 }
 
-func TestDesCbcEncrypt(t *testing.T) {
+func TestDesCbcCrypt(t *testing.T) {
 	t.Parallel()
 
 	data := "hello world"
@@ -103,14 +104,14 @@ func TestDesCtrCrypt(t *testing.T) {
 	data := "hello world"
 	key := "abcdefgh"
 
-	desCtrCrypt := DesCtrCrypt([]byte(data), []byte(key))
-	desCtrDeCrypt := DesCtrCrypt(desCtrCrypt, []byte(key))
+	desCtrCrypt := DesCtrEncrypt([]byte(data), []byte(key))
+	desCtrDeCrypt := DesCtrDecrypt(desCtrCrypt, []byte(key))
 
 	assert := internal.NewAssert(t, "TestDesCtrCrypt")
 	assert.Equal(data, string(desCtrDeCrypt))
 }
 
-func TestDesCfbEncrypt(t *testing.T) {
+func TestDesCfbCrypt(t *testing.T) {
 	t.Parallel()
 
 	data := "hello world"
@@ -123,7 +124,7 @@ func TestDesCfbEncrypt(t *testing.T) {
 	assert.Equal(data, string(desCfbDecrypt))
 }
 
-func TestDesOfbEncrypt(t *testing.T) {
+func TestDesOfbCrypt(t *testing.T) {
 	t.Parallel()
 
 	data := "hello world"
@@ -139,14 +140,95 @@ func TestDesOfbEncrypt(t *testing.T) {
 func TestRsaEncrypt(t *testing.T) {
 	t.Parallel()
 
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	err := GenerateRsaKey(4096, "./rsa_private_example.pem", "./rsa_public_example.pem")
 	if err != nil {
 		t.FailNow()
 	}
 	data := []byte("hello world")
-	encrypted := RsaEncrypt(data, "rsa_public.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
+	encrypted := RsaEncrypt(data, "./rsa_public_example.pem")
+	decrypted := RsaDecrypt(encrypted, "./rsa_private_example.pem")
 
 	assert := internal.NewAssert(t, "TestRsaEncrypt")
 	assert.Equal(string(data), string(decrypted))
 }
+
+func TestRsaEncryptOAEP(t *testing.T) {
+	assert := internal.NewAssert(t, "TestRsaEncrypt")
+	t.Parallel()
+
+	pri, pub := GenerateRsaKeyPair(1024)
+
+	data := []byte("hello world")
+	label := []byte("123456")
+
+	encrypted, err := RsaEncryptOAEP(data, label, *pub)
+	assert.IsNil(err)
+
+	decrypted, err := RsaDecryptOAEP([]byte(encrypted), label, *pri)
+
+	assert.IsNil(err)
+	assert.Equal("hello world", string(decrypted))
+}
+
+func TestAesGcmEncrypt(t *testing.T) {
+	t.Parallel()
+
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesGcmEncrypt([]byte(data), []byte(key))
+	decrypted := AesGcmDecrypt(encrypted, []byte(key))
+
+	assert := internal.NewAssert(t, "TestAesGcmEncrypt")
+	assert.Equal(data, string(decrypted))
+}
+
+func TestRsaSignAndVerify(t *testing.T) {
+	t.Parallel()
+
+	data := []byte("This is a test data for RSA signing")
+	hash := crypto.SHA256
+
+	t.Run("RSA Sign and Verify", func(t *testing.T) {
+		privateKey := "./rsa_private_example.pem"
+		publicKey := "./rsa_public_example.pem"
+
+		signature, err := RsaSign(hash, data, privateKey)
+		if err != nil {
+			t.Fatalf("RsaSign failed: %v", err)
+		}
+
+		err = RsaVerifySign(hash, data, signature, publicKey)
+		if err != nil {
+			t.Fatalf("RsaVerifySign failed: %v", err)
+		}
+	})
+
+	t.Run("RSA Sign and Verify Invalid Signature", func(t *testing.T) {
+		publicKey := "./rsa_public_example.pem"
+
+		invalidSig := []byte("InvalidSignature")
+
+		err := RsaVerifySign(hash, data, invalidSig, publicKey)
+		if err == nil {
+			t.Fatalf("RsaVerifySign failed: %v", err)
+		}
+	})
+
+	t.Run("RSA Sign and Verify With Different Hash", func(t *testing.T) {
+		publicKey := "./rsa_public_example.pem"
+		privateKey := "./rsa_private_example.pem"
+		hashSign := crypto.SHA256
+		hashVerify := crypto.SHA512
+
+		signature, err := RsaSign(hashSign, data, privateKey)
+		if err != nil {
+			t.Fatalf("RsaSign failed: %v", err)
+		}
+
+		err = RsaVerifySign(hashVerify, data, signature, publicKey)
+		if err == nil {
+			t.Fatalf("RsaVerifySign failed: %v", err)
+		}
+	})
+}

cryptor/gm_example_test.go

@@ -0,0 +1,71 @@
+package cryptor_test
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"github.com/duke-git/lancet/v2/cryptor"
+)
+
+func ExampleSm3() {
+	data := []byte("hello world")
+	hash := cryptor.Sm3(data)
+
+	fmt.Println(hex.EncodeToString(hash))
+
+	// Output:
+	// 44f0061e69fa6fdfc290c494654a05dc0c053da7e5c52b84ef93a9d67d3fff88
+}
+
+func ExampleSm4EcbEncrypt() {
+	key := []byte("1234567890abcdef") // 16 bytes key
+	plaintext := []byte("hello world")
+
+	encrypted := cryptor.Sm4EcbEncrypt(plaintext, key)
+	decrypted := cryptor.Sm4EcbDecrypt(encrypted, key)
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello world
+}
+
+func ExampleSm4CbcEncrypt() {
+	key := []byte("1234567890abcdef") // 16 bytes key
+	plaintext := []byte("hello world")
+
+	encrypted := cryptor.Sm4CbcEncrypt(plaintext, key)
+	decrypted := cryptor.Sm4CbcDecrypt(encrypted, key)
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello world
+}
+
+func ExampleGenerateSm2Key() {
+	// Generate SM2 key pair
+	privateKey, err := cryptor.GenerateSm2Key()
+	if err != nil {
+		return
+	}
+
+	plaintext := []byte("hello world")
+
+	// Encrypt with public key
+	ciphertext, err := cryptor.Sm2Encrypt(&privateKey.PublicKey, plaintext)
+	if err != nil {
+		return
+	}
+
+	// Decrypt with private key
+	decrypted, err := cryptor.Sm2Decrypt(privateKey, ciphertext)
+	if err != nil {
+		return
+	}
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello world
+}

cryptor/gm_sm2.go

@@ -0,0 +1,251 @@
+package cryptor
+
+import (
+	"crypto/elliptic"
+	"crypto/rand"
+	"encoding/binary"
+	"errors"
+	"io"
+	"math/big"
+)
+
+// SM2 implements the Chinese SM2 elliptic curve public key algorithm.
+// SM2 is based on elliptic curve cryptography and provides encryption, decryption, signing and verification.
+//
+// Note: This implementation uses crypto/elliptic package methods (GenerateKey, ScalarBaseMult, ScalarMult, IsOnCurve)
+// which are marked as deprecated in Go 1.20+. These methods still work correctly and are widely used.
+// The //nolint:staticcheck directive suppresses deprecation warnings.
+// A future version may replace these with a custom elliptic curve implementation.
+
+var (
+	sm2P256       *sm2Curve
+	sm2P256Params = &elliptic.CurveParams{Name: "sm2p256v1"}
+)
+
+func init() {
+	// SM2 curve parameters
+	sm2P256Params.P, _ = new(big.Int).SetString("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF", 16)
+	sm2P256Params.N, _ = new(big.Int).SetString("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123", 16)
+	sm2P256Params.B, _ = new(big.Int).SetString("28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93", 16)
+	sm2P256Params.Gx, _ = new(big.Int).SetString("32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7", 16)
+	sm2P256Params.Gy, _ = new(big.Int).SetString("BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0", 16)
+	sm2P256Params.BitSize = 256
+
+	sm2P256 = &sm2Curve{sm2P256Params}
+}
+
+type sm2Curve struct {
+	*elliptic.CurveParams
+}
+
+// Sm2PrivateKey represents an SM2 private key.
+type Sm2PrivateKey struct {
+	D         *big.Int
+	PublicKey Sm2PublicKey
+}
+
+// Sm2PublicKey represents an SM2 public key.
+type Sm2PublicKey struct {
+	X, Y *big.Int
+}
+
+// GenerateSm2Key generates a new SM2 private/public key pair.
+// Play: https://go.dev/play/p/bKYMqRLvIx3
+func GenerateSm2Key() (*Sm2PrivateKey, error) {
+	priv, x, y, err := elliptic.GenerateKey(sm2P256, rand.Reader)
+	if err != nil {
+		return nil, err
+	}
+
+	privateKey := &Sm2PrivateKey{
+		D: new(big.Int).SetBytes(priv),
+		PublicKey: Sm2PublicKey{
+			X: x,
+			Y: y,
+		},
+	}
+
+	return privateKey, nil
+}
+
+// Sm2Encrypt encrypts plaintext using SM2 public key.
+// Returns ciphertext in the format: C1 || C3 || C2
+// C1 = kG (65 bytes in uncompressed format)
+// C3 = Hash(x2 || M || y2) (32 bytes for SM3)
+// C2 = M xor t (same length as plaintext)
+// Play: https://go.dev/play/p/bKYMqRLvIx3
+func Sm2Encrypt(pub *Sm2PublicKey, plaintext []byte) ([]byte, error) {
+	if pub == nil || pub.X == nil || pub.Y == nil {
+		return nil, errors.New("sm2: invalid public key")
+	}
+
+	for {
+		// Generate random k
+		k, err := randFieldElement(sm2P256, rand.Reader)
+		if err != nil {
+			return nil, err
+		}
+
+		// C1 = kG
+		c1x, c1y := sm2P256.ScalarBaseMult(k.Bytes())
+
+		// kP = (x2, y2)
+		x2, y2 := sm2P256.ScalarMult(pub.X, pub.Y, k.Bytes())
+
+		// Derive key using KDF
+		kdfLen := len(plaintext)
+		t := sm2KDF(append(toBytes(sm2P256, x2), toBytes(sm2P256, y2)...), kdfLen)
+
+		// Check if t is all zeros
+		allZero := true
+		for _, b := range t {
+			if b != 0 {
+				allZero = false
+				break
+			}
+		}
+		if allZero {
+			continue
+		}
+
+		// C2 = M xor t
+		c2 := make([]byte, len(plaintext))
+		for i := 0; i < len(plaintext); i++ {
+			c2[i] = plaintext[i] ^ t[i]
+		}
+
+		// C3 = Hash(x2 || M || y2)
+		c3Input := append(toBytes(sm2P256, x2), plaintext...)
+		c3Input = append(c3Input, toBytes(sm2P256, y2)...)
+		c3 := Sm3(c3Input)
+
+		// Return C1 || C3 || C2
+		c1 := sm2MarshalUncompressed(sm2P256, c1x, c1y)
+		result := append(c1, c3...)
+		result = append(result, c2...)
+
+		return result, nil
+	}
+}
+
+// Sm2Decrypt decrypts ciphertext using SM2 private key.
+// Expects ciphertext in the format: C1 || C3 || C2
+// Play: https://go.dev/play/p/bKYMqRLvIx3
+func Sm2Decrypt(priv *Sm2PrivateKey, ciphertext []byte) ([]byte, error) {
+	if priv == nil || priv.D == nil {
+		return nil, errors.New("sm2: invalid private key")
+	}
+
+	// Parse C1 (65 bytes), C3 (32 bytes), C2 (remaining)
+	if len(ciphertext) < 97 {
+		return nil, errors.New("sm2: ciphertext too short")
+	}
+
+	c1 := ciphertext[:65]
+	c3 := ciphertext[65:97]
+	c2 := ciphertext[97:]
+
+	// Parse C1
+	c1x, c1y := sm2UnmarshalUncompressed(sm2P256, c1)
+	if c1x == nil {
+		return nil, errors.New("sm2: invalid C1 point")
+	}
+
+	// Verify C1 is on curve
+	if !sm2P256.IsOnCurve(c1x, c1y) {
+		return nil, errors.New("sm2: C1 not on curve")
+	}
+
+	// dC1 = (x2, y2)
+	x2, y2 := sm2P256.ScalarMult(c1x, c1y, priv.D.Bytes())
+
+	// Derive key using KDF
+	kdfLen := len(c2)
+	t := sm2KDF(append(toBytes(sm2P256, x2), toBytes(sm2P256, y2)...), kdfLen)
+
+	// M = C2 xor t
+	plaintext := make([]byte, len(c2))
+	for i := 0; i < len(c2); i++ {
+		plaintext[i] = c2[i] ^ t[i]
+	}
+
+	// Verify C3 = Hash(x2 || M || y2)
+	u := append(toBytes(sm2P256, x2), plaintext...)
+	u = append(u, toBytes(sm2P256, y2)...)
+	hash := Sm3(u)
+
+	for i := 0; i < len(c3); i++ {
+		if c3[i] != hash[i] {
+			return nil, errors.New("sm2: hash verification failed")
+		}
+	}
+
+	return plaintext, nil
+}
+
+// SM2 KDF (Key Derivation Function)
+func sm2KDF(z []byte, klen int) []byte {
+	limit := (klen + 31) / 32
+	result := make([]byte, 0, limit*32)
+
+	for i := 1; i <= limit; i++ {
+		counter := make([]byte, 4)
+		binary.BigEndian.PutUint32(counter, uint32(i))
+		hash := Sm3(append(z, counter...))
+		result = append(result, hash...)
+	}
+
+	return result[:klen]
+}
+
+func toBytes(curve elliptic.Curve, value *big.Int) []byte {
+	byteLen := (curve.Params().BitSize + 7) / 8
+	buf := make([]byte, byteLen)
+	b := value.Bytes()
+	copy(buf[byteLen-len(b):], b)
+	return buf
+}
+
+func sm2MarshalUncompressed(curve *sm2Curve, x, y *big.Int) []byte {
+	byteLen := (curve.BitSize + 7) / 8
+	ret := make([]byte, 1+2*byteLen)
+	ret[0] = 4 // uncompressed point
+
+	xBytes := x.Bytes()
+	copy(ret[1+byteLen-len(xBytes):], xBytes)
+	yBytes := y.Bytes()
+	copy(ret[1+2*byteLen-len(yBytes):], yBytes)
+
+	return ret
+}
+
+func sm2UnmarshalUncompressed(curve *sm2Curve, data []byte) (*big.Int, *big.Int) {
+	byteLen := (curve.BitSize + 7) / 8
+	if len(data) != 1+2*byteLen {
+		return nil, nil
+	}
+	if data[0] != 4 {
+		return nil, nil
+	}
+
+	x := new(big.Int).SetBytes(data[1 : 1+byteLen])
+	y := new(big.Int).SetBytes(data[1+byteLen:])
+
+	return x, y
+}
+
+func randFieldElement(c elliptic.Curve, rand io.Reader) (*big.Int, error) {
+	params := c.Params()
+	b := make([]byte, params.BitSize/8+8)
+	_, err := io.ReadFull(rand, b)
+	if err != nil {
+		return nil, err
+	}
+
+	k := new(big.Int).SetBytes(b)
+	n := new(big.Int).Sub(params.N, big.NewInt(1))
+	k.Mod(k, n)
+	k.Add(k, big.NewInt(1))
+
+	return k, nil
+}

cryptor/gm_sm3.go

@@ -0,0 +1,211 @@
+package cryptor
+
+import (
+	"encoding/binary"
+	"hash"
+)
+
+// SM3 implements the Chinese SM3 cryptographic hash algorithm.
+// SM3 produces a 256-bit (32-byte) hash value.
+
+const (
+	sm3BlockSize = 64
+	sm3Size      = 32
+	sm3T1        = 0x79cc4519
+	sm3T2        = 0x7a879d8a
+)
+
+var sm3IV = [8]uint32{
+	0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600,
+	0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e,
+}
+
+type sm3Digest struct {
+	h   [8]uint32
+	x   [sm3BlockSize]byte
+	nx  int
+	len uint64
+}
+
+// Sm3 returns a new hash.Hash computing the SM3 checksum.
+// Play: https://go.dev/play/p/zDAQpteAiOc
+func Sm3(data []byte) []byte {
+	h := newSm3()
+	h.Write(data)
+	return h.Sum(nil)
+}
+
+func newSm3() hash.Hash {
+	d := new(sm3Digest)
+	d.Reset()
+	return d
+}
+
+func (d *sm3Digest) Reset() {
+	d.h = sm3IV
+	d.nx = 0
+	d.len = 0
+}
+
+func (d *sm3Digest) Size() int {
+	return sm3Size
+}
+
+func (d *sm3Digest) BlockSize() int {
+	return sm3BlockSize
+}
+
+func (d *sm3Digest) Write(p []byte) (nn int, err error) {
+	nn = len(p)
+	d.len += uint64(nn)
+
+	if d.nx > 0 {
+		n := copy(d.x[d.nx:], p)
+		d.nx += n
+		if d.nx == sm3BlockSize {
+			sm3Block(d, d.x[:])
+			d.nx = 0
+		}
+		p = p[n:]
+	}
+
+	if len(p) >= sm3BlockSize {
+		n := len(p) &^ (sm3BlockSize - 1)
+		sm3Block(d, p[:n])
+		p = p[n:]
+	}
+
+	if len(p) > 0 {
+		d.nx = copy(d.x[:], p)
+	}
+
+	return
+}
+
+func (d *sm3Digest) Sum(in []byte) []byte {
+	d0 := *d
+	hash := d0.checkSum()
+	return append(in, hash[:]...)
+}
+
+func (d *sm3Digest) checkSum() [sm3Size]byte {
+	len := d.len
+	var tmp [64]byte
+	tmp[0] = 0x80
+
+	if len%64 < 56 {
+		d.Write(tmp[0 : 56-len%64])
+	} else {
+		d.Write(tmp[0 : 64+56-len%64])
+	}
+
+	len <<= 3
+	binary.BigEndian.PutUint64(tmp[:], len)
+	d.Write(tmp[0:8])
+
+	if d.nx != 0 {
+		panic("d.nx != 0")
+	}
+
+	var digest [sm3Size]byte
+	for i := 0; i < 8; i++ {
+		binary.BigEndian.PutUint32(digest[i*4:], d.h[i])
+	}
+
+	return digest
+}
+
+func sm3Block(dig *sm3Digest, p []byte) {
+	var w [68]uint32
+	var w1 [64]uint32
+
+	h0, h1, h2, h3, h4, h5, h6, h7 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]
+
+	for len(p) >= sm3BlockSize {
+		for i := 0; i < 16; i++ {
+			j := i * 4
+			w[i] = binary.BigEndian.Uint32(p[j : j+4])
+		}
+
+		for i := 16; i < 68; i++ {
+			w[i] = sm3P1(w[i-16]^w[i-9]^sm3RotateLeft(w[i-3], 15)) ^ sm3RotateLeft(w[i-13], 7) ^ w[i-6]
+		}
+
+		for i := 0; i < 64; i++ {
+			w1[i] = w[i] ^ w[i+4]
+		}
+
+		A, B, C, D, E, F, G, H := h0, h1, h2, h3, h4, h5, h6, h7
+
+		for j := 0; j < 64; j++ {
+			var ss1, ss2, tt1, tt2, t uint32
+
+			if j < 16 {
+				t = sm3T1
+			} else {
+				t = sm3T2
+			}
+
+			ss1 = sm3RotateLeft(sm3RotateLeft(A, 12)+E+sm3RotateLeft(t, uint32(j%32)), 7)
+			ss2 = ss1 ^ sm3RotateLeft(A, 12)
+
+			if j < 16 {
+				tt1 = sm3FF0(A, B, C) + D + ss2 + w1[j]
+				tt2 = sm3GG0(E, F, G) + H + ss1 + w[j]
+			} else {
+				tt1 = sm3FF1(A, B, C) + D + ss2 + w1[j]
+				tt2 = sm3GG1(E, F, G) + H + ss1 + w[j]
+			}
+
+			D = C
+			C = sm3RotateLeft(B, 9)
+			B = A
+			A = tt1
+			H = G
+			G = sm3RotateLeft(F, 19)
+			F = E
+			E = sm3P0(tt2)
+		}
+
+		h0 ^= A
+		h1 ^= B
+		h2 ^= C
+		h3 ^= D
+		h4 ^= E
+		h5 ^= F
+		h6 ^= G
+		h7 ^= H
+
+		p = p[sm3BlockSize:]
+	}
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h0, h1, h2, h3, h4, h5, h6, h7
+}
+
+func sm3RotateLeft(x, n uint32) uint32 {
+	return (x << n) | (x >> (32 - n))
+}
+
+func sm3P0(x uint32) uint32 {
+	return x ^ sm3RotateLeft(x, 9) ^ sm3RotateLeft(x, 17)
+}
+
+func sm3P1(x uint32) uint32 {
+	return x ^ sm3RotateLeft(x, 15) ^ sm3RotateLeft(x, 23)
+}
+
+func sm3FF0(x, y, z uint32) uint32 {
+	return x ^ y ^ z
+}
+
+func sm3FF1(x, y, z uint32) uint32 {
+	return (x & y) | (x & z) | (y & z)
+}
+
+func sm3GG0(x, y, z uint32) uint32 {
+	return x ^ y ^ z
+}
+
+func sm3GG1(x, y, z uint32) uint32 {
+	return (x & y) | (^x & z)
+}

cryptor/gm_sm4.go

@@ -0,0 +1,270 @@
+package cryptor
+
+import (
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/binary"
+	"io"
+)
+
+// SM4 implements the Chinese SM4 block cipher.
+// SM4 is a 128-bit block cipher with 128-bit keys.
+// This implementation uses pre-computed lookup tables for optimal performance.
+
+const sm4BlockSize = 16
+
+// Pre-computed T-transformation lookup tables for performance optimization
+var sm4T1Table [256][4]uint32 // S-box + L1 transformation
+var sm4T2Table [256][4]uint32 // S-box + L2 transformation
+
+var sm4Sbox = [256]byte{
+	0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,
+	0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
+	0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62,
+	0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6,
+	0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8,
+	0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35,
+	0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87,
+	0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e,
+	0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1,
+	0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3,
+	0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f,
+	0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51,
+	0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8,
+	0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0,
+	0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84,
+	0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48,
+}
+
+var sm4FK = [4]uint32{0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc}
+
+var sm4CK = [32]uint32{
+	0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
+	0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
+	0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
+	0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
+	0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,
+	0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
+	0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,
+	0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279,
+}
+
+// 初始化预计算查找表
+func init() {
+	// Pre-compute all possible T1 and T2 transformations
+	for pos := 0; pos < 4; pos++ {
+		for i := 0; i < 256; i++ {
+			// S-box 替换
+			sboxVal := sm4Sbox[i]
+			
+			// 根据字节位置计算偏移
+			shift := uint32((3 - pos) * 8)
+			b := uint32(sboxVal) << shift
+			
+			// L1 变换：b ^ ROL(b,2) ^ ROL(b,10) ^ ROL(b,18) ^ ROL(b,24)
+			sm4T1Table[i][pos] = b ^ sm4RotateLeft(b, 2) ^ sm4RotateLeft(b, 10) ^ sm4RotateLeft(b, 18) ^ sm4RotateLeft(b, 24)
+			
+			// L2 变换：b ^ ROL(b,13) ^ ROL(b,23)
+			sm4T2Table[i][pos] = b ^ sm4RotateLeft(b, 13) ^ sm4RotateLeft(b, 23)
+		}
+	}
+}
+
+type sm4Cipher struct {
+	enc [32]uint32
+	dec [32]uint32
+}
+
+// Sm4EcbEncrypt encrypts data using SM4 in ECB mode.
+// key must be 16 bytes.
+// Play: https://go.dev/play/p/l5IQxYuuaED
+func Sm4EcbEncrypt(data, key []byte) []byte {
+	if len(key) != 16 {
+		panic("sm4: key length must be 16 bytes")
+	}
+
+	c := newSm4Cipher(key)
+	padded := pkcs7Padding(data, sm4BlockSize)
+	encrypted := make([]byte, len(padded))
+
+	for i := 0; i < len(padded); i += sm4BlockSize {
+		c.Encrypt(encrypted[i:i+sm4BlockSize], padded[i:i+sm4BlockSize])
+	}
+
+	return encrypted
+}
+
+// Sm4EcbDecrypt decrypts data using SM4 in ECB mode.
+// key must be 16 bytes.
+// Play: https://go.dev/play/p/l5IQxYuuaED
+func Sm4EcbDecrypt(encrypted, key []byte) []byte {
+	if len(key) != 16 {
+		panic("sm4: key length must be 16 bytes")
+	}
+
+	if len(encrypted)%sm4BlockSize != 0 {
+		panic("sm4: encrypted data length must be multiple of block size")
+	}
+
+	c := newSm4Cipher(key)
+	decrypted := make([]byte, len(encrypted))
+
+	for i := 0; i < len(encrypted); i += sm4BlockSize {
+		c.Decrypt(decrypted[i:i+sm4BlockSize], encrypted[i:i+sm4BlockSize])
+	}
+
+	return pkcs7UnPadding(decrypted)
+}
+
+// Sm4CbcEncrypt encrypts data using SM4 in CBC mode.
+// key must be 16 bytes.
+// Play: https://go.dev/play/p/65Q6iYhLRTa
+func Sm4CbcEncrypt(data, key []byte) []byte {
+	if len(key) != 16 {
+		panic("sm4: key length must be 16 bytes")
+	}
+
+	c := newSm4Cipher(key)
+	padded := pkcs7Padding(data, sm4BlockSize)
+
+	iv := make([]byte, sm4BlockSize)
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic("sm4: failed to generate IV: " + err.Error())
+	}
+
+	encrypted := make([]byte, len(padded))
+	mode := cipher.NewCBCEncrypter(c, iv)
+	mode.CryptBlocks(encrypted, padded)
+
+	return append(iv, encrypted...)
+}
+
+// Sm4CbcDecrypt decrypts data using SM4 in CBC mode.
+// key must be 16 bytes.
+// Play: https://go.dev/play/p/65Q6iYhLRTa
+func Sm4CbcDecrypt(encrypted, key []byte) []byte {
+	if len(key) != 16 {
+		panic("sm4: key length must be 16 bytes")
+	}
+
+	if len(encrypted) < sm4BlockSize {
+		panic("sm4: encrypted data too short")
+	}
+
+	if len(encrypted)%sm4BlockSize != 0 {
+		panic("sm4: encrypted data length must be multiple of block size")
+	}
+
+	c := newSm4Cipher(key)
+	iv := encrypted[:sm4BlockSize]
+	ciphertext := encrypted[sm4BlockSize:]
+
+	decrypted := make([]byte, len(ciphertext))
+	mode := cipher.NewCBCDecrypter(c, iv)
+	mode.CryptBlocks(decrypted, ciphertext)
+
+	return pkcs7UnPadding(decrypted)
+}
+
+func newSm4Cipher(key []byte) *sm4Cipher {
+	c := &sm4Cipher{}
+
+	var mk [4]uint32
+	for i := 0; i < 4; i++ {
+		mk[i] = binary.BigEndian.Uint32(key[i*4 : (i+1)*4])
+	}
+
+	var k [36]uint32
+	k[0] = mk[0] ^ sm4FK[0]
+	k[1] = mk[1] ^ sm4FK[1]
+	k[2] = mk[2] ^ sm4FK[2]
+	k[3] = mk[3] ^ sm4FK[3]
+
+	for i := 0; i < 32; i++ {
+		k[i+4] = k[i] ^ sm4T2Fast(k[i+1]^k[i+2]^k[i+3]^sm4CK[i])
+		c.enc[i] = k[i+4]
+	}
+
+	for i := 0; i < 32; i++ {
+		c.dec[i] = c.enc[31-i]
+	}
+
+	return c
+}
+
+func (c *sm4Cipher) BlockSize() int {
+	return sm4BlockSize
+}
+
+func (c *sm4Cipher) Encrypt(dst, src []byte) {
+	if len(src) < sm4BlockSize {
+		panic("sm4: input not full block")
+	}
+	if len(dst) < sm4BlockSize {
+		panic("sm4: output not full block")
+	}
+
+	// 使用局部变量避免数组分配，提升性能
+	x0 := binary.BigEndian.Uint32(src[0:4])
+	x1 := binary.BigEndian.Uint32(src[4:8])
+	x2 := binary.BigEndian.Uint32(src[8:12])
+	x3 := binary.BigEndian.Uint32(src[12:16])
+
+	// 32 轮加密
+	for i := 0; i < 32; i++ {
+		t := x1 ^ x2 ^ x3 ^ c.enc[i]
+		x0 ^= sm4T1Fast(t)
+		x0, x1, x2, x3 = x1, x2, x3, x0
+	}
+
+	binary.BigEndian.PutUint32(dst[0:4], x3)
+	binary.BigEndian.PutUint32(dst[4:8], x2)
+	binary.BigEndian.PutUint32(dst[8:12], x1)
+	binary.BigEndian.PutUint32(dst[12:16], x0)
+}
+
+func (c *sm4Cipher) Decrypt(dst, src []byte) {
+	if len(src) < sm4BlockSize {
+		panic("sm4: input not full block")
+	}
+	if len(dst) < sm4BlockSize {
+		panic("sm4: output not full block")
+	}
+
+	x0 := binary.BigEndian.Uint32(src[0:4])
+	x1 := binary.BigEndian.Uint32(src[4:8])
+	x2 := binary.BigEndian.Uint32(src[8:12])
+	x3 := binary.BigEndian.Uint32(src[12:16])
+
+	// 32 轮解密
+	for i := 0; i < 32; i++ {
+		t := x1 ^ x2 ^ x3 ^ c.dec[i]
+		x0 ^= sm4T1Fast(t)
+		x0, x1, x2, x3 = x1, x2, x3, x0
+	}
+
+	binary.BigEndian.PutUint32(dst[0:4], x3)
+	binary.BigEndian.PutUint32(dst[4:8], x2)
+	binary.BigEndian.PutUint32(dst[8:12], x1)
+	binary.BigEndian.PutUint32(dst[12:16], x0)
+}
+
+// 使用预计算查找表的快速 T1 变换（用于加密轮函数）
+func sm4T1Fast(a uint32) uint32 {
+	return sm4T1Table[byte(a>>24)][0] ^
+		sm4T1Table[byte(a>>16)][1] ^
+		sm4T1Table[byte(a>>8)][2] ^
+		sm4T1Table[byte(a)][3]
+}
+
+// 使用预计算查找表的快速 T2 变换（用于密钥扩展）
+func sm4T2Fast(a uint32) uint32 {
+	return sm4T2Table[byte(a>>24)][0] ^
+		sm4T2Table[byte(a>>16)][1] ^
+		sm4T2Table[byte(a>>8)][2] ^
+		sm4T2Table[byte(a)][3]
+}
+
+func sm4RotateLeft(x uint32, n uint32) uint32 {
+	return (x << n) | (x >> (32 - n))
+}

cryptor/gm_test.go

@@ -0,0 +1,163 @@
+package cryptor
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestSm3(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSm3")
+
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{
+			input:    "abc",
+			expected: "66c7f0f462eeedd9d1f2d46bdc10e4e24167c4875cf2f7a2297da02b8f4ba8e0",
+		},
+		{
+			input:    "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd",
+			expected: "debe9ff92275b8a138604889c18e5a4d6fdb70e5387e5765293dcba39c0c5732",
+		},
+		{
+			input:    "",
+			expected: "1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b",
+		},
+	}
+
+	for _, tt := range tests {
+		result := Sm3([]byte(tt.input))
+		resultHex := hex.EncodeToString(result)
+		assert.Equal(tt.expected, resultHex)
+	}
+}
+
+func TestSm4EcbEncryptDecrypt(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSm4EcbEncryptDecrypt")
+
+	key := []byte("1234567890abcdef") // 16 bytes
+	plaintext := []byte("Hello, SM4!")
+
+	// Encrypt
+	encrypted := Sm4EcbEncrypt(plaintext, key)
+	assert.IsNotNil(encrypted)
+
+	// Decrypt
+	decrypted := Sm4EcbDecrypt(encrypted, key)
+	assert.Equal(plaintext, decrypted)
+}
+
+func TestSm4CbcEncryptDecrypt(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSm4CbcEncryptDecrypt")
+
+	key := []byte("1234567890abcdef") // 16 bytes
+	plaintext := []byte("Hello, SM4 CBC mode!")
+
+	// Encrypt
+	encrypted := Sm4CbcEncrypt(plaintext, key)
+	assert.IsNotNil(encrypted)
+
+	// Decrypt
+	decrypted := Sm4CbcDecrypt(encrypted, key)
+	assert.Equal(plaintext, decrypted)
+}
+
+func TestSm4EcbWithLongData(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSm4EcbWithLongData")
+
+	key := []byte("1234567890abcdef")
+	plaintext := []byte("This is a longer message that spans multiple blocks for SM4 encryption testing.")
+
+	encrypted := Sm4EcbEncrypt(plaintext, key)
+	decrypted := Sm4EcbDecrypt(encrypted, key)
+
+	assert.Equal(plaintext, decrypted)
+}
+
+func TestSm2EncryptDecrypt(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSm2EncryptDecrypt")
+
+	// Generate key pair
+	privateKey, err := GenerateSm2Key()
+	assert.IsNil(err)
+	assert.IsNotNil(privateKey)
+
+	plaintext := []byte("Hello, SM2!")
+
+	// Encrypt with public key
+	ciphertext, err := Sm2Encrypt(&privateKey.PublicKey, plaintext)
+	assert.IsNil(err)
+	assert.IsNotNil(ciphertext)
+
+	// Decrypt with private key
+	decrypted, err := Sm2Decrypt(privateKey, ciphertext)
+	assert.IsNil(err)
+	assert.Equal(plaintext, decrypted)
+}
+
+func TestSm2WithLongData(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSm2WithLongData")
+
+	privateKey, err := GenerateSm2Key()
+	assert.IsNil(err)
+
+	plaintext := []byte("This is a longer message for SM2 encryption testing. " +
+		"SM2 is an elliptic curve public key cryptography algorithm.")
+
+	ciphertext, err := Sm2Encrypt(&privateKey.PublicKey, plaintext)
+	assert.IsNil(err)
+
+	decrypted, err := Sm2Decrypt(privateKey, ciphertext)
+	assert.IsNil(err)
+	assert.Equal(plaintext, decrypted)
+}
+
+func TestSm4InvalidKeyLength(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSm4InvalidKeyLength")
+
+	defer func() {
+		if r := recover(); r != nil {
+			assert.IsNotNil(r)
+		}
+	}()
+
+	key := []byte("short")
+	plaintext := []byte("test")
+	Sm4EcbEncrypt(plaintext, key) // Should panic
+}
+
+func TestSm2InvalidInput(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSm2InvalidInput")
+
+	// Test with nil public key
+	_, err := Sm2Encrypt(nil, []byte("test"))
+	assert.IsNotNil(err)
+
+	// Test with nil private key
+	_, err = Sm2Decrypt(nil, []byte("test"))
+	assert.IsNotNil(err)
+
+	// Test with invalid ciphertext
+	privateKey, _ := GenerateSm2Key()
+	_, err = Sm2Decrypt(privateKey, []byte("short"))
+	assert.IsNotNil(err)
+}

cryptor/rsa_private.pem

@@ -0,0 +1,51 @@
+-----BEGIN rsa private key-----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=
+-----END rsa private key-----

cryptor/rsa_private_example.pem

@@ -0,0 +1,51 @@
+-----BEGIN rsa private key-----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-----END rsa private key-----

cryptor/rsa_public.pem

@@ -0,0 +1,14 @@
+-----BEGIN rsa public key-----
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA5IqWfYbW1NlTDWE2plFW
+qD6CTquA0Ar/1E66lY8OMtrdpxTmchirmoISWN0BD7r2tV9T/kHs44Sy3raAfkR5
+ixYF5FRkb63FdIAtoynsxS6MEE26fgWuDAa1xwNt+t/uivnpfJk25htpBNkKGT8i
+i0TPPLn1N15hMHenT6PzWVjGjQxWcp4dUA4gXTDuqaeu7Oy7Ku2yP90/ra+cjTV8
+DnBJ9enQhAfu1LivJO3FgmXeuC3uqhhM3t9ZbNy7tvJI5PXDCaS8iesBvCp5carT
+SXWLpFEgvIhXQIsXtxezKAP3gRd8r5JPQI9FZlxyUcyf+Htkn2A4qyKhFElnP1z9
+j0YLFhL/gQMdtNIY7yhSb29PyuCG7noz25swrfxbA7ZVppM0J19JNhlpqmusBKLB
+NqN+KMD8EDli7NLX17S9Dj2pQF9I8fVXPEhkdTb67rr7y3OUANKjh0Opnt3JLoj9
+u1X7BfCeUSR/qq3E8RFPeyxvP1tc5QVqKBG6UPBo8nLQqdzJhUd8a1YEfXIUbdHL
+s2q5WVFu2MDavIp634+fzfcIFRoBtdxf5aCdxLaLocsA/aLLyL1pK6K0rpdrSUtc
+EBMST26qIlU0Ht+SQtaMdE2gyjkMM5RpLh1q/gpow+0j3zu6f5tDsu3qwgjLIx78
+YCTGUuCpsVMzFK4tahYSPNkCAwEAAQ==
+-----END rsa public key-----

cryptor/rsa_public_example.pem

@@ -0,0 +1,14 @@
+-----BEGIN rsa public key-----
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAuzBz+aC+e7Lvny2zYlcy
+AfG6AAtPkxZqJ9JkYkM+0CP87pe0xOXQh4dz9iJekOwAq7FKpasUEUzkTm6Z0PUo
+j/TWY/xpoPNXXzz/5dz3u6r/A5TumJ6BmX/7K/x8FsokIeP+lWaN1l+7uBKK8rgf
+m4AZOXd/plzBkTrnu6lKG/rH9cnr2leKWDqk2jcG6r15r/07MdStpWgt0OBYoHzv
+jLJWmJ08VrnF9PFtWhL939xSAIicFzJ0T9fAdmSSYmg22mKgN1zeWtZndJ/Ejv+5
+YlWmuFJ8YKvwR0+4XIRLX9qsMy7qPTh7zsZhgtKzyb7qvVqDh2pmwekGJcwxGcoC
+LHLqNKf/dD+4vXxgS+f1ObfOcJpDqBajD/U6BXtrZ/p4cvoYnZA383YR/CRG/nJ8
+jIvt2FutT4hsNSd0L6c2mfo5mTnoDOEL3mkreZ4Az+GE57jMw1Ia9jwkM1QQoy0a
++kTiW8BedNqcRnVVGT9/OS/ggyKFwxJ/Xh1DfxZXAuyCBRUJUyVl9YCr2y30zngu
+CdaTTViA9UbrjtcE2bZtnqOMAU2s08F0IiaGLKKMhrxUoXLgngXSX7gomC4aEfcg
+5hf7ft6FA+bXB9DHwGdv/UyrGr88nve5um1OT5kmyOujKpka4QZ5/rU+RznBE0UW
+DcHAyc+Zv+te0DqPUNcAW5ECAwEAAQ==
+-----END rsa public key-----

datastructure/hashmap/hashmap.go

@@ -123,6 +123,25 @@ func (hm *HashMap) Iterate(iteratee func(key, value any)) {
 	}
 }
 
+// FilterByValue returns a filtered HashMap.
+// If any value is not matching the perdicate function then it returns nil
+// otherwise it returns the HashMap with selected values.
+func (hm *HashMap) FilterByValue(perdicate func(value any) bool) *HashMap {
+	var filteredHM *HashMap
+	if hm.size > 0 {
+		for i := 0; i < len(hm.table); i++ {
+			item := hm.table[i]
+			if item != nil && perdicate(item.value) {
+				if filteredHM == nil {
+					filteredHM = NewHashMap()
+				}
+				filteredHM.Put(item.key, item.value)
+			}
+		}
+	}
+	return filteredHM
+}
+
 // Keys returns a slice of the hashmap's keys (random order)
 func (hm *HashMap) Keys() []any {
 	keys := make([]any, int(hm.size))
@@ -168,6 +187,11 @@ func (hm *HashMap) resize() {
 	}
 }
 
+// Size returns current size of Hashmap
+func (hm *HashMap) Size() uint64 {
+	return hm.size
+}
+
 func (hm *HashMap) hash(key any) uint64 {
 	h := fnv.New64a()
 	_, _ = h.Write([]byte(fmt.Sprintf("%v", key)))

datastructure/hashmap/hashmap_test.go

@@ -105,3 +105,24 @@ func TestHashMap_GetOrDefault(t *testing.T) {
 	assert.Equal(1, hm.GetOrDefault("a", 5))
 	assert.Equal(5, hm.GetOrDefault("d", 5))
 }
+
+func TestHashMap_FilterByValue(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestHashMap_FilterByValue")
+
+	hm := NewHashMap()
+
+	hm.Put("a", 1)
+	hm.Put("b", 2)
+	hm.Put("c", 3)
+	hm.Put("d", 4)
+	hm.Put("e", 5)
+	hm.Put("f", 6)
+
+	filteredHM := hm.FilterByValue(func(value any) bool {
+		return value.(int) == 1 || value.(int) == 3
+	})
+
+	assert.Equal(uint64(2), filteredHM.Size())
+}

datastructure/heap/maxheap.go

@@ -7,18 +7,18 @@ package datastructure
 import (
 	"fmt"
 
-	"github.com/duke-git/lancet/v2/lancetconstraints"
+	"github.com/duke-git/lancet/v2/constraints"
 )
 
 // MaxHeap implements a binary max heap
-// type T should implements Compare function in lancetconstraints.Comparator interface.
+// type T should implements Compare function in constraints.Comparator interface.
 type MaxHeap[T any] struct {
 	data       []T
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
 
 // NewMaxHeap returns a MaxHeap instance with the given comparator.
-func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T] {
+func NewMaxHeap[T any](comparator constraints.Comparator) *MaxHeap[T] {
 	return &MaxHeap[T]{
 		data:       make([]T, 0),
 		comparator: comparator,
@@ -26,7 +26,7 @@ func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T] {
 }
 
 // BuildMaxHeap builds a MaxHeap instance with data and given comparator.
-func BuildMaxHeap[T any](data []T, comparator lancetconstraints.Comparator) *MaxHeap[T] {
+func BuildMaxHeap[T any](data []T, comparator constraints.Comparator) *MaxHeap[T] {
 	heap := &MaxHeap[T]{
 		data:       make([]T, 0, len(data)),
 		comparator: comparator,

datastructure/link/doublylink.go

@@ -209,7 +209,7 @@ func (dl *DoublyLink[T]) Size() int {
 
 // Values return slice of all doubly linklist node value
 func (dl *DoublyLink[T]) Values() []T {
-	result := []T{}
+	result := make([]T, 0, dl.length)
 	current := dl.Head
 	for current != nil {
 		result = append(result, current.Value)

datastructure/link/singlylink.go

@@ -212,7 +212,7 @@ func (sl *SinglyLink[T]) Size() int {
 
 // Values return slice of all singly linklist node value
 func (sl *SinglyLink[T]) Values() []T {
-	result := []T{}
+	result := make([]T, 0, sl.length)
 	current := sl.Head
 	for current != nil {
 		result = append(result, current.Value)

datastructure/link/singlylink_test.go

@@ -15,7 +15,6 @@ func TestSinglyLink_InsertAtFirst(t *testing.T) {
 	link.InsertAtHead(1)
 	link.InsertAtHead(2)
 	link.InsertAtHead(3)
-	link.Print()
 
 	expected := []int{3, 2, 1}
 	values := link.Values()
@@ -32,7 +31,6 @@ func TestSinglyLink_InsertAtTail(t *testing.T) {
 	link.InsertAtTail(1)
 	link.InsertAtTail(2)
 	link.InsertAtTail(3)
-	link.Print()
 
 	expected := []int{1, 2, 3}
 	values := link.Values()
@@ -77,7 +75,6 @@ func TestSinglyLink_DeleteAtHead(t *testing.T) {
 	link.InsertAtTail(4)
 
 	link.DeleteAtHead()
-	link.Print()
 
 	expected := []int{2, 3, 4}
 	values := link.Values()

datastructure/list/copyonwritelist.go

@@ -90,6 +90,35 @@ func lastIndexOf[T any](o T, e []T, start int, end int) int {
 	return -1
 }
 
+// LastIndexOfFunc returns the index of the last occurrence of the value in this list satisfying the
+// functional predicate f(T) bool
+// if not found return -1.
+func (l *CopyOnWriteList[T]) LastIndexOfFunc(f func(T) bool) int {
+	index := -1
+	data := l.getList()
+	for i := len(data) - 1; i >= 0; i-- {
+		if f(data[i]) {
+			index = i
+			break
+		}
+	}
+	return index
+}
+
+// IndexOfFunc returns the first index satisfying the functional predicate f(v) bool
+// if not found return -1.
+func (l *CopyOnWriteList[T]) IndexOfFunc(f func(T) bool) int {
+	index := -1
+	data := l.getList()
+	for i, v := range data {
+		if f(v) {
+			index = i
+			break
+		}
+	}
+	return index
+}
+
 // get returns the element at the specified position in this list.
 func get[T any](o []T, index int) *T {
 	return &o[index]

datastructure/list/copyonwritelist_test.go

@@ -1,8 +1,9 @@
 package datastructure
 
 import (
-	"github.com/duke-git/lancet/v2/internal"
 	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
 )
 
 func TestCopyOnWriteList_ValueOf(t *testing.T) {
@@ -233,3 +234,35 @@ func TestCopyOnWriteList_SubList(t *testing.T) {
 	subList = list.SubList(11, 1)
 	assert.Equal([]int{}, subList)
 }
+
+func TestCopyOnWriteListIndexOfFunc(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestIndexOfFunc")
+
+	list := NewCopyOnWriteList([]int{1, 2, 3})
+	i := list.IndexOfFunc(func(a int) bool { return a == 1 })
+	assert.Equal(0, i)
+
+	i = list.IndexOfFunc(func(a int) bool { return a == 4 })
+	assert.Equal(-1, i)
+}
+
+func TestNewCopyOnWriteListLastIndexOfFunc(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestLastIndexOfFunc")
+
+	list := NewCopyOnWriteList([]int{1, 2, 3, 3, 3, 3, 4, 5, 6, 9})
+	i := list.LastIndexOfFunc(func(a int) bool { return a == 3 })
+	assert.Equal(5, i)
+
+	i = list.LastIndexOfFunc(func(a int) bool { return a == 10 })
+	assert.Equal(-1, i)
+
+	i = list.LastIndexOfFunc(func(a int) bool { return a == 4 })
+	assert.Equal(6, i)
+
+	i = list.LastIndexOfFunc(func(a int) bool { return a == 1 })
+	assert.Equal(0, i)
+}

datastructure/optional/optional.go

@@ -0,0 +1,108 @@
+package optional
+
+import (
+	"sync"
+)
+
+// Optional is a type that may or may not contain a non-nil value.
+type Optional[T any] struct {
+	value *T
+	mu    *sync.RWMutex
+}
+
+// Default returns an default Optional instance.
+func Default[T any]() Optional[T] {
+	return Optional[T]{mu: &sync.RWMutex{}}
+}
+
+// Of returns an Optional with a non-nil value.
+func Of[T any](value T) Optional[T] {
+	return Optional[T]{value: &value, mu: &sync.RWMutex{}}
+}
+
+// FromNillable returns an Optional for a given value, which may be nil.
+func FromNillable[T any](value *T) Optional[T] {
+	if value == nil {
+		return Default[T]()
+	}
+	return Optional[T]{value: value, mu: &sync.RWMutex{}}
+}
+
+// IsNotNil checks if there is a value present.
+func (o Optional[T]) IsNotNil() bool {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	return o.value != nil
+}
+
+// IsNil checks if the Optional is nil.
+func (o Optional[T]) IsNil() bool {
+	return !o.IsNotNil()
+}
+
+// IfNotNil performs the given action with the value if a value is not nil.
+func (o Optional[T]) IfNotNil(action func(value T)) {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value != nil {
+		action(*o.value)
+	}
+}
+
+// IfNotNilOrElse performs the action with the value if present, otherwise performs the fallback action.
+func (o Optional[T]) IfNotNilOrElse(action func(value T), fallbackAction func()) {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value != nil {
+		action(*o.value)
+	} else {
+		fallbackAction()
+	}
+}
+
+// Unwarp returns the value if not nil, otherwise panics.
+func (o Optional[T]) Unwarp() T {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value == nil {
+		panic("Optional.Get: no value present")
+	}
+	return *o.value
+}
+
+// OrElse returns the value if is not nil, otherwise returns other.
+func (o Optional[T]) OrElse(other T) T {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value != nil {
+		return *o.value
+	}
+	return other
+}
+
+// OrElseGet returns the value if is not nil, otherwise invokes action and returns the result.
+func (o Optional[T]) OrElseGet(action func() T) T {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value != nil {
+		return *o.value
+	}
+	return action()
+}
+
+// OrElseTrigger returns the value if present, otherwise returns an error.
+func (o Optional[T]) OrElseTrigger(errorHandler func() error) (T, error) {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value == nil {
+		return *new(T), errorHandler()
+	}
+	return *o.value, nil
+}

datastructure/optional/optional_test.go

@@ -0,0 +1,151 @@
+package optional
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestDefault(t *testing.T) {
+	assert := internal.NewAssert(t, "TestEmpty")
+	opt := Default[int]()
+
+	assert.ShouldBeTrue(opt.IsNil())
+}
+
+func TestOf(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOf")
+	value := 42
+	opt := Of(value)
+
+	assert.ShouldBeTrue(opt.IsNotNil())
+	assert.Equal(opt.Unwarp(), value)
+}
+
+func TestFromNillable(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOfNullable")
+	var value *int = nil
+	opt := FromNillable(value)
+
+	assert.ShouldBeFalse(opt.IsNotNil())
+
+	value = new(int)
+	*value = 42
+	opt = FromNillable(value)
+
+	assert.ShouldBeTrue(opt.IsNotNil())
+}
+
+func TestOrElse(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOrElse")
+	optDefault := Default[int]()
+	defaultValue := 100
+
+	val := optDefault.OrElse(defaultValue)
+	assert.Equal(val, defaultValue)
+
+	optWithValue := Of(42)
+	val = optWithValue.OrElse(defaultValue)
+	assert.Equal(val, 42)
+}
+
+func TestOrElseGetHappyPath(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOrElseGetHappyPath")
+	optWithValue := Of(42)
+	action := func() int { return 100 }
+
+	val := optWithValue.OrElseGet(action)
+	assert.Equal(val, 42)
+}
+
+func TestOrElseGet(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOrElseGet")
+	optDefault := Default[int]()
+	action := func() int { return 100 }
+
+	val := optDefault.OrElseGet(action)
+	assert.Equal(val, action())
+}
+
+func TestOrElseTrigger(t *testing.T) {
+	assert := internal.NewAssert(t, "OrElseTrigger")
+	optDefault := Default[int]()
+	_, err := optDefault.OrElseTrigger(func() error { return errors.New("no value") })
+
+	assert.Equal(err.Error(), "no value")
+
+	optWithValue := Of(42)
+	val, err := optWithValue.OrElseTrigger(func() error { return errors.New("no value") })
+
+	assert.IsNil(err)
+	assert.Equal(val, 42)
+}
+
+func TestIfNotNil(t *testing.T) {
+	assert := internal.NewAssert(t, "IfNotNil")
+	called := false
+	action := func(value int) { called = true }
+
+	optDefault := Default[int]()
+	optDefault.IfNotNil(action)
+
+	assert.ShouldBeFalse(called)
+
+	called = false // Reset for next test
+	optWithValue := Of(42)
+	optWithValue.IfNotNil(action)
+
+	assert.ShouldBeTrue(called)
+}
+
+func TestIfNotNilOrElse(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIfNotNilOrElse")
+
+	// Test when value is present
+	calledWithValue := false
+	valueAction := func(value int) { calledWithValue = true }
+	fallbackAction := func() { t.Errorf("Empty action should not be called when value is present") }
+
+	optWithValue := Of(42)
+	optWithValue.IfNotNilOrElse(valueAction, fallbackAction)
+
+	assert.ShouldBeTrue(calledWithValue)
+
+	// Test when value is not present
+	calledWithEmpty := false
+	valueAction = func(value int) { t.Errorf("Value action should not be called when value is not present") }
+	fallbackAction = func() { calledWithEmpty = true }
+
+	optDefault := Default[int]()
+	optDefault.IfNotNilOrElse(valueAction, fallbackAction)
+
+	assert.ShouldBeTrue(calledWithEmpty)
+}
+
+func TestGetWithPanicStandard(t *testing.T) {
+	assert := internal.NewAssert(t, "TestGetWithPanicStandard")
+
+	// Test when value is present
+	optWithValue := Of(42)
+	func() {
+		defer func() {
+			r := recover()
+			assert.IsNil(r)
+		}()
+		val := optWithValue.Unwarp()
+		if val != 42 {
+			t.Errorf("Expected Unwarp to return 42, got %v", val)
+		}
+	}()
+
+	// Test when value is not present
+	optDefault := Default[int]()
+	func() {
+		defer func() {
+			r := recover()
+			assert.IsNotNil(r)
+		}()
+		_ = optDefault.Unwarp()
+	}()
+}

datastructure/queue/arrayqueue.go

@@ -12,7 +12,7 @@ import (
 
 // ArrayQueue implements queue with slice
 type ArrayQueue[T any] struct {
-	items    []T
+	data     []T
 	head     int
 	tail     int
 	capacity int
@@ -21,7 +21,7 @@ type ArrayQueue[T any] struct {
 
 func NewArrayQueue[T any](capacity int) *ArrayQueue[T] {
 	return &ArrayQueue[T]{
-		items:    make([]T, 0, capacity),
+		data:     make([]T, 0, capacity),
 		head:     0,
 		tail:     0,
 		capacity: capacity,
@@ -31,9 +31,9 @@ func NewArrayQueue[T any](capacity int) *ArrayQueue[T] {
 
 // Data return slice of queue data
 func (q *ArrayQueue[T]) Data() []T {
-	items := []T{}
+	items := make([]T, 0, q.tail-q.head)
 	for i := q.head; i < q.tail; i++ {
-		items = append(items, q.items[i])
+		items = append(items, q.data[i])
 	}
 	return items
 }
@@ -55,40 +55,71 @@ func (q *ArrayQueue[T]) IsFull() bool {
 
 // Front return front value of queue
 func (q *ArrayQueue[T]) Front() T {
-	return q.items[0]
+	return q.data[q.head]
 }
 
 // Back return back value of queue
 func (q *ArrayQueue[T]) Back() T {
-	return q.items[q.size-1]
+	return q.data[q.tail-1]
 }
 
 // EnQueue put element into queue
 func (q *ArrayQueue[T]) Enqueue(item T) bool {
-	if q.head == 0 && q.tail == q.capacity {
-		return false
-	} else if q.head != 0 && q.tail == q.capacity {
-		for i := q.head; i < q.tail; i++ {
-			q.items[i-q.head] = q.items[i]
+	if q.tail < q.capacity {
+		q.data = append(q.data, item)
+		// q.tail++
+		q.data[q.tail] = item
+	} else {
+		//upgrade
+		if q.head > 0 {
+			for i := 0; i < q.tail-q.head; i++ {
+				q.data[i] = q.data[i+q.head]
+			}
+			q.tail -= q.head
+			q.head = 0
+		} else {
+			if q.capacity < 65536 {
+				if q.capacity == 0 {
+					q.capacity = 1
+				}
+				q.capacity *= 2
+			} else {
+				q.capacity += 2 ^ 16
+			}
+
+			tmp := make([]T, q.capacity, q.capacity)
+			copy(tmp, q.data)
+			q.data = tmp
 		}
-		q.tail = q.tail - q.head
-		q.head = 0
+
+		q.data[q.tail] = item
 	}
 
-	q.items = append(q.items, item)
 	q.tail++
 	q.size++
+
 	return true
 }
 
 // DeQueue remove head element of queue and return it, if queue is empty, return nil and error
 func (q *ArrayQueue[T]) Dequeue() (T, bool) {
 	var item T
-	if q.head == q.tail {
+	if q.size == 0 {
 		return item, false
 	}
-	item = q.items[q.head]
+
+	item = q.data[q.head]
 	q.head++
+
+	if q.head >= 1024 || q.head*2 > q.tail {
+		q.capacity -= q.head
+		q.tail -= q.head
+		tmp := make([]T, q.capacity, q.capacity)
+		copy(tmp, q.data[q.head:])
+		q.data = tmp
+		q.head = 0
+	}
+
 	q.size--
 	return item, true
 }
@@ -96,7 +127,7 @@ func (q *ArrayQueue[T]) Dequeue() (T, bool) {
 // Clear the queue data
 func (q *ArrayQueue[T]) Clear() {
 	capacity := q.capacity
-	q.items = make([]T, 0, capacity)
+	q.data = make([]T, 0, capacity)
 	q.head = 0
 	q.tail = 0
 	q.size = 0
@@ -105,7 +136,7 @@ func (q *ArrayQueue[T]) Clear() {
 
 // Contain checks if the value is in queue or not
 func (q *ArrayQueue[T]) Contain(value T) bool {
-	for _, v := range q.items {
+	for _, v := range q.data {
 		if reflect.DeepEqual(v, value) {
 			return true
 		}
@@ -117,7 +148,7 @@ func (q *ArrayQueue[T]) Contain(value T) bool {
 func (q *ArrayQueue[T]) Print() {
 	info := "["
 	for i := q.head; i < q.tail; i++ {
-		info += fmt.Sprintf("%+v, ", q.items[i])
+		info += fmt.Sprintf("%+v, ", q.data[i])
 	}
 	info += "]"
 	fmt.Println(info)

datastructure/queue/arrayqueue_test.go

@@ -11,7 +11,7 @@ func TestArrayQueue_Enqueue(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestArrayQueue_Enqueue")
 
-	queue := NewArrayQueue[int](5)
+	queue := NewArrayQueue[int](2)
 	queue.Enqueue(1)
 	queue.Enqueue(2)
 	queue.Enqueue(3)

datastructure/queue/linkedqueue.go

@@ -27,7 +27,7 @@ func NewLinkedQueue[T any]() *LinkedQueue[T] {
 
 // Data return slice of queue data
 func (q *LinkedQueue[T]) Data() []T {
-	res := []T{}
+	res := make([]T, 0, q.length)
 	current := q.head
 
 	for current != nil {

datastructure/queue/priorityqueue.go

@@ -8,20 +8,20 @@ package datastructure
 import (
 	"errors"
 
-	"github.com/duke-git/lancet/v2/lancetconstraints"
+	"github.com/duke-git/lancet/v2/constraints"
 )
 
 // PriorityQueue is a priority queue implemented by binary heap tree
-// type T should implements Compare function in lancetconstraints.Comparator interface.
+// type T should implements Compare function in constraints.Comparator interface.
 type PriorityQueue[T any] struct {
 	items      []T
 	size       int
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
 
 // NewPriorityQueue return a pointer of PriorityQueue
 // param `comparator` is used to compare values in the queue
-func NewPriorityQueue[T any](capacity int, comparator lancetconstraints.Comparator) *PriorityQueue[T] {
+func NewPriorityQueue[T any](capacity int, comparator constraints.Comparator) *PriorityQueue[T] {
 	return &PriorityQueue[T]{
 		items:      make([]T, capacity+1),
 		size:       0,

datastructure/set/set.go

@@ -4,19 +4,21 @@
 // Package datastructure contains some data structure. Set is a data container, like slice, but element of set is not duplicate.
 package datastructure
 
+import "sort"
+
 // Set is a data container, like slice, but element of set is not duplicate.
 type Set[T comparable] map[T]struct{}
 
-// NewSet return a instance of set
-func NewSet[T comparable](items ...T) Set[T] {
-	set := make(Set[T])
+// New create a instance of set from given values.
+func New[T comparable](items ...T) Set[T] {
+	set := make(Set[T], len(items))
 	set.Add(items...)
 	return set
 }
 
-// NewSetFromSlice create a set from slice
-func NewSetFromSlice[T comparable](items []T) Set[T] {
-	set := make(Set[T])
+// FromSlice create a set from given slice.
+func FromSlice[T comparable](items []T) Set[T] {
+	set := make(Set[T], len(items))
 	for _, item := range items {
 		set.Add(item)
 	}
@@ -77,8 +79,7 @@ func (s Set[T]) ContainAll(other Set[T]) bool {
 
 // Clone return a copy of set
 func (s Set[T]) Clone() Set[T] {
-	set := NewSet[T]()
-	set.Add(s.Values()...)
+	set := FromSlice(s.ToSlice())
 	return set
 }
 
@@ -116,14 +117,11 @@ func (s Set[T]) Size() int {
 }
 
 // Values return all values of set
+// Deprecated: Values function is deprecated and will be removed in future versions. Please use ToSlice() function instead.
+//
+// The ToSlice() function provides the same functionality as Values and returns a slice containing all values of the set.
 func (s Set[T]) Values() []T {
-	result := make([]T, 0, len(s))
-
-	s.Iterate(func(value T) {
-		result = append(result, value)
-	})
-
-	return result
+	return s.ToSlice()
 }
 
 // Union creates a new set contain all element of set s and other
@@ -135,7 +133,7 @@ func (s Set[T]) Union(other Set[T]) Set[T] {
 
 // Intersection creates a new set whose element both be contained in set s and other
 func (s Set[T]) Intersection(other Set[T]) Set[T] {
-	set := NewSet[T]()
+	set := New[T]()
 	s.Iterate(func(value T) {
 		if other.Contain(value) {
 			set.Add(value)
@@ -147,7 +145,7 @@ func (s Set[T]) Intersection(other Set[T]) Set[T] {
 
 // SymmetricDifference creates a new set whose element is in set1 or set2, but not in both sets
 func (s Set[T]) SymmetricDifference(other Set[T]) Set[T] {
-	set := NewSet[T]()
+	set := New[T]()
 	s.Iterate(func(value T) {
 		if !other.Contain(value) {
 			set.Add(value)
@@ -163,9 +161,9 @@ func (s Set[T]) SymmetricDifference(other Set[T]) Set[T] {
 	return set
 }
 
-// Minus creates an set of whose element in origin set but not in compared set
+// Minus creates a set of whose element in origin set but not in compared set
 func (s Set[T]) Minus(comparedSet Set[T]) Set[T] {
-	set := NewSet[T]()
+	set := New[T]()
 
 	s.Iterate(func(value T) {
 		if !comparedSet.Contain(value) {
@@ -189,11 +187,34 @@ func (s Set[T]) EachWithBreak(iteratee func(item T) bool) {
 // Pop delete the top element of set then return it, if set is empty, return nil-value of T and false.
 func (s Set[T]) Pop() (v T, ok bool) {
 	if len(s) > 0 {
-		items := s.Values()
-		item := items[len(s)-1]
-		delete(s, item)
-		return item, true
+		for item := range s {
+			v = item
+			delete(s, item)
+			return v, true
+		}
 	}
 
 	return v, false
 }
+
+// ToSlice returns a slice containing all values of the set.
+func (s Set[T]) ToSlice() []T {
+	if s.IsEmpty() {
+		return []T{}
+	}
+	result := make([]T, 0, s.Size())
+	s.Iterate(func(value T) {
+		result = append(result, value)
+	})
+
+	return result
+}
+
+// ToSortedSlice returns a sorted slice containing all values of the set.
+func (s Set[T]) ToSortedSlice(less func(v1, v2 T) bool) []T {
+	result := s.ToSlice()
+	sort.Slice(result, func(i, j int) bool {
+		return less(result[i], result[j])
+	})
+	return result
+}

datastructure/set/set_test.go

@@ -1,23 +1,25 @@
 package datastructure
 
 import (
+	"reflect"
+	"sort"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
 )
 
-func TestSet_NewSetFromSlice(t *testing.T) {
+func TestSet_FromSlice(t *testing.T) {
 	t.Parallel()
 
-	assert := internal.NewAssert(t, "TestSet_NewSetFromSlice")
+	assert := internal.NewAssert(t, "TestSet_FromSlice")
 
-	s1 := NewSetFromSlice([]int{1, 2, 2, 3})
+	s1 := FromSlice([]int{1, 2, 2, 3})
 	assert.Equal(3, s1.Size())
 	assert.Equal(true, s1.Contain(1))
 	assert.Equal(true, s1.Contain(2))
 	assert.Equal(true, s1.Contain(3))
 
-	s2 := NewSetFromSlice([]int{})
+	s2 := FromSlice([]int{})
 	assert.Equal(0, s2.Size())
 }
 
@@ -26,10 +28,10 @@ func TestSet_Add(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Add")
 
-	set := NewSet[int]()
+	set := New[int]()
 	set.Add(1, 2, 3)
 
-	cmpSet := NewSet(1, 2, 3)
+	cmpSet := New(1, 2, 3)
 
 	assert.Equal(true, set.Equal(cmpSet))
 }
@@ -39,12 +41,12 @@ func TestSet_AddIfNotExist(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_AddIfNotExist")
 
-	set := NewSet[int]()
+	set := New[int]()
 	set.Add(1, 2, 3)
 
 	assert.Equal(false, set.AddIfNotExist(1))
 	assert.Equal(true, set.AddIfNotExist(4))
-	assert.Equal(NewSet(1, 2, 3, 4), set)
+	assert.Equal(New(1, 2, 3, 4), set)
 }
 
 func TestSet_AddIfNotExistBy(t *testing.T) {
@@ -52,7 +54,7 @@ func TestSet_AddIfNotExistBy(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_AddIfNotExistBy")
 
-	set := NewSet[int]()
+	set := New[int]()
 	set.Add(1, 2)
 
 	ok := set.AddIfNotExistBy(3, func(val int) bool {
@@ -75,7 +77,7 @@ func TestSet_Contain(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Contain")
 
-	set := NewSet[int]()
+	set := New[int]()
 	set.Add(1, 2, 3)
 
 	assert.Equal(true, set.Contain(1))
@@ -87,9 +89,9 @@ func TestSet_ContainAll(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_ContainAll")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(1, 2)
-	set3 := NewSet(1, 2, 3, 4)
+	set1 := New(1, 2, 3)
+	set2 := New(1, 2)
+	set3 := New(1, 2, 3, 4)
 
 	assert.Equal(true, set1.ContainAll(set2))
 	assert.Equal(false, set1.ContainAll(set3))
@@ -100,7 +102,7 @@ func TestSet_Clone(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Clone")
 
-	set1 := NewSet(1, 2, 3)
+	set1 := New(1, 2, 3)
 	set2 := set1.Clone()
 
 	assert.Equal(true, set1.Size() == set2.Size())
@@ -112,11 +114,11 @@ func TestSet_Delete(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Delete")
 
-	set := NewSet[int]()
+	set := New[int]()
 	set.Add(1, 2, 3)
 	set.Delete(3)
 
-	assert.Equal(true, set.Equal(NewSet(1, 2)))
+	assert.Equal(true, set.Equal(New(1, 2)))
 }
 
 func TestSet_Equal(t *testing.T) {
@@ -124,9 +126,9 @@ func TestSet_Equal(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Equal")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(1, 2, 3)
-	set3 := NewSet(1, 2, 3, 4)
+	set1 := New(1, 2, 3)
+	set2 := New(1, 2, 3)
+	set3 := New(1, 2, 3, 4)
 
 	assert.Equal(true, set1.Equal(set2))
 	assert.Equal(false, set1.Equal(set3))
@@ -137,7 +139,7 @@ func TestSet_Iterate(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Iterate")
 
-	set := NewSet(1, 2, 3)
+	set := New(1, 2, 3)
 	arr := []int{}
 	set.Iterate(func(value int) {
 		arr = append(arr, value)
@@ -151,7 +153,7 @@ func TestSet_IsEmpty(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_IsEmpty")
 
-	set := NewSet[int]()
+	set := New[int]()
 	assert.Equal(true, set.IsEmpty())
 }
 
@@ -160,7 +162,7 @@ func TestSet_Size(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Size")
 
-	set := NewSet(1, 2, 3)
+	set := New(1, 2, 3)
 	assert.Equal(3, set.Size())
 }
 
@@ -169,7 +171,7 @@ func TestSet_Values(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Values")
 
-	set := NewSet(1, 2, 3)
+	set := New(1, 2, 3)
 	values := set.Values()
 
 	assert.Equal(3, len(values))
@@ -180,12 +182,12 @@ func TestSet_Union(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Union")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
 
 	unionSet := set1.Union(set2)
 
-	assert.Equal(NewSet(1, 2, 3, 4, 5), unionSet)
+	assert.Equal(New(1, 2, 3, 4, 5), unionSet)
 }
 
 func TestSet_Intersection(t *testing.T) {
@@ -193,11 +195,11 @@ func TestSet_Intersection(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Intersection")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
 	intersectionSet := set1.Intersection(set2)
 
-	assert.Equal(NewSet(2, 3), intersectionSet)
+	assert.Equal(New(2, 3), intersectionSet)
 }
 
 func TestSet_SymmetricDifference(t *testing.T) {
@@ -205,10 +207,10 @@ func TestSet_SymmetricDifference(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_SymmetricDifference")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
 
-	assert.Equal(NewSet(1, 4, 5), set1.SymmetricDifference(set2))
+	assert.Equal(New(1, 4, 5), set1.SymmetricDifference(set2))
 }
 
 func TestSet_Minus(t *testing.T) {
@@ -216,16 +218,16 @@ func TestSet_Minus(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Minus")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
-	set3 := NewSet(2, 3)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
+	set3 := New(2, 3)
 
-	assert.Equal(NewSet(1), set1.Minus(set2))
-	assert.Equal(NewSet(4, 5), set2.Minus(set3))
+	assert.Equal(New(1), set1.Minus(set2))
+	assert.Equal(New(4, 5), set2.Minus(set3))
 }
 
 func TestEachWithBreak(t *testing.T) {
-	// s := NewSet(1, 2, 3, 4, 5)
+	// s := New(1, 2, 3, 4, 5)
 
 	// var sum int
 
@@ -241,22 +243,93 @@ func TestEachWithBreak(t *testing.T) {
 	// assert.Equal(6, sum)
 }
 
-// func TestPop(t *testing.T) {
-// 	assert := internal.NewAssert(t, "TestPop")
+func TestPop(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestSet_Pop")
 
-// 	s := NewSet[int]()
+	s := New[int]()
 
-// 	val, ok := s.Pop()
-// 	assert.Equal(0, val)
-// 	assert.Equal(false, ok)
+	val, ok := s.Pop()
+	assert.Equal(0, val)
+	assert.Equal(false, ok)
 
-// 	s.Add(1)
-// 	s.Add(2)
-// 	s.Add(3)
+	s = New(1, 2, 3, 4, 5)
+	sl := s.ToSlice()
 
-// 	// s = NewSet(1, 2, 3, 4, 5)
+	val, ok = s.Pop()
+	assert.Equal(false, s.Contain(val))
+	assert.Equal(true, ok)
+	assert.Equal(len(sl)-1, s.Size())
 
-// 	val, ok = s.Pop()
-// 	assert.Equal(3, val)
-// 	assert.Equal(true, ok)
-// }
+	var found bool
+
+	for _, v := range sl {
+		if v == val {
+			found = true
+		}
+	}
+
+	assert.Equal(true, found)
+}
+
+func TestSet_ToSlice(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSet_ToSlice")
+
+	set1 := FromSlice([]int{6, 3, 1, 5, 6, 7, 1})
+	set2 := FromSlice([]float64{-2.65, 4.25, 4.25 - 3.14, 0})
+	set3 := New[string]()
+
+	slice1 := set1.ToSlice()
+	slice2 := set2.ToSlice()
+	slice3 := set3.ToSlice()
+
+	sort.Ints(slice1)
+	sort.Float64s(slice2)
+
+	assert.Equal(5, len(slice1))
+	assert.Equal(4, len(slice2))
+	assert.Equal(0, len(slice3))
+
+	assert.Equal(true, reflect.DeepEqual(slice1, []int{1, 3, 5, 6, 7}))
+	assert.Equal(true, reflect.DeepEqual(slice2, []float64{-2.65, 0, 1.11, 4.25}))
+	assert.Equal("[]string", reflect.TypeOf(slice3).String())
+}
+
+func TestSet_ToSortedSlice(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSet_ToSortedSlice")
+
+	set1 := FromSlice([]int{6, 3, 1, 5, 6, 7, 1})
+	set2 := FromSlice([]float64{-2.65, 4.25, 4.25 - 3.14, 0})
+
+	type Person struct {
+		Name string
+		Age  int
+	}
+	set3 := FromSlice([]Person{{"Tom", 20}, {"Jerry", 18}, {"Spike", 25}})
+
+	slice1 := set1.ToSortedSlice(func(v1, v2 int) bool {
+		return v1 < v2
+	})
+	slice2 := set2.ToSortedSlice(func(v1, v2 float64) bool {
+		return v2 < v1
+	})
+	slice3 := set3.ToSortedSlice(func(v1, v2 Person) bool {
+		return v1.Age < v2.Age
+	})
+
+	assert.Equal(5, len(slice1))
+	assert.Equal(4, len(slice2))
+	assert.Equal(3, len(slice3))
+
+	assert.Equal(true, reflect.DeepEqual(slice1, []int{1, 3, 5, 6, 7}))
+	assert.Equal(true, reflect.DeepEqual(slice2, []float64{4.25, 1.11, 0, -2.65}))
+	assert.Equal(true, reflect.DeepEqual(slice3, []Person{
+		{"Jerry", 18},
+		{"Tom", 20},
+		{"Spike", 25},
+	}))
+}

datastructure/stack/linkedstack.go

@@ -24,7 +24,7 @@ func NewLinkedStack[T any]() *LinkedStack[T] {
 
 // Data return stack data
 func (s *LinkedStack[T]) Data() []T {
-	res := []T{}
+	res := make([]T, 0, s.length)
 	current := s.top
 
 	for current != nil {

datastructure/tree/bstree.go

@@ -7,22 +7,22 @@ package datastructure
 import (
 	"math"
 
+	"github.com/duke-git/lancet/v2/constraints"
 	"github.com/duke-git/lancet/v2/datastructure"
-	"github.com/duke-git/lancet/v2/lancetconstraints"
 )
 
 // BSTree is a binary search tree data structure in which each node has at most two children,
 // which are referred to as the left child and the right child.
 // In BSTree: leftNode < rootNode < rightNode
-// type T should implements Compare function in lancetconstraints.Comparator interface.
+// type T should implements Compare function in constraints.Comparator interface.
 type BSTree[T any] struct {
 	root       *datastructure.TreeNode[T]
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
 
 // NewBSTree create a BSTree pointer
 // param `comparator` is used to compare values in the tree
-func NewBSTree[T any](rootData T, comparator lancetconstraints.Comparator) *BSTree[T] {
+func NewBSTree[T any](rootData T, comparator constraints.Comparator) *BSTree[T] {
 	root := datastructure.NewTreeNode(rootData)
 	return &BSTree[T]{root, comparator}
 }
@@ -87,7 +87,7 @@ func (t *BSTree[T]) HasSubTree(subTree *BSTree[T]) bool {
 }
 
 func hasSubTree[T any](superTreeRoot, subTreeRoot *datastructure.TreeNode[T],
-	comparator lancetconstraints.Comparator) bool {
+	comparator constraints.Comparator) bool {
 	result := false
 
 	if superTreeRoot != nil && subTreeRoot != nil {

datastructure/tree/bstree_test.go

@@ -100,12 +100,6 @@ func TestBSTree_Delete(t *testing.T) {
 
 	acturl1 := bstree.InOrderTraverse()
 	assert.Equal([]int{2, 5, 6, 7}, acturl1)
-
-	//todo
-	// bstree.DeletetNode(6, comparator)
-	// bstree.Print()
-	// acturl2 := bstree.InOrderTraverse()
-	// assert.Equal([]int{2, 5, 7}, acturl2)
 }
 
 func TestBSTree_Depth(t *testing.T) {

datastructure/tree/tree_internal.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"math"
 
+	"github.com/duke-git/lancet/v2/constraints"
 	"github.com/duke-git/lancet/v2/datastructure"
-	"github.com/duke-git/lancet/v2/lancetconstraints"
 )
 
 func preOrderTraverse[T any](node *datastructure.TreeNode[T]) []T {
@@ -86,7 +86,7 @@ func levelOrderTraverse[T any](root *datastructure.TreeNode[T], traversal *[]T)
 	}
 }
 
-func insertTreeNode[T any](rootNode, newNode *datastructure.TreeNode[T], comparator lancetconstraints.Comparator) {
+func insertTreeNode[T any](rootNode, newNode *datastructure.TreeNode[T], comparator constraints.Comparator) {
 	if comparator.Compare(newNode.Value, rootNode.Value) == -1 {
 		if rootNode.Left == nil {
 			rootNode.Left = newNode
@@ -103,7 +103,7 @@ func insertTreeNode[T any](rootNode, newNode *datastructure.TreeNode[T], compara
 }
 
 // todo, delete root node failed
-func deleteTreeNode[T any](node *datastructure.TreeNode[T], data T, comparator lancetconstraints.Comparator) *datastructure.TreeNode[T] {
+func deleteTreeNode[T any](node *datastructure.TreeNode[T], data T, comparator constraints.Comparator) *datastructure.TreeNode[T] {
 	if node == nil {
 		return nil
 	}
@@ -147,7 +147,7 @@ func printTreeNodes[T any](nodes []*datastructure.TreeNode[T], level, maxLevel i
 
 	printSpaces(firstSpaces)
 
-	newNodes := []*datastructure.TreeNode[T]{}
+	newNodes := make([]*datastructure.TreeNode[T], 0, len(nodes)*2)
 	for _, node := range nodes {
 		if node != nil {
 			fmt.Printf("%v", node.Value)
@@ -216,7 +216,7 @@ func calculateDepth[T any](node *datastructure.TreeNode[T], depth int) int {
 	return max(calculateDepth(node.Left, depth+1), calculateDepth(node.Right, depth+1))
 }
 
-func isSubTree[T any](superTreeRoot, subTreeRoot *datastructure.TreeNode[T], comparator lancetconstraints.Comparator) bool {
+func isSubTree[T any](superTreeRoot, subTreeRoot *datastructure.TreeNode[T], comparator constraints.Comparator) bool {
 	if subTreeRoot == nil {
 		return true
 	}

datetime/datetime.go

@@ -30,6 +30,7 @@ package datetime
 
 import (
 	"fmt"
+	"runtime"
 	"strings"
 	"time"
 )
@@ -63,28 +64,95 @@ func init() {
 	}
 }
 
-// AddMinute add or sub minute to the time.
+// AddMinute add or sub minutes to the time.
 // Play: https://go.dev/play/p/nT1heB1KUUK
-func AddMinute(t time.Time, minute int64) time.Time {
-	return t.Add(time.Minute * time.Duration(minute))
+func AddMinute(t time.Time, minutes int64) time.Time {
+	return t.Add(time.Minute * time.Duration(minutes))
 }
 
-// AddHour add or sub hour to the time.
+// AddHour add or sub hours to the time.
 // Play: https://go.dev/play/p/rcMjd7OCsi5
-func AddHour(t time.Time, hour int64) time.Time {
-	return t.Add(time.Hour * time.Duration(hour))
+func AddHour(t time.Time, hours int64) time.Time {
+	return t.Add(time.Hour * time.Duration(hours))
 }
 
-// AddDay add or sub day to the time.
+// AddDay add or sub days to the time.
 // Play: https://go.dev/play/p/dIGbs_uTdFa
-func AddDay(t time.Time, day int64) time.Time {
-	return t.Add(24 * time.Hour * time.Duration(day))
+func AddDay(t time.Time, days int64) time.Time {
+	return t.Add(24 * time.Hour * time.Duration(days))
+}
+
+// AddWeek add or sub weeks to the time.
+// play: https://go.dev/play/p/M9TqdMiaA2p
+func AddWeek(t time.Time, weeks int64) time.Time {
+	return t.Add(7 * 24 * time.Hour * time.Duration(weeks))
+}
+
+// AddMonth add or sub months to the time.
+// Play: https://go.dev/play/p/DLoiOnpLvsN
+func AddMonth(t time.Time, months int64) time.Time {
+	return t.AddDate(0, int(months), 0)
 }
 
 // AddYear add or sub year to the time.
 // Play: https://go.dev/play/p/MqW2ujnBx10
 func AddYear(t time.Time, year int64) time.Time {
-	return t.Add(365 * 24 * time.Hour * time.Duration(year))
+	return t.AddDate(int(year), 0, 0)
+}
+
+// AddDaySafe add or sub days to the time and ensure that the returned date does not exceed the valid date of the target year and month.
+// Play: https://go.dev/play/p/JTohZFpoDJ3
+func AddDaySafe(t time.Time, days int) time.Time {
+	t = t.AddDate(0, 0, days)
+	year, month, day := t.Date()
+
+	lastDayOfMonth := time.Date(year, month+1, 0, 0, 0, 0, 0, t.Location()).Day()
+
+	if day > lastDayOfMonth {
+		t = time.Date(year, month, lastDayOfMonth, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
+	}
+
+	return t
+}
+
+// AddMonthSafe add or sub months to the time and ensure that the returned date does not exceed the valid date of the target year and month.
+// Play: https://go.dev/play/p/KLw0lo6mbVW
+func AddMonthSafe(t time.Time, months int) time.Time {
+	year := t.Year()
+	month := int(t.Month()) + months
+
+	for month > 12 {
+		month -= 12
+		year++
+	}
+	for month < 1 {
+		month += 12
+		year--
+	}
+
+	daysInMonth := time.Date(year, time.Month(month+1), 0, 0, 0, 0, 0, time.UTC).Day()
+
+	day := t.Day()
+	if day > daysInMonth {
+		day = daysInMonth
+	}
+
+	return time.Date(year, time.Month(month), day, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
+}
+
+// AddYearSafe add or sub years to the time and ensure that the returned date does not exceed the valid date of the target year and month.
+// Play: https://go.dev/play/p/KVGXWZZ54ZH
+func AddYearSafe(t time.Time, years int) time.Time {
+	year, month, day := t.Date()
+	year += years
+
+	if month == time.February && day == 29 {
+		if !IsLeapYear(year) {
+			day = 28
+		}
+	}
+
+	return time.Date(year, month, day, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
 }
 
 // GetNowDate return format yyyy-mm-dd of current date.
@@ -212,13 +280,9 @@ func EndOfDay(t time.Time) time.Time {
 }
 
 // BeginOfWeek return beginning week, default week begin from Sunday.
-// Play: https://go.dev/play/p/ynjoJPz7VNV
-func BeginOfWeek(t time.Time, beginFrom ...time.Weekday) time.Time {
-	var beginFromWeekday = time.Sunday
-	if len(beginFrom) > 0 {
-		beginFromWeekday = beginFrom[0]
-	}
-	y, m, d := t.AddDate(0, 0, int(beginFromWeekday-t.Weekday())).Date()
+// Play: https://go.dev/play/p/DCHdcL6gnfV
+func BeginOfWeek(t time.Time, beginFrom time.Weekday) time.Time {
+	y, m, d := t.AddDate(0, 0, int(beginFrom-t.Weekday())).Date()
 	beginOfWeek := time.Date(y, m, d, 0, 0, 0, 0, t.Location())
 	if beginOfWeek.After(t) {
 		return beginOfWeek.AddDate(0, 0, -7)
@@ -227,13 +291,9 @@ func BeginOfWeek(t time.Time, beginFrom ...time.Weekday) time.Time {
 }
 
 // EndOfWeek return end week time, default week end with Saturday.
-// Play: https://go.dev/play/p/i08qKXD9flf
-func EndOfWeek(t time.Time, endWith ...time.Weekday) time.Time {
-	var endWithWeekday = time.Saturday
-	if len(endWith) > 0 {
-		endWithWeekday = endWith[0]
-	}
-	y, m, d := t.AddDate(0, 0, int(endWithWeekday-t.Weekday())).Date()
+// Play: https://go.dev/play/p/mGSA162YgX9
+func EndOfWeek(t time.Time, endWith time.Weekday) time.Time {
+	y, m, d := t.AddDate(0, 0, int(endWith-t.Weekday())).Date()
 	var endWithWeek = time.Date(y, m, d, 23, 59, 59, int(time.Second-time.Nanosecond), t.Location())
 	if endWithWeek.Before(t) {
 		endWithWeek = endWithWeek.AddDate(0, 0, 7)
@@ -381,3 +441,111 @@ func TimestampNano(timezone ...string) int64 {
 
 	return t.UnixNano()
 }
+
+// TrackFuncTime track the time of function execution.
+// call it at top of the func like `defer TrackFuncTime(time.Now())()`
+// Play: https://go.dev/play/p/QBSEdfXHPTp
+func TrackFuncTime(pre time.Time) func() {
+	callerName := getCallerName()
+	return func() {
+		elapsed := time.Since(pre)
+		fmt.Printf("Function %s execution time:\t %v", callerName, elapsed)
+	}
+}
+
+func getCallerName() string {
+	pc, _, _, ok := runtime.Caller(2)
+	if !ok {
+		return "Unknown"
+	}
+	fn := runtime.FuncForPC(pc)
+	if fn == nil {
+		return "Unknown"
+	}
+
+	fullName := fn.Name()
+	if lastDot := strings.LastIndex(fullName, "."); lastDot != -1 {
+		return fullName[lastDot+1:]
+	}
+
+	return fullName
+}
+
+// DaysBetween returns the number of days between two times.
+// Play: https://go.dev/play/p/qD6qGb3TbOy
+func DaysBetween(start, end time.Time) int {
+	duration := end.Sub(start)
+	days := int(duration.Hours() / 24)
+
+	return days
+}
+
+// GenerateDatetimesBetween returns a slice of strings between two times.
+// layout: the format of the datetime string
+// interval: the interval between two datetimes
+// Play: https://go.dev/play/p/6kHBpAxD9ZC
+func GenerateDatetimesBetween(start, end time.Time, layout string, interval string) ([]string, error) {
+	var result []string
+
+	if start.After(end) {
+		start, end = end, start
+	}
+
+	duration, err := time.ParseDuration(interval)
+	if err != nil {
+		return nil, err
+	}
+
+	for current := start; !current.After(end); current = current.Add(duration) {
+		result = append(result, current.Format(layout))
+	}
+
+	return result, nil
+}
+
+// Min returns the earliest time among the given times.
+// Play: https://go.dev/play/p/MCIDvHNOGGb
+func Min(t1 time.Time, times ...time.Time) time.Time {
+	minTime := t1
+
+	for _, t := range times {
+		if t.Before(minTime) {
+			minTime = t
+		}
+	}
+
+	return minTime
+}
+
+// Max returns the latest time among the given times.
+// Play: https://go.dev/play/p/9m6JMk1LB7-
+func Max(t1 time.Time, times ...time.Time) time.Time {
+	maxTime := t1
+
+	for _, t := range times {
+		if t.After(maxTime) {
+			maxTime = t
+		}
+	}
+
+	return maxTime
+}
+
+// MaxMin returns the latest and earliest time among the given times.
+// Play: https://go.dev/play/p/rbW51cDtM_2
+func MaxMin(t1 time.Time, times ...time.Time) (maxTime time.Time, minTime time.Time) {
+	maxTime = t1
+	minTime = t1
+
+	for _, t := range times {
+		if t.Before(minTime) {
+			minTime = t
+		}
+
+		if t.After(maxTime) {
+			maxTime = t
+		}
+	}
+
+	return maxTime, minTime
+}

datetime/datetime_example_test.go

@@ -7,71 +7,141 @@ import (
 )
 
 func ExampleAddDay() {
-	now := time.Now()
+	date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")
 
-	tomorrow := AddDay(now, 1)
-	diff1 := tomorrow.Sub(now)
+	after1Day := AddDay(date, 1)
+	before1Day := AddDay(date, -1)
 
-	yesterday := AddDay(now, -1)
-	diff2 := yesterday.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
+	fmt.Println(after1Day.Format("2006-01-02 15:04:05"))
+	fmt.Println(before1Day.Format("2006-01-02 15:04:05"))
 
 	// Output:
-	// 24h0m0s
-	// -24h0m0s
+	// 2021-01-02 00:00:00
+	// 2020-12-31 00:00:00
+}
+
+func ExampleAddWeek() {
+	date, _ := time.Parse("2006-01-02", "2021-01-01")
+
+	after2Weeks := AddWeek(date, 2)
+	before2Weeks := AddWeek(date, -2)
+
+	fmt.Println(after2Weeks.Format("2006-01-02"))
+	fmt.Println(before2Weeks.Format("2006-01-02"))
+
+	// Output:
+	// 2021-01-15
+	// 2020-12-18
+}
+
+func ExampleAddMonth() {
+	date, _ := time.Parse("2006-01-02", "2021-01-01")
+
+	after2Months := AddMonth(date, 2)
+	before2Months := AddMonth(date, -2)
+
+	fmt.Println(after2Months.Format("2006-01-02"))
+	fmt.Println(before2Months.Format("2006-01-02"))
+
+	// Output:
+	// 2021-03-01
+	// 2020-11-01
 }
 
 func ExampleAddHour() {
-	now := time.Now()
+	date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")
 
-	after2Hours := AddHour(now, 2)
-	diff1 := after2Hours.Sub(now)
+	after2Hours := AddHour(date, 2)
+	before2Hours := AddHour(date, -2)
 
-	before2Hours := AddHour(now, -2)
-	diff2 := before2Hours.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
+	fmt.Println(after2Hours.Format("2006-01-02 15:04:05"))
+	fmt.Println(before2Hours.Format("2006-01-02 15:04:05"))
 
 	// Output:
-	// 2h0m0s
-	// -2h0m0s
+	// 2021-01-01 02:00:00
+	// 2020-12-31 22:00:00
 }
 
 func ExampleAddMinute() {
-	now := time.Now()
+	date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")
 
-	after2Minutes := AddMinute(now, 2)
-	diff1 := after2Minutes.Sub(now)
+	after2Minutes := AddMinute(date, 2)
+	before2Minutes := AddMinute(date, -2)
 
-	before2Minutes := AddMinute(now, -2)
-	diff2 := before2Minutes.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
+	fmt.Println(after2Minutes.Format("2006-01-02 15:04:05"))
+	fmt.Println(before2Minutes.Format("2006-01-02 15:04:05"))
 
 	// Output:
-	// 2m0s
-	// -2m0s
+	// 2021-01-01 00:02:00
+	// 2020-12-31 23:58:00
 }
 
 func ExampleAddYear() {
-	now := time.Now()
+	date, _ := time.Parse("2006-01-02", "2021-01-01")
 
-	after1Year := AddYear(now, 1)
-	diff1 := after1Year.Sub(now)
+	after2Years := AddYear(date, 2)
+	before2Years := AddYear(date, -2)
 
-	before1Year := AddYear(now, -1)
-	diff2 := before1Year.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
+	fmt.Println(after2Years.Format("2006-01-02"))
+	fmt.Println(before2Years.Format("2006-01-02"))
 
 	// Output:
-	// 8760h0m0s
-	// -8760h0m0s
+	// 2023-01-01
+	// 2019-01-01
+}
+
+func ExampleAddDaySafe() {
+	leapYearDate1, _ := time.Parse("2006-01-02", "2024-02-29")
+	result1 := AddDaySafe(leapYearDate1, 1)
+
+	leapYearDate2, _ := time.Parse("2006-01-02", "2024-03-01")
+	result2 := AddDaySafe(leapYearDate2, -1)
+
+	nonLeapYearDate1, _ := time.Parse("2006-01-02", "2025-02-28")
+	result3 := AddDaySafe(nonLeapYearDate1, 1)
+
+	nonLeaYearDate2, _ := time.Parse("2006-01-02", "2025-03-01")
+	result4 := AddDaySafe(nonLeaYearDate2, -1)
+
+	fmt.Println(result1.Format("2006-01-02"))
+	fmt.Println(result2.Format("2006-01-02"))
+	fmt.Println(result3.Format("2006-01-02"))
+	fmt.Println(result4.Format("2006-01-02"))
+
+	// Output:
+	// 2024-03-01
+	// 2024-02-29
+	// 2025-03-01
+	// 2025-02-28
+}
+
+func ExampleAddMonthSafe() {
+	date1, _ := time.Parse("2006-01-02", "2025-01-31")
+	result1 := AddMonthSafe(date1, 1)
+
+	date2, _ := time.Parse("2006-01-02", "2024-02-29")
+	result2 := AddMonthSafe(date2, -1)
+
+	fmt.Println(result1.Format("2006-01-02"))
+	fmt.Println(result2.Format("2006-01-02"))
+
+	// Output:
+	// 2025-02-28
+	// 2024-01-29
+}
+
+func ExampleAddYearSafe() {
+	date, _ := time.Parse("2006-01-02", "2020-02-29")
+
+	result1 := AddYearSafe(date, 1)
+	result2 := AddYearSafe(date, -1)
+
+	fmt.Println(result1.Format("2006-01-02"))
+	fmt.Println(result2.Format("2006-01-02"))
+
+	// Output:
+	// 2021-02-28
+	// 2019-02-28
 }
 
 func ExampleGetNowDate() {
@@ -229,23 +299,23 @@ func ExampleEndOfDay() {
 func ExampleBeginOfWeek() {
 	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
 
-	result := BeginOfWeek(input)
+	result := BeginOfWeek(input, time.Monday)
 
 	fmt.Println(result)
 
 	// Output:
-	// 2023-01-08 00:00:00 +0000 UTC
+	// 2023-01-02 00:00:00 +0000 UTC
 }
 
 func ExampleEndOfWeek() {
 	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
 
-	result := EndOfWeek(input)
+	result := EndOfWeek(input, time.Sunday)
 
 	fmt.Println(result)
 
 	// Output:
-	// 2023-01-14 23:59:59.999999999 +0000 UTC
+	// 2023-01-08 23:59:59.999999999 +0000 UTC
 }
 
 func ExampleBeginOfMonth() {
@@ -408,3 +478,61 @@ func ExampleIsWeekend() {
 	// true
 	// false
 }
+
+func ExampleDaysBetween() {
+	start := time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC)
+	end := time.Date(2024, time.September, 10, 0, 0, 0, 0, time.UTC)
+
+	result := DaysBetween(start, end)
+
+	fmt.Println(result)
+
+	// Output:
+	// 9
+}
+
+func ExampleGenerateDatetimesBetween() {
+	start := time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC)
+	end := time.Date(2024, time.September, 1, 2, 0, 0, 0, time.UTC)
+
+	layout := "2006-01-02 15:04:05"
+	interval := "1h"
+
+	result, err := GenerateDatetimesBetween(start, end, layout, interval)
+
+	fmt.Println(result)
+	fmt.Println(err)
+
+	// Output:
+	// [2024-09-01 00:00:00 2024-09-01 01:00:00 2024-09-01 02:00:00]
+	// <nil>
+}
+
+func ExampleMin() {
+	result := Min(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(result)
+
+	// Output:
+	// 2024-09-01 00:00:00 +0000 UTC
+}
+
+func ExampleMax() {
+	result := Max(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(result)
+
+	// Output:
+	// 2024-09-02 00:00:00 +0000 UTC
+}
+
+func ExampleMaxMin() {
+	max, min := MaxMin(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 3, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(max)
+	fmt.Println(min)
+
+	// Output:
+	// 2024-09-03 00:00:00 +0000 UTC
+	// 2024-09-01 00:00:00 +0000 UTC
+}

datetime/datetime_test.go

@@ -9,78 +9,427 @@ import (
 
 func TestAddYear(t *testing.T) {
 	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestAddDay")
 
-	now := time.Now()
-	after2Years := AddYear(now, 1)
-	diff1 := after2Years.Sub(now)
-	assert.Equal(float64(8760), diff1.Hours())
+	tests := []struct {
+		inputDate string
+		years     int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     1,
+			expected:  "2022-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     -1,
+			expected:  "2020-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     0,
+			expected:  "2021-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     2,
+			expected:  "2023-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     3,
+			expected:  "2024-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     4,
+			expected:  "2025-01-01 00:00:00",
+		},
+	}
 
-	before2Years := AddYear(now, -1)
-	diff2 := before2Years.Sub(now)
-	assert.Equal(float64(-8760), diff2.Hours())
-}
-
-func TestBetweenSeconds(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestBetweenSeconds")
-
-	today := time.Now()
-	tomorrow := AddDay(today, 1)
-	yesterday := AddDay(today, -1)
-
-	result1 := BetweenSeconds(today, tomorrow)
-	result2 := BetweenSeconds(today, yesterday)
-
-	assert.Equal(int64(86400), result1)
-	assert.Equal(int64(-86400), result2)
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
+		result := AddYear(date, int64(tt.years))
+		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
+	}
 }
 
 func TestAddDay(t *testing.T) {
 	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestAddDay")
 
-	now := time.Now()
-	after2Days := AddDay(now, 2)
-	diff1 := after2Days.Sub(now)
-	assert.Equal(float64(48), diff1.Hours())
+	tests := []struct {
+		inputDate string
+		days      int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      1,
+			expected:  "2021-01-02 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      -1,
+			expected:  "2020-12-31 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      0,
+			expected:  "2021-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      2,
+			expected:  "2021-01-03 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      3,
+			expected:  "2021-01-04 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      4,
+			expected:  "2021-01-05 00:00:00",
+		},
+	}
 
-	before2Days := AddDay(now, -2)
-	diff2 := before2Days.Sub(now)
-	assert.Equal(float64(-48), diff2.Hours())
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
+		result := AddDay(date, int64(tt.days))
+		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
+	}
 }
 
 func TestAddHour(t *testing.T) {
 	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestAddHour")
 
-	now := time.Now()
-	after2Hours := AddHour(now, 2)
-	diff1 := after2Hours.Sub(now)
-	assert.Equal(float64(2), diff1.Hours())
+	tests := []struct {
+		inputDate string
+		hours     int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     1,
+			expected:  "2021-01-01 01:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     -1,
+			expected:  "2020-12-31 23:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     0,
+			expected:  "2021-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     24,
+			expected:  "2021-01-02 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     25,
+			expected:  "2021-01-02 01:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     48,
+			expected:  "2021-01-03 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     49,
+			expected:  "2021-01-03 01:00:00",
+		},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
+		result := AddHour(date, int64(tt.hours))
+		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
+	}
 
-	before2Hours := AddHour(now, -2)
-	diff2 := before2Hours.Sub(now)
-	assert.Equal(float64(-2), diff2.Hours())
 }
 
 func TestAddMinute(t *testing.T) {
 	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestAddMinute")
 
-	now := time.Now()
-	after2Minutes := AddMinute(now, 2)
-	diff1 := after2Minutes.Sub(now)
-	assert.Equal(float64(2), diff1.Minutes())
+	tests := []struct {
+		inputDate string
+		minutes   int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   1,
+			expected:  "2021-01-01 00:01:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   -1,
+			expected:  "2020-12-31 23:59:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   0,
+			expected:  "2021-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   60,
+			expected:  "2021-01-01 01:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   61,
+			expected:  "2021-01-01 01:01:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   1440,
+			expected:  "2021-01-02 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   1441,
+			expected:  "2021-01-02 00:01:00",
+		},
+	}
 
-	before2Minutes := AddMinute(now, -2)
-	diff2 := before2Minutes.Sub(now)
-	assert.Equal(float64(-2), diff2.Minutes())
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
+		result := AddMinute(date, int64(tt.minutes))
+		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
+	}
+}
+
+func TestAddWeek(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestAddWeek")
+
+	tests := []struct {
+		inputDate string
+		weeks     int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01",
+			weeks:     1,
+			expected:  "2021-01-08",
+		},
+		{
+			inputDate: "2021-01-01",
+			weeks:     -1,
+			expected:  "2020-12-25",
+		},
+		{
+			inputDate: "2021-01-01",
+			weeks:     0,
+			expected:  "2021-01-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			weeks:     52,
+			expected:  "2021-12-31",
+		},
+		{
+			inputDate: "2021-01-01",
+			weeks:     53,
+			expected:  "2022-01-07",
+		},
+		{
+			inputDate: "2021-01-01",
+			weeks:     104,
+			expected:  "2022-12-30",
+		},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02", tt.inputDate)
+		result := AddWeek(date, int64(tt.weeks))
+		assert.Equal(tt.expected, result.Format("2006-01-02"))
+	}
+}
+
+func TestAddMonth(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestAddMonth")
+
+	tests := []struct {
+		inputDate string
+		months    int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01",
+			months:    1,
+			expected:  "2021-02-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			months:    -1,
+			expected:  "2020-12-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			months:    0,
+			expected:  "2021-01-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			months:    12,
+			expected:  "2022-01-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			months:    13,
+			expected:  "2022-02-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			months:    24,
+			expected:  "2023-01-01",
+		},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02", tt.inputDate)
+		result := AddMonth(date, int64(tt.months))
+		assert.Equal(tt.expected, result.Format("2006-01-02"))
+	}
+
+}
+
+func TestAddDaySafe(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestAddDaySafe")
+
+	tests := []struct {
+		inputDate string
+		days      int
+		expected  string
+	}{
+		{"2025-01-31", 10, "2025-02-10"},
+		{"2025-01-01", 30, "2025-01-31"},
+		{"2025-01-31", 1, "2025-02-01"},
+		{"2025-02-28", 1, "2025-03-01"},
+		{"2024-02-29", 1, "2024-03-01"},
+		{"2024-02-29", 365, "2025-02-28"},
+
+		{"2025-01-31", -10, "2025-01-21"},
+		{"2025-01-01", -30, "2024-12-02"},
+		{"2025-02-01", -1, "2025-01-31"},
+		{"2025-03-01", -1, "2025-02-28"},
+		{"2024-03-01", -1, "2024-02-29"},
+
+		{"2025-01-31", -31, "2024-12-31"},
+		{"2025-12-31", 1, "2026-01-01"},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02", tt.inputDate)
+		result := AddDaySafe(date, tt.days)
+		assert.Equal(tt.expected, result.Format("2006-01-02"))
+	}
+}
+
+func TestAddMonthSafe(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestAddMonthSafe")
+
+	tests := []struct {
+		inputDate string
+		months    int
+		expected  string
+	}{
+		{
+			inputDate: "2025-01-31",
+			months:    1,
+			expected:  "2025-02-28",
+		},
+		{
+			inputDate: "2025-01-31",
+			months:    -1,
+			expected:  "2024-12-31",
+		},
+		{
+			inputDate: "2025-12-31",
+			months:    1,
+			expected:  "2026-01-31",
+		},
+		{
+			inputDate: "2025-01-31",
+			months:    -1,
+			expected:  "2024-12-31",
+		},
+		{
+			inputDate: "2024-02-29",
+			months:    1,
+			expected:  "2024-03-29",
+		},
+		{
+			inputDate: "2024-02-29",
+			months:    -1,
+			expected:  "2024-01-29",
+		},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02", tt.inputDate)
+		result := AddMonthSafe(date, tt.months)
+		assert.Equal(tt.expected, result.Format("2006-01-02"))
+	}
+
+}
+
+func TestAddYearSafe(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestAddYearSafe")
+
+	tests := []struct {
+		inputDate string
+		years     int
+		expected  string
+	}{
+		{
+			inputDate: "2020-02-29",
+			years:     1,
+			expected:  "2021-02-28",
+		},
+		{
+			inputDate: "2020-02-29",
+			years:     2,
+			expected:  "2022-02-28",
+		},
+		{
+			inputDate: "2020-02-29",
+			years:     -1,
+			expected:  "2019-02-28",
+		},
+		{
+			inputDate: "2020-02-29",
+			years:     -2,
+			expected:  "2018-02-28",
+		},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02", tt.inputDate)
+		result := AddYearSafe(date, tt.years)
+		assert.Equal(tt.expected, result.Format("2006-01-02"))
+	}
 }
 
 func TestGetNowDate(t *testing.T) {
@@ -262,9 +611,9 @@ func TestBeginOfWeek(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestBeginOfWeek")
 
-	expected := time.Date(2022, 2, 13, 0, 0, 0, 0, time.Local)
+	expected := time.Date(2022, 2, 14, 0, 0, 0, 0, time.Local)
 	td := time.Date(2022, 2, 15, 15, 48, 40, 112, time.Local)
-	actual := BeginOfWeek(td)
+	actual := BeginOfWeek(td, time.Monday)
 
 	assert.Equal(expected, actual)
 }
@@ -274,9 +623,9 @@ func TestEndOfWeek(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestEndOfWeek")
 
-	expected := time.Date(2022, 2, 19, 23, 59, 59, 999999999, time.Local)
+	expected := time.Date(2022, 2, 20, 23, 59, 59, 999999999, time.Local)
 	td := time.Date(2022, 2, 15, 15, 48, 40, 112, time.Local)
-	actual := EndOfWeek(td)
+	actual := EndOfWeek(td, time.Sunday)
 
 	assert.Equal(expected, actual)
 }
@@ -410,3 +759,187 @@ func TestTimestamp(t *testing.T) {
 	ts4 := TimestampNano()
 	t.Log(ts4)
 }
+
+func TestTrackFuncTime(t *testing.T) {
+	defer TrackFuncTime(time.Now())()
+
+	var n int
+	for i := 0; i < 5000000; i++ {
+		n++
+	}
+}
+
+func TestDaysBetween(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestDaysBetween")
+
+	tests := []struct {
+		start    time.Time
+		end      time.Time
+		expected int
+	}{
+		{
+			start:    time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
+			end:      time.Date(2024, time.September, 10, 0, 0, 0, 0, time.UTC),
+			expected: 9,
+		},
+		{
+			start:    time.Date(2024, time.September, 10, 0, 0, 0, 0, time.UTC),
+			end:      time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
+			expected: -9,
+		},
+		{
+			start:    time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
+			end:      time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
+			expected: 0,
+		},
+		{
+			start:    time.Date(2024, time.January, 1, 0, 0, 0, 0, time.UTC),
+			end:      time.Date(2024, time.December, 31, 0, 0, 0, 0, time.UTC),
+			expected: 365,
+		},
+		{
+			start:    time.Date(2024, time.March, 1, 0, 0, 0, 0, time.UTC),
+			end:      time.Date(2024, time.March, 31, 0, 0, 0, 0, time.UTC),
+			expected: 30,
+		},
+	}
+
+	for _, tt := range tests {
+		result := DaysBetween(tt.start, tt.end)
+		assert.Equal(tt.expected, result)
+	}
+}
+
+func TestGenerateDatetimesBetween(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestGenerateDatetimesBetween")
+
+	tests := []struct {
+		start    time.Time
+		end      time.Time
+		layout   string
+		interval string
+		expected []string
+	}{
+		{
+			start:    time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
+			end:      time.Date(2024, time.September, 1, 2, 0, 0, 0, time.UTC),
+			layout:   "2006-01-02 15:04:05",
+			interval: "30m",
+			expected: []string{
+				"2024-09-01 00:00:00",
+				"2024-09-01 00:30:00",
+				"2024-09-01 01:00:00",
+				"2024-09-01 01:30:00",
+				"2024-09-01 02:00:00",
+			},
+		},
+		{
+			start:    time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
+			end:      time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
+			layout:   "2006-01-02 15:04:05",
+			interval: "1h",
+			expected: []string{"2024-09-01 00:00:00"},
+		},
+		{
+			start:    time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
+			end:      time.Date(2024, time.September, 1, 3, 0, 0, 0, time.UTC),
+			layout:   "2006-01-02 15:04:05",
+			interval: "2h",
+			expected: []string{
+				"2024-09-01 00:00:00",
+				"2024-09-01 02:00:00",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		result, err := GenerateDatetimesBetween(tt.start, tt.end, tt.layout, tt.interval)
+
+		assert.Equal(tt.expected, result)
+		assert.IsNil(err)
+	}
+
+	t.Run("Invalid interval", func(t *testing.T) {
+		_, err := GenerateDatetimesBetween(time.Now(), time.Now(), "2006-01-02 15:04:05", "invalid")
+		if err == nil {
+			t.Fatal("Expected error, got nil")
+		}
+	})
+}
+
+func TestMin(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMin")
+
+	zeroTime := time.Time{}
+	now := time.Now()
+	oneMinuteAgo := now.Add(-time.Minute)
+	oneMinuteAfter := now.Add(time.Minute)
+
+	assert.Equal(zeroTime, Min(zeroTime, now, oneMinuteAgo, oneMinuteAfter))
+
+	assert.Equal(zeroTime, Min(now, zeroTime))
+
+	assert.Equal(oneMinuteAgo, Min(oneMinuteAgo, now, oneMinuteAfter))
+}
+
+func TestMax(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMax")
+
+	zeroTime := time.Time{}
+	now := time.Now()
+	oneMinuteAgo := now.Add(-time.Minute)
+	oneMinuteAfter := now.Add(time.Minute)
+
+	assert.Equal(oneMinuteAfter, Max(zeroTime, now, oneMinuteAgo, oneMinuteAfter))
+
+	assert.Equal(now, Max(now, zeroTime))
+
+	assert.Equal(oneMinuteAfter, Max(oneMinuteAgo, now, oneMinuteAfter))
+}
+
+func TestMaxMin(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMinMax")
+
+	zeroTime := time.Time{}
+	now := time.Now()
+	oneMinuteAgo := now.Add(-time.Minute)
+	oneMinuteAfter := now.Add(time.Minute)
+
+	max, min := MaxMin(zeroTime, now, oneMinuteAgo, oneMinuteAfter)
+	assert.Equal(zeroTime, min)
+	assert.Equal(oneMinuteAfter, max)
+
+	max, min = MaxMin(now, zeroTime)
+	assert.Equal(zeroTime, min)
+	assert.Equal(now, max)
+
+	max, min = MaxMin(oneMinuteAgo, now, oneMinuteAfter)
+	assert.Equal(oneMinuteAgo, min)
+	assert.Equal(oneMinuteAfter, max)
+}
+
+func TestBetweenSeconds(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestBetweenSeconds")
+
+	today := time.Now()
+	tomorrow := AddDay(today, 1)
+	yesterday := AddDay(today, -1)
+
+	result1 := BetweenSeconds(today, tomorrow)
+	result2 := BetweenSeconds(today, yesterday)
+
+	assert.Equal(int64(86400), result1)
+	assert.Equal(int64(-86400), result2)
+}

docs/.vitepress/common.ts

@@ -0,0 +1,90 @@
+import { defineConfig, HeadConfig } from 'vitepress'
+
+export const META_IMAGE = '/lancet_logo.png'
+export const isProduction = process.env.NETLIFY && process.env.CONTEXT === 'production'
+
+if (process.env.NETLIFY) {
+    console.log('Netlify build', process.env.CONTEXT)
+}
+
+const productionHead: HeadConfig[] = [
+    [
+        'script',
+        {
+            src: 'https://unpkg.com/thesemetrics@latest',
+            async: '',
+            type: 'text/javascript',
+        },
+    ],
+]
+
+const rControl = /[\u0000-\u001f]/g
+const rSpecial = /[\s~`!@#$%^&*()\-_+=[\]{}|\\;:"'“”‘’<>,.?/]+/g
+const rCombining = /[\u0300-\u036F]/g
+
+/**
+ * Default slugification function
+ */
+export const slugify = (str: string): string =>
+    str
+        .normalize('NFKD')
+        // Remove accents
+        .replace(rCombining, '')
+        // Remove control characters
+        .replace(rControl, '')
+        // Replace special characters
+        .replace(rSpecial, '-')
+        // ensure it doesn't start with a number
+        .replace(/^(\d)/, '_$1')
+
+export const commonConfig = defineConfig({
+    title: 'Lancet',
+    appearance: true,
+    ignoreDeadLinks: true,
+
+    markdown: {
+        theme: {
+            dark: 'dracula-soft',
+            light: 'vitesse-light',
+        },
+
+        attrs: {
+            leftDelimiter: '%{',
+            rightDelimiter: '}%',
+        },
+
+        anchor: {
+            slugify,
+        },
+    },
+
+    head: [
+        // ['link', { rel: 'icon', type: 'image/svg+xml', href: '/logo.svg' }],
+        ['link', { rel: 'icon', type: 'image/png', href: '/lancet_logo_mini.png' }],
+        ['meta', { name: 'theme-color', content: '#5f67ee' }],
+        ['meta', { name: 'og:type', content: 'website' }],
+        ['meta', { name: 'og:locale', content: 'zh' }],
+
+        ...(isProduction ? productionHead : []),
+    ],
+
+    themeConfig: {
+        logo: { src: '/lancet_logo_mini.png', width: 24, height: 24 },
+        outline: [2, 3],
+
+        search: {
+            provider: 'local',
+        },
+        socialLinks: [
+            {
+                icon: 'github',
+                link: 'https://github.com/duke-git/lancet',
+            },
+        ],
+
+        footer: {
+            copyright: 'Copyright © 2023-present Duke Du',
+            message: '<a href="https://beian.miit.gov.cn/" target="_blank">京ICP备2023022770号-1</a>',
+        },
+    },
+})

docs/.vitepress/config.mts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitepress'
+import { commonConfig } from './common'
+import { zhConfig } from './zh'
+import { enConfig } from './en'
+
+// https://vitepress.dev/reference/site-config
+export default defineConfig({
+    ...commonConfig,
+
+    locales: {
+        root: { label: '简体中文', lang: 'zh-CN', link: '/', ...zhConfig },
+        en: { label: 'English', lang: 'en-US', link: '/en/', ...enConfig },
+    },
+})

docs/.vitepress/en.ts

@@ -0,0 +1,141 @@
+import type { DefaultTheme, LocaleSpecificConfig } from 'vitepress'
+
+export const META_URL = 'https://www.golancet.cn/en/'
+export const META_TITLE = 'Lancet'
+export const META_DESCRIPTION = 'A powerful util function library of Go'
+
+export const enConfig: LocaleSpecificConfig<DefaultTheme.Config> = {
+    description: META_DESCRIPTION,
+
+    head: [
+        ['meta', { property: 'og:url', content: META_URL }],
+        ['meta', { property: 'og:description', content: META_DESCRIPTION }],
+    ],
+
+    themeConfig: {
+        editLink: {
+            pattern: 'https://github.com/duke-git/lancet/edit/v2/docs/:path',
+            text: 'Suggest changes to this page',
+        },
+        nav: [
+            {
+                text: 'Home',
+                link: '/en/',
+                activeMatch: '^/en/',
+            },
+            {
+                text: 'Guide',
+                link: '/en/guide/introduction',
+                activeMatch: '^/en/guide/',
+            },
+            { text: 'API', link: '/en/api/overview', activeMatch: '^/en/api/' },
+            {
+                text: 'Links',
+                items: [
+                    {
+                        text: 'Discussion',
+                        link: 'https://github.com/duke-git/lancet/discussions',
+                    },
+                    {
+                        text: 'Changelog',
+                        link: 'https://github.com/duke-git/lancet/releases',
+                    },
+                    {
+                        text: 'Contribution',
+                        link: 'https://github.com/duke-git/lancet/blob/main/CONTRIBUTION.md',
+                    },
+                ],
+            },
+        ],
+
+        sidebar: {
+            '/en/guide/': [
+                {
+                    text: 'Introduction',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: 'What is Lancet？',
+                            link: '/en/guide/introduction',
+                        },
+                        {
+                            text: 'Getting started',
+                            link: '/en/guide/getting_started',
+                        },
+                    ],
+                },
+                {
+                    text: 'Contribute Code',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: 'Contribution guide',
+                            link: '/en/guide/contribution_guide',
+                        },
+                        {
+                            text: 'Contributors',
+                            link: '/en/guide/contributors',
+                        },
+                    ],
+                },
+                {
+                    text: 'API Reference',
+                    link: '/en/api/overview'
+                },
+            ],
+            '/en/api/': [
+                {
+                    text: 'Overview',
+                    items: [{ text: 'API overview', link: '/en/api/overview' }],
+                },
+                {
+                    text: 'Packages',
+                    collapsed: false,
+                    items: [
+                        { text: 'algorithm', link: '/en/api/packages/algorithm' },
+                        { text: 'compare', link: '/en/api/packages/compare' },
+                        { text: 'concurrency', link: '/en/api/packages/concurrency' },
+                        { text: 'condition', link: '/en/api/packages/condition' },
+                        { text: 'convertor', link: '/en/api/packages/convertor' },
+                        { text: 'cryptor', link: '/en/api/packages/cryptor' },
+                        {
+                            text: 'datastructure',
+                            collapsed: true,
+                            items: [
+                                { text: 'list', link: '/en/api/packages/datastructure/list' },
+                                { text: 'safelist', link: '/en/api/packages/datastructure/copyonwritelist' },
+                                { text: 'link', link: '/en/api/packages/datastructure/link' },
+                                { text: 'stack', link: '/en/api/packages/datastructure/stack' },
+                                { text: 'queue', link: '/en/api/packages/datastructure/queue' },
+                                { text: 'heap', link: '/en/api/packages/datastructure/heap' },
+                                { text: 'tree', link: '/en/api/packages/datastructure/tree' },
+                                { text: 'set', link: '/en/api/packages/datastructure/set' },
+                                { text: 'hashmap', link: '/en/api/packages/datastructure/hashmap' },
+                            ],
+                        },
+                        { text: 'datetime', link: '/en/api/packages/datetime' },
+                        { text: 'enum', link: '/en/api/packages/enum' },
+                        { text: 'eventbus', link: '/en/api/packages/eventbus' },
+                        { text: 'fileutil', link: '/en/api/packages/fileutil' },
+                        { text: 'formatter', link: '/en/api/packages/formatter' },
+                        { text: 'function', link: '/en/api/packages/function' },
+                        { text: 'mathutil', link: '/en/api/packages/mathutil' },
+                        { text: 'maputil', link: '/en/api/packages/maputil' },
+                        { text: 'netutil', link: '/en/api/packages/netutil' },
+                        { text: 'pointer', link: '/en/api/packages/pointer' },
+                        { text: 'random', link: '/en/api/packages/random' },
+                        { text: 'retry', link: '/en/api/packages/retry' },
+                        { text: 'slice', link: '/en/api/packages/slice' },
+                        { text: 'stream', link: '/en/api/packages/stream' },
+                        { text: 'struct', link: '/en/api/packages/struct' },
+                        { text: 'strutil', link: '/en/api/packages/strutil' },
+                        { text: 'tuple', link: '/en/api/packages/tuple' },
+                        { text: 'validator', link: '/en/api/packages/validator' },
+                        { text: 'system', link: '/en/api/packages/system' },
+                        { text: 'xerror', link: '/en/api/packages/xerror' },
+                    ],
+                },
+            ],
+        },
+    },
+}

docs/.vitepress/zh.ts

@@ -0,0 +1,154 @@
+import type { DefaultTheme, LocaleSpecificConfig } from 'vitepress'
+
+export const META_URL = 'https://www.golancet.cn'
+export const META_TITLE = 'Lancet'
+export const META_DESCRIPTION = '一个强大的Go语言工具函数库'
+
+export const zhConfig: LocaleSpecificConfig<DefaultTheme.Config> = {
+    description: META_DESCRIPTION,
+
+    head: [
+        ['meta', { property: 'og:url', content: META_URL }],
+        ['meta', { property: 'og:description', content: META_DESCRIPTION }],
+    ],
+
+    themeConfig: {
+        editLink: {
+            pattern: 'https://github.com/duke-git/lancet/edit/v2/docs/:path',
+            text: '对本页提出修改建议',
+        },
+        outline: {
+            label: '本页内容',
+        },
+
+        docFooter: {
+            prev: '上一页',
+            next: '下一页',
+        },
+
+        nav: [
+            {
+                text: '首页',
+                link: '/',
+                activeMatch: '^/',
+            },
+            {
+                text: '指南',
+                link: '/guide/introduction',
+                activeMatch: '^/guide/',
+            },
+            { text: 'API', link: '/api/overview', activeMatch: '^/api/' },
+            {
+                text: '相关链接',
+                items: [
+                    {
+                        text: '论坛',
+                        link: 'https://github.com/duke-git/lancet/discussions',
+                    },
+                    {
+                        text: '更新日志',
+                        link: 'https://github.com/duke-git/lancet/releases',
+                    },
+                    {
+                        text: '参与贡献',
+                        link: 'https://github.com/duke-git/lancet/blob/main/CONTRIBUTION.zh-CN.md',
+                    },
+                ],
+            },
+        ],
+
+        sidebar: {
+            '/guide/': [
+                {
+                    text: '介绍',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: 'Lancet是什么？',
+                            link: '/guide/introduction',
+                        },
+                        {
+                            text: '开始',
+                            link: '/guide/getting_started',
+                        },
+                    ],
+                },
+                {
+                    text: '贡献代码',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: '贡献指南',
+                            link: '/guide/contribution_guide',
+                        },
+                        {
+                            text: '贡献者',
+                            link: '/guide/contributors',
+                        },
+                    ],
+                },
+                {
+                    text: 'API手册',
+                    link: '/api/overview'
+                },
+            ],
+
+            '/api/': [
+                {
+                    text: '概览',
+                    items: [{ text: 'API概述', link: '/api/overview' }],
+                },
+                {
+                    text: 'API文档',
+                    collapsed: false,
+                    items: [
+                        { text: '算法', link: '/api/packages/algorithm' },
+                        { text: '比较器', link: '/api/packages/compare' },
+                        { text: '并发处理', link: '/api/packages/concurrency' },
+                        { text: '条件判断', link: '/api/packages/condition' },
+                        { text: '类型转换', link: '/api/packages/convertor' },
+                        { text: '加密&解密', link: '/api/packages/cryptor' },
+                        {
+                            text: '数据结构',
+                            collapsed: true,
+                            items: [
+                                { text: '线性表', link: '/api/packages/datastructure/list' },
+                                {
+                                    text: '线性表(线程安全)',
+                                    link: '/api/packages/datastructure/copyonwritelist',
+                                },
+                                { text: '链表', link: '/api/packages/datastructure/link' },
+                                { text: '栈', link: '/api/packages/datastructure/stack' },
+                                { text: '队列', link: '/api/packages/datastructure/queue' },
+                                { text: '堆', link: '/api/packages/datastructure/heap' },
+                                { text: '树', link: '/api/packages/datastructure/tree' },
+                                { text: '集合', link: '/api/packages/datastructure/set' },
+                                { text: 'HashMap', link: '/api/packages/datastructure/hashmap' },
+                            ],
+                        },
+                        { text: '日期&时间', link: '/api/packages/datetime' },
+                        { text: '事件总线', link: '/api/packages/eventbus' },
+                        { text: '文件处理', link: '/api/packages/fileutil' },
+                        { text: '格式化工具', link: '/api/packages/formatter' },
+                        { text: '函数', link: '/api/packages/function' },
+                        { text: '数学工具', link: '/api/packages/mathutil' },
+                        { text: 'Map', link: '/api/packages/maputil' },
+                        { text: '网络', link: '/api/packages/netutil' },
+                        { text: '指针', link: '/api/packages/pointer' },
+                        { text: '随机数', link: '/api/packages/random' },
+                        { text: '重试', link: '/api/packages/retry' },
+                        { text: '切片', link: '/api/packages/slice' },
+                        { text: '流', link: '/api/packages/stream' },
+                        { text: '结构体', link: '/api/packages/struct' },
+                        { text: '字符串', link: '/api/packages/strutil' },
+                        { text: '枚举', link: '/api/packages/enum' },
+                        { text: '元组', link: '/api/packages/tuple' },
+                        { text: '验证器', link: '/api/packages/validator' },
+                        { text: '系统工具函数', link: '/api/packages/system' },
+                        { text: '错误处理', link: '/api/packages/xerror' },
+                    ],
+                },
+            ],
+        },
+    },
+}

docs/api/overview.md

@@ -0,0 +1,70 @@
+---
+outline: deep
+---
+
+# API 概述
+
+<b>lancet（柳叶刀）是一个功能强大、全面、高效、可复用的 go 语言工具函数库。包含 25 个包，超过 600 个工具函数。功能涵盖字符串处理、切片处理、网络、并发、加解密、文件处理、时间/日期、流处理、迭代器等等。</b>
+
+<style>
+.package-title {
+    color: black;
+    font-size: 18px;
+    text-align: center;
+    font-weight: bold;
+}
+.package-container {
+    font-size: 16px;
+    border: 1px dashed;
+    padding: 10px;
+    text-align: center;
+}
+
+.package-cell {
+    height: 40px;
+    width: 140px;
+    display: inline-block;
+    vertical-align: middle;
+    line-height: 40px;
+    background: #6cadf5;
+    border: 1px solid;
+    margin-right: 10px;
+    margin-bottom: 10px;
+    border-radius: 6px;
+    font-weight: bold;
+}
+</style>
+
+<div>
+    <p class="package-title">lancet功能模块</p>
+    <div class="package-container">
+        <div class="package-cell">algorithm</div>
+        <div class="package-cell">compare</div>
+        <div class="package-cell">concurrency</div>
+        <div class="package-cell">condition</div>
+        <div class="package-cell">convertor</div>
+        <div class="package-cell">cryptor</div>
+        <div class="package-cell">datastructure</div>
+        <div class="package-cell">datetime</div>
+        <div class="package-cell">enum</div>
+        <div class="package-cell">eventbus</div>
+        <div class="package-cell">fileutil</div>
+        <div class="package-cell">formatter</div>
+        <div class="package-cell">function</div>
+        <div class="package-cell">iterator</div>
+        <div class="package-cell">maputil</div>
+        <div class="package-cell">mathutil</div>
+        <div class="package-cell">netutil</div>
+        <div class="package-cell">pointer</div>
+        <div class="package-cell">random</div>
+        <div class="package-cell">retry</div>
+        <div class="package-cell">slice</div>
+        <div class="package-cell">stream</div>
+        <div class="package-cell">structs</div>
+        <div class="package-cell">strutil</div>
+        <div class="package-cell">system</div>
+        <div class="package-cell">tuple</div>
+        <div class="package-cell">validator</div>
+        <div class="package-cell">xerror</div>
+    </div>
+</div>

docs/api/packages/algorithm.md

@@ -8,7 +8,7 @@ algorithm 算法包实现一些基本算法，sort，search，lrucache。
 
 -   [https://github.com/duke-git/lancet/blob/main/algorithm/sort.go](https://github.com/duke-git/lancet/blob/main/algorithm/sort.go)
 -   [https://github.com/duke-git/lancet/blob/main/algorithm/search.go](https://github.com/duke-git/lancet/blob/main/algorithm/search.go)
--   [https://github.com/duke-git/lancet/blob/main/algorithm/lru_cache.go](https://github.com/duke-git/lancet/blob/main/algorithm/lru_cache.go)
+-   [https://github.com/duke-git/lancet/blob/main/algorithm/lrucache.go](https://github.com/duke-git/lancet/blob/main/algorithm/lrucache.go)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -43,15 +43,15 @@ import (
 
 ### <span id="BubbleSort">BubbleSort</span>
 
-<p>冒泡排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>冒泡排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func BubbleSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GNdv7Jg2Taj)</span></b>
 
 ```go
 package main
@@ -91,15 +91,15 @@ func main() {
 
 ### <span id="InsertionSort">InsertionSort</span>
 
-<p>插入排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>插入排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func InsertionSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/G5LJiWgJJW6)</span></b>
 
 ```go
 package main
@@ -117,7 +117,7 @@ type people struct {
 // PeopleAageComparator sort people slice by age field
 type peopleAgeComparator struct{}
 
-// Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
+// Compare implements github.com/duke-git/lancet/constraints/constraints.go/Comparator
 func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
     p1, _ := v1.(people)
     p2, _ := v2.(people)
@@ -154,15 +154,15 @@ func main() {
 
 ### <span id="SelectionSort">SelectionSort</span>
 
-<p>选择排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>选择排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func SelectionSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/oXovbkekayS)</span></b>
 
 ```go
 package main
@@ -202,15 +202,15 @@ func main() {
 
 ### <span id="ShellSort">ShellSort</span>
 
-<p>希尔排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>希尔排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func ShellSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3ibkszpJEu3)</span></b>
 
 ```go
 package main
@@ -250,15 +250,15 @@ func main() {
 
 ### <span id="QuickSort">QuickSort</span>
 
-<p>快速排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>快速排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func QuickSort[T any](slice []T comparator lancetconstraints.Comparator)
+func QuickSort[T any](slice []T comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7Y7c1Elk3ax)</span></b>
 
 ```go
 package main
@@ -298,15 +298,15 @@ func main() {
 
 ### <span id="HeapSort">HeapSort</span>
 
-<p>堆排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>堆排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func HeapSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/u6Iwa1VZS_f)</span></b>
 
 ```go
 package main
@@ -346,15 +346,15 @@ func main() {
 
 ### <span id="MergeSort">MergeSort</span>
 
-<p>归并排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>归并排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func MergeSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ydinn9YzUJn)</span></b>
 
 ```go
 package main
@@ -394,15 +394,15 @@ func main() {
 
 ### <span id="CountSort">CountSort</span>
 
-<p>计数排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>计数排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func CountSort[T any](slice []T, comparator constraints.Comparator) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tB-Umgm0DrP)</span></b>
 
 ```go
 package main
@@ -443,15 +443,15 @@ func main() {
 
 ### <span id="BinarySearch">BinarySearch</span>
 
-<p>二分递归查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>二分递归查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
+func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/t6MeGiUSN47)</span></b>
 
 ```go
 package main
@@ -494,15 +494,15 @@ func main() {
 
 ### <span id="BinaryIterativeSearch">BinaryIterativeSearch</span>
 
-<p>二分迭代查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>二分迭代查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
+func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Anozfr8ZLH3)</span></b>
 
 ```go
 package main
@@ -553,7 +553,7 @@ func main() {
 func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IsS7rgn5s3x)</span></b>
 
 ```go
 package main
@@ -596,7 +596,7 @@ func (l *LRUCache[K, V]) Delete(key K) bool
 func (l *LRUCache[K, V]) Len() int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/-EZjgOURufP)</span></b>
 
 ```go
 package main

docs/api/packages/compare.md

@@ -35,7 +35,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## Documentation
+## 文档
 
 ### <span id="Equal">Equal</span>
 
@@ -47,7 +47,7 @@ import (
 func Equal(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wmVxR-to4lz)</span></b>
 
 ```go
 package main
@@ -96,7 +96,7 @@ func main() {
 func EqualValue(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fxnna_LLD9u)</span></b>
 
 ```go
 package main
@@ -135,7 +135,7 @@ func main() {
 func LessThan(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cYh7FQQj0ne)</span></b>
 
 ```go
 package main
@@ -184,7 +184,7 @@ func main() {
 func GreaterThan(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9-NYDFZmIMp)</span></b>
 
 ```go
 package main
@@ -236,7 +236,7 @@ func main() {
 func LessOrEqual(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/e4T_scwoQzp)</span></b>
 
 ```go
 package main
@@ -285,7 +285,7 @@ func main() {
 func GreaterOrEqual(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vx8mP0U8DFk)</span></b>
 
 ```go
 package main
@@ -337,7 +337,7 @@ func main() {
 func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/TuDdcNtMkjo)</span></b>
 
 ```go
 package main

docs/api/packages/concurrency.md

@@ -0,0 +1,852 @@
+# Concurrency
+
+并发包包含一些支持并发编程的功能。例如：goroutine, channel 等。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/concurrency/channel.go](https://github.com/duke-git/lancet/blob/main/concurrency/channel.go)
+-   [https://github.com/duke-git/lancet/blob/main/concurrency/keyed_locker.go](https://github.com/duke-git/lancet/blob/main/concurrency/keyed_locker.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+### Channel
+
+-   [NewChannel](#NewChannel)
+-   [Bridge](#Bridge)
+-   [FanIn](#FanIn)
+-   [Generate](#Generate)
+-   [Or](#Or)
+-   [OrDone](#OrDone)
+-   [Repeat](#Repeat)
+-   [RepeatFn](#RepeatFn)
+-   [Take](#Take)
+-   [Tee](#Tee)
+
+### KeyedLocker
+
+-   [NewKeyedLocker](#NewKeyedLocker)
+-   [KeyedLocker_Do](#Do)
+-   [NewRWKeyedLocker](#NewRWKeyedLocker)
+-   [RLock](#RLock)
+-   [Lock](#Lock)
+-   [NewTryKeyedLocker](#NewTryKeyedLocker)
+-   [TryLock](#TryLock)
+-   [Unlock](#Unlock)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### Channel
+
+### <span id="NewChannel">NewChannel</span>
+
+<p>返回一个Channel指针实例</p>
+
+<b>函数签名:</b>
+
+```go
+type Channel[T any] struct
+func NewChannel[T any]() *Channel[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    c := concurrency.NewChannel[int]()
+}
+```
+
+### <span id="Bridge">Bridge</span>
+
+<p>将多个channel链接到一个channel，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qmWSy1NVF-Y)</span></b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
+
+    c := concurrency.NewChannel[int]()
+    genVals := func() <-chan <-chan int {
+        out := make(chan (<-chan int))
+        go func() {
+            defer close(out)
+            for i := 1; i <= 5; i++ {
+                stream := make(chan int, 1)
+                stream <- i
+                close(stream)
+                out <- stream
+            }
+        }()
+        return out
+    }
+
+    for v := range c.Bridge(ctx, genVals()) {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 3
+    // 4
+    // 5
+}
+```
+
+### <span id="FanIn">FanIn</span>
+
+<p>将多个channel合并为一个channel，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2VYFMexEvTm)</span></b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
+
+    c := concurrency.NewChannel[int]()
+    channels := make([]<-chan int, 2)
+
+    for i := 0; i < 2; i++ {
+        channels[i] = c.Take(ctx, c.Repeat(ctx, i), 2)
+    }
+
+    chs := c.FanIn(ctx, channels...)
+
+    for v := range chs {
+        fmt.Println(v) //1 1 0 0 or 0 0 1 1
+    }
+}
+```
+
+### <span id="Generate">Generate</span>
+
+<p>根据传入的值，生成channel.</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
+
+    c := concurrency.NewChannel[int]()
+    intStream := c.Generate(ctx, 1, 2, 3)
+
+    fmt.Println(<-intStream)
+    fmt.Println(<-intStream)
+    fmt.Println(<-intStream)
+
+    // Output:
+    // 1
+    // 2
+    // 3
+}
+```
+
+### <span id="Repeat">Repeat</span>
+
+<p>返回一个channel，将参数`values`重复放入channel，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/k5N_ALVmYjE)</span></b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
+
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
+
+    for v := range intStream {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 1
+    // 2
+}
+```
+
+### <span id="RepeatFn">RepeatFn</span>
+
+<p>返回一个channel，重复执行函数fn，并将结果放入返回的channel，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4J1zAWttP85)</span></b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
+
+    fn := func() string {
+        return "hello"
+    }
+
+    c := concurrency.NewChannel[string]()
+    intStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
+
+    for v := range intStream {
+        fmt.Println(v)
+    }
+    // Output:
+    // hello
+    // hello
+    // hello
+}
+```
+
+### <span id="Or">Or</span>
+
+<p>将一个或多个channel读取到一个channel中，当任何读取channel关闭时将结束读取。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel[T]) Or(channels ...<-chan T) <-chan T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Wqz9rwioPww)</span></b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    sig := func(after time.Duration) <-chan any {
+        c := make(chan any)
+        go func() {
+            defer close(c)
+            time.Sleep(after)
+        }()
+        return c
+    }
+
+    start := time.Now()
+
+    c := concurrency.NewChannel[any]()
+    <-c.Or(
+        sig(1*time.Second),
+        sig(2*time.Second),
+        sig(3*time.Second),
+    )
+
+    fmt.Println("done after %v", time.Since(start)) //1.003s
+}
+```
+
+### <span id="OrDone">OrDone</span>
+
+<p>将一个channel读入另一个channel，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lm_GoS6aDjo)</span></b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
+
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
+
+    for v := range c.OrDone(ctx, intStream) {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 1
+    // 1
+}
+```
+
+### <span id="Take">Take</span>
+
+<p>返回一个channel，其值从另一个channel获取，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9Utt-1pDr2J)</span></b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
+
+    numbers := make(chan int, 5)
+    numbers <- 1
+    numbers <- 2
+    numbers <- 3
+    numbers <- 4
+    numbers <- 5
+    defer close(numbers)
+
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, numbers, 3)
+
+    for v := range intStream {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 3
+}
+```
+
+### <span id="Tee">Tee</span>
+
+<p>将一个channel分成两个channel，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3TQPKnCirrP)</span></b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
+
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1), 2)
+
+    ch1, ch2 := c.Tee(ctx, intStream)
+
+    for v := range ch1 {
+        fmt.Println(v)
+        fmt.Println(<-ch2)
+    }
+    // Output:
+    // 1
+    // 1
+    // 1
+    // 1
+}
+```
+
+### KeyedLocker
+
+### <span id="NewKeyedLocker">NewKeyedLocker</span>
+
+<p>NewKeyedLocker创建一个新的KeyedLocker，并为锁的过期设置指定的 TTL。KeyedLocker 是一个简单的键值锁实现，允许非阻塞的锁获取。</p>
+
+<b>函数签名:</b>
+
+```go
+func NewKeyedLocker[K comparable](ttl time.Duration) *KeyedLocker[K]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GzeyC33T5rw)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    locker := concurrency.NewKeyedLocker[string](2 * time.Second)
+
+    task := func() {
+        fmt.Println("Executing task...")
+        time.Sleep(1 * time.Second)
+        fmt.Println("Task completed.")
+    }
+
+    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+    defer cancel()
+
+    if err := locker.Do(ctx, "mykey", task); err != nil {
+        log.Fatalf("Error executing task: %v\n", err)
+    } else {
+        fmt.Println("Task successfully executed.")
+    }
+
+    ctx2, cancel2 := context.WithTimeout(context.Background(), 3*time.Second)
+    defer cancel2()
+
+    if err := locker.Do(ctx2, "mykey", task); err != nil {
+        log.Fatalf("Error executing task: %v\n", err)
+    } else {
+        fmt.Println("Task successfully executed.")
+    }
+
+    // Output:
+    // Executing task...
+    // Task completed.
+    // Task successfully executed.
+    // Executing task...
+    // Task completed.
+    // Task successfully executed.
+}
+```
+
+### <span id="Do">Do</span>
+
+<p>为指定的键获取锁并执行提供的函数。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *KeyedLocker[K]) Do(ctx context.Context, key K, fn func()) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GzeyC33T5rw)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    locker := concurrency.NewKeyedLocker[string](2 * time.Second)
+
+    task := func() {
+        fmt.Println("Executing task...")
+        time.Sleep(1 * time.Second)
+        fmt.Println("Task completed.")
+    }
+
+    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+    defer cancel()
+
+    if err := locker.Do(ctx, "mykey", task); err != nil {
+        log.Fatalf("Error executing task: %v\n", err)
+    } else {
+        fmt.Println("Task successfully executed.")
+    }
+
+    ctx2, cancel2 := context.WithTimeout(context.Background(), 3*time.Second)
+    defer cancel2()
+
+    if err := locker.Do(ctx2, "mykey", task); err != nil {
+        log.Fatalf("Error executing task: %v\n", err)
+    } else {
+        fmt.Println("Task successfully executed.")
+    }
+
+    // Output:
+    // Executing task...
+    // Task completed.
+    // Task successfully executed.
+    // Executing task...
+    // Task completed.
+    // Task successfully executed.
+}
+```
+
+### <span id="NewRWKeyedLocker">NewRWKeyedLocker</span>
+
+<p>NewRWKeyedLocker创建一个新的RWKeyedLocker，并为锁的过期设置指定的 TTL。RWKeyedLocker 是一个简单的键值读写锁实现，允许非阻塞的锁获取。</p>
+
+<b>函数签名:</b>
+
+```go
+func NewRWKeyedLocker[K comparable](ttl time.Duration) *RWKeyedLocker[K]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CkaJWWwZm9)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    locker := concurrency.NewRWKeyedLocker[string](2 * time.Second)
+
+    // Simulate a key
+    key := "resource_key"
+
+    fn := func() {
+        fmt.Println("Starting write operation...")
+        // Simulate write operation, assuming it takes 2 seconds
+        time.Sleep(200 * time.Millisecond)
+        fmt.Println("Write operation completed!")
+    }
+
+    // Acquire the write lock and execute the operation
+    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+    defer cancel()
+
+    // Execute the lock operation with a 3-second timeout
+    err := locker.Lock(ctx, key, fn)
+    if err != nil {
+        return
+    }
+
+    //output:
+    //Starting write operation...
+    //Write operation completed!
+}
+```
+
+### <span id="RLock">RLock</span>
+
+<p>RLock为指定的键获取读锁并执行提供的函数。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *RWKeyedLocker[K]) RLock(ctx context.Context, key K, fn func()) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ZrCr8sMo77T)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    locker := concurrency.NewRWKeyedLocker[string](2 * time.Second)
+
+    // Simulate a key
+    key := "resource_key"
+
+    fn := func() {
+        fmt.Println("Starting write operation...")
+        // Simulate write operation, assuming it takes 2 seconds
+        time.Sleep(200 * time.Millisecond)
+        fmt.Println("Write operation completed!")
+    }
+
+    // Acquire the write lock and execute the operation
+    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+    defer cancel()
+
+    // Execute the lock operation with a 3-second timeout
+    err := locker.RLock(ctx, key, fn)
+    if err != nil {
+        return
+    }
+
+    //output:
+    //Starting write operation...
+    //Write operation completed!
+}
+```
+
+### <span id="Lock">Lock</span>
+
+<p>Lock为指定的键获取锁并执行提供的函数。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *RWKeyedLocker[K]) Lock(ctx context.Context, key K, fn func()) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/WgAcXbOPKGk)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    locker := NewRWKeyedLocker[string](2 * time.Second)
+
+    // Simulate a key
+    key := "resource_key"
+
+    fn := func() {
+        fmt.Println("Starting write operation...")
+        // Simulate write operation, assuming it takes 2 seconds
+        time.Sleep(200 * time.Millisecond)
+        fmt.Println("Write operation completed!")
+    }
+
+    // Acquire the write lock and execute the operation
+    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+    defer cancel()
+
+    // Execute the lock operation with a 3-second timeout
+    err := locker.Lock(ctx, key, fn)
+    if err != nil {
+        return
+    }
+
+    //output:
+    //Starting write operation...
+    //Write operation completed!
+}
+```
+
+### <span id="NewTryKeyedLocker">NewTryKeyedLocker</span>
+
+<p>创建一个TryKeyedLocker实例，TryKeyedLocker是KeyedLocker的非阻塞版本。</p>
+
+<b>函数签名:</b>
+
+```go
+func NewTryKeyedLocker[K comparable]() *TryKeyedLocker[K]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VG9qLvyetE2)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    locker := concurrency.NewTryKeyedLocker[string]()
+
+    key := "resource_key"
+
+    if locker.TryLock(key) {
+        fmt.Println("Lock acquired")
+        time.Sleep(1 * time.Second)
+        // Unlock after work is done
+        locker.Unlock(key)
+        fmt.Println("Lock released")
+    } else {
+        fmt.Println("Lock failed")
+    }
+
+    //output:
+    //Lock acquired
+    //Lock released
+}
+```
+
+### <span id="TryLock">TryLock</span>
+
+<p>TryLock尝试获取指定键的锁。如果锁成功获取，则返回true，否则返回false。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *TryKeyedLocker[K]) TryLock(key K) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VG9qLvyetE2)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    locker := concurrency.NewTryKeyedLocker[string]()
+
+    key := "resource_key"
+
+    if locker.TryLock(key) {
+        fmt.Println("Lock acquired")
+        time.Sleep(1 * time.Second)
+        // Unlock after work is done
+        locker.Unlock(key)
+        fmt.Println("Lock released")
+    } else {
+        fmt.Println("Lock failed")
+    }
+
+    //output:
+    //Lock acquired
+    //Lock released
+}
+```
+
+### <span id="Unlock">Unlock</span>
+
+<p>释放指定键的锁。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *TryKeyedLocker[K]) Unlock(key K)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VG9qLvyetE2)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    locker := concurrency.NewTryKeyedLocker[string]()
+
+    key := "resource_key"
+
+    if locker.TryLock(key) {
+        fmt.Println("Lock acquired")
+        time.Sleep(1 * time.Second)
+        // Unlock after work is done
+        locker.Unlock(key)
+        fmt.Println("Lock released")
+    } else {
+        fmt.Println("Lock failed")
+    }
+
+    //output:
+    //Lock acquired
+    //Lock released
+}
+```

docs/api/packages/condition.md

@@ -18,7 +18,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## Index
+## 目录
 
 - [Bool](#Bool)
 - [And](#And)
@@ -27,11 +27,12 @@ import (
 - [Nor](#Nor)
 - [Xnor](#Xnor)
 - [Nand](#Nand)
-- [TernaryOperator](#TernaryOperator)
+- [Ternary](#Ternary)
+- [TernaryOperator<sup>deprecated</sup>](#TernaryOperator)
 
 <div STYLE="page-break-after: always;"></div>
 
-## 目录
+## 文档
 
 ### <span id="Bool">Bool</span>
 <p>返回传入参数的bool值.<br/>
@@ -45,7 +46,7 @@ slices和map的length大于0时，返回true，否则返回false<br/>
 ```go
 func Bool[T any](value T) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ETzeDJRSvhm)</span></b>
 
 ```go
 package main
@@ -109,7 +110,7 @@ func main() {
 ```go
 func And[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/W1SSUmt6pvr)</span></b>
 
 ```go
 package main
@@ -135,7 +136,7 @@ func main() {
 ```go
 func Or[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UlQTxHaeEkq)</span></b>
 
 ```go
 package main
@@ -161,7 +162,7 @@ func main() {
 ```go
 func Xor[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gObZrW7ZbG8)</span></b>
 
 ```go
 package main
@@ -187,7 +188,7 @@ func main() {
 ```go
 func Nor[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g2j08F_zZky)</span></b>
 
 ```go
 package main
@@ -213,7 +214,7 @@ func main() {
 ```go
 func Xnor[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OuDB9g51643)</span></b>
 
 ```go
 package main
@@ -239,7 +240,7 @@ func main() {
 ```go
 func Nand[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vSRMLxLIbq8)</span></b>
 
 ```go
 package main
@@ -257,15 +258,51 @@ func main() {
 }
 ```
 
+### <span id="Ternary">Ternary</span>
+<p>三元运算符。</p>
+
+<b>函数签名:</b>
+
+```go
+func Ternary[T, U any](isTrue T, ifValue U, elseValue U) U
+```
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ElllPZY0guT)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+    conditionTrue := 2 > 1
+    result1 := condition.Ternary(conditionTrue, 0, 1)
+
+    conditionFalse := 2 > 3
+    result2 := condition.Ternary(conditionFalse, 0, 1)
+    
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 0
+    // 1
+}
+```
+
 ### <span id="TernaryOperator">TernaryOperator</span>
 <p>三元运算符</p>
 
+> ⚠️ 本函数已弃用，使用`Ternary`代替。
+
 <b>函数签名:</b>
 
 ```go
 func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ElllPZY0guT)</span></b>
 
 ```go
 package main

docs/api/packages/convertor.md

@@ -33,6 +33,9 @@ import (
 -   [ToJson](#ToJson)
 -   [ToMap](#ToMap)
 -   [ToPointer](#ToPointer)
+-   [ToPointers](#ToPointers)
+-   [FromPointer](#FromPointer)
+-   [FromPointers](#FromPointers)
 -   [ToString](#ToString)
 -   [StructToMap](#StructToMap)
 -   [MapToSlice](#MapToSlice)
@@ -43,6 +46,11 @@ import (
 -   [ToInterface](#ToInterface)
 -   [Utf8ToGbk](#Utf8ToGbk)
 -   [GbkToUtf8](#GbkToUtf8)
+-   [ToStdBase64](#ToStdBase64)
+-   [ToUrlBase64](#ToUrlBase64)
+-   [ToRawStdBase64](#ToRawStdBase64)
+-   [ToRawUrlBase64](#ToRawUrlBase64)
+-   [ToBigInt](#ToBigInt)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -58,7 +66,7 @@ import (
 func ColorHexToRGB(colorHex string) (red, green, blue int)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/o7_ft-JCJBV)</span></b>
 
 ```go
 package main
@@ -89,7 +97,7 @@ func main() {
 func ColorRGBToHex(red, green, blue int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nzKS2Ro87J1)</span></b>
 
 ```go
 package main
@@ -122,7 +130,7 @@ func main() {
 func ToBool(s string) (bool, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ARht2WnGdIN)</span></b>
 
 ```go
 package main
@@ -163,7 +171,7 @@ func main() {
 func ToBytes(data any) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fAMXYFDvOvr)</span></b>
 
 ```go
 package main
@@ -196,7 +204,7 @@ func main() {
 func ToChar(s string) []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/JJ1SvbFkVdM)</span></b>
 
 ```go
 package main
@@ -232,7 +240,7 @@ func main() {
 func ToChannel[T any](array []T) <-chan T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hOx_oYZbAnL)</span></b>
 
 ```go
 package main
@@ -269,7 +277,7 @@ func main() {
 func ToFloat(value any) (float64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4YTmPCibqHJ)</span></b>
 
 ```go
 package main
@@ -314,7 +322,7 @@ func main() {
 func ToInt(value any) (int64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9_h9vIt-QZ_b)</span></b>
 
 ```go
 package main
@@ -356,7 +364,7 @@ func main() {
 func ToJson(value any) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2rLIkMmXWvR)</span></b>
 
 ```go
 package main
@@ -368,7 +376,7 @@ import (
 
 func main() {
     aMap := map[string]int{"a": 1, "b": 2, "c": 3}
-    result, err := ToJson(aMap)
+    result, err := convertor.ToJson(aMap)
 
     if err != nil {
         fmt.Printf("%v", err)
@@ -391,7 +399,7 @@ func main() {
 func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tVFy7E-t24l)</span></b>
 
 ```go
 package main
@@ -432,7 +440,7 @@ func main() {
 func ToPointer[T any](value T) *T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ASf_etHNlw1)</span></b>
 
 ```go
 package main
@@ -451,6 +459,108 @@ func main() {
 }
 ```
 
+### <span id="ToPointers">ToPointers</span>
+
+<p>将值的切片转换为指针的切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func ToPointers[T any](values []T) []*T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ZUoXd2i5ZkV)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    strs := []string{"a", "b", "c"}
+	pointerStrs := convertor.ToPointers(strs)
+	fmt.Println(*pointerStrs[0])
+	fmt.Println(*pointerStrs[1])
+	fmt.Println(*pointerStrs[2])
+
+	// Output:
+	// a
+	// b
+	// c
+}
+```
+
+### <span id="FromPointer">FromPointer</span>
+
+<p>返回指针所指向的值。</p>
+
+<b>函数签名:</b>
+
+```go
+func FromPointer[T any](ptr *T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wAp90V7Zu6g)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    str := "abc"
+    strPtr := &str
+	result := convertor.FromPointer(strPtr)
+	fmt.Println(result)
+
+	// Output:
+	// abc
+}
+```
+
+### <span id="FromPointers">FromPointers</span>
+
+<p>将指针的切片转换为值的切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func FromPointers[T any](pointers []*T) []T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qIPsyYtNy3Q)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    strs := []string{"a", "b", "c"}
+    strPtr := []*string{&strs[0], &strs[1], &strs[2]}
+
+	result := convertor.FromPointers(strPtr)
+
+	fmt.Println(result[0])
+    fmt.Println(result[1])
+    fmt.Println(result[2])
+
+	// Output:
+	// a
+    // b
+    // c
+}
+```
+
 ### <span id="ToString">ToString</span>
 
 <p>将值转换为字符串，对于数字、字符串、[]byte，将转换为字符串。 对于其他类型（切片、映射、数组、结构体）将调用 json.Marshal</p>
@@ -461,7 +571,7 @@ func main() {
 func ToString(value any) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nF1zOOslpQq)</span></b>
 
 ```go
 package main
@@ -509,7 +619,7 @@ func main() {
 func StructToMap(value any) (map[string]any, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KYGYJqNUBOI)</span></b>
 
 ```go
 package main
@@ -547,7 +657,7 @@ func main() {
 func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dmX4Ix5V6Wl)</span></b>
 
 ```go
 package main
@@ -577,7 +687,7 @@ func main() {
 func EncodeByte(data any) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DVmM1G5JfuP)</span></b>
 
 ```go
 package main
@@ -606,7 +716,7 @@ func main() {
 func DecodeByte(data []byte, target any) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -642,7 +752,7 @@ func main() {
 func DeepClone[T any](src T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/j4DP5dquxnk)</span></b>
 
 ```go
 package main
@@ -706,7 +816,7 @@ func main() {
 func CopyProperties[T, U any](dst T, src U) (err error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/oZujoB5Sgg5)</span></b>
 
 ```go
 package main
@@ -785,7 +895,7 @@ func main() {
 func ToInterface(v reflect.Value) (value interface{}, ok bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/syqw0-WG7Xd)</span></b>
 
 ```go
 package main
@@ -820,7 +930,7 @@ func main() {
 func Utf8ToGbk(bs []byte) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9FlIaFLArIL)</span></b>
 
 ```go
 package main
@@ -854,7 +964,7 @@ func main() {
 func GbkToUtf8(bs []byte) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OphmHCN_9u8)</span></b>
 
 ```go
 package main
@@ -876,3 +986,302 @@ func main() {
     // hello
 }
 ```
+
+### <span id="ToStdBase64">ToStdBase64</span>
+
+<p>将值转换为StdBase64编码的字符串。error类型的数据也会把error的原因进行编码，复杂的结构会转为JSON格式的字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func ToStdBase64(value any) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_fLJqJD3NMo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    afterEncode := convertor.ToStdBase64(nil)
+    fmt.Println(afterEncode)
+
+    afterEncode = convertor.ToStdBase64("")
+    fmt.Println(afterEncode)
+
+    stringVal := "hello"
+    afterEncode = convertor.ToStdBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToStdBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToStdBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToStdBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode = convertor.ToStdBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToStdBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToStdBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    //
+    //
+    // aGVsbG8=
+    // aGVsbG8=
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
+    // MTIzLjQ1Ng==
+    // dHJ1ZQ==
+    // ZXJy
+}
+
+```
+
+### <span id="ToUrlBase64">ToUrlBase64</span>
+
+<p>值转换为 ToUrlBase64 编码的字符串。error 类型的数据也会把 error 的原因进行编码，复杂的结构会转为 JSON 格式的字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func ToUrlBase64(value any) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/C_d0GlvEeUR)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    afterEncode := convertor.ToUrlBase64(nil)
+    fmt.Println(afterEncode)
+
+
+    stringVal := "hello"
+    afterEncode = convertor.ToUrlBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToUrlBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToUrlBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToUrlBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode = convertor.ToUrlBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToUrlBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToUrlBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    //
+    // aGVsbG8=
+    // aGVsbG8=
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
+    // MTIzLjQ1Ng==
+    // dHJ1ZQ==
+    // ZXJy
+}
+
+```
+
+### <span id="ToRawStdBase64">ToRawStdBase64</span>
+
+<p>值转换为 ToRawStdBase64 编码的字符串。error 类型的数据也会把 error 的原因进行编码，复杂的结构会转为 JSON 格式的字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func ToRawStdBase64(value any) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wSAr3sfkDcv)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+
+    stringVal := "hello"
+    afterEncode = convertor.ToRawStdBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToRawStdBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToRawStdBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToRawStdBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode := convertor.ToRawStdBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToRawStdBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToRawStdBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    // aGVsbG8
+    // aGVsbG8
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
+    // MTIzLjQ1Ng
+    // dHJ1ZQ
+    // ZXJy
+}
+```
+
+### <span id="ToRawUrlBase64">ToRawUrlBase64</span>
+
+<p>值转换为 ToRawUrlBase64 编码的字符串。error 类型的数据也会把 error 的原因进行编码，复杂的结构会转为 JSON 格式的字符串</p>
+
+<b>函数签名:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HwdDPFcza1O)</span></b>
+
+```go
+func ToRawUrlBase64(value any) string
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+
+    stringVal := "hello"
+    afterEncode := convertor.ToRawUrlBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToRawUrlBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToRawUrlBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToRawUrlBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode = convertor.ToRawUrlBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToRawUrlBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToRawUrlBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    // aGVsbG8
+    // aGVsbG8
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
+    // MTIzLjQ1Ng
+    // dHJ1ZQ
+    // ZXJy
+}
+```
+
+### <span id="ToBigInt">ToBigInt</span>
+
+<p>将整数值转换为bigInt。</p>
+
+<b>函数签名:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/X3itkCxwB_x)</span></b>
+
+```go
+func ToBigInt[T any](v T) (*big.Int, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    n := 9876543210
+    bigInt, _ := convertor.ToBigInt(n)
+
+    fmt.Println(bigInt)
+    // Output:
+    // 9876543210
+}
+```

docs/api/packages/datastructure/copyonwritelist.md

@@ -26,6 +26,8 @@ import (
 -   [Remove](#Remove)
 -   [IndexOf](#IndexOf)
 -   [LastIndexOf](#LastIndexOf)
+-   [IndexOfFunc](#IndexOfFunc)
+-   [LastIndexOfFunc](#LastIndexOfFunc)
 -   [IsEmpty](#IsEmpty)
 -   [Contain](#Contain)
 -   [ValueOf](#ValueOf)
@@ -198,6 +200,58 @@ func main()  {
 
 ```
 
+### <span id="IndexOfFunc">IndexOfFunc</span>
+<p>返回第一个满足判断函数f(v)的元素的索引，如果找不到则返回-1。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *CopyOnWriteList[T]) IndexOfFunc(f func(T) bool) int 
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1, 2, 3})
+
+    fmt.Println(l.IndexOfFunc(func(a int) bool { return a == 1 })) //0
+    fmt.Println(l.IndexOfFunc(func(a int) bool { return a == 0 })) //-1
+}
+```
+
+### <span id="LastIndexOfFunc">LastIndexOfFunc</span>
+<p>返回最后一个满足判断函数f(v)的元素的索引，如果找不到则返回-1。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *CopyOnWriteList[T]) LastIndexOfFunc(f func(T) bool) int
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1, 2, 3, 1})
+
+    fmt.Println(l.LastIndexOfFunc(func(a int) bool { return a == 1 })) // 3
+    fmt.Println(l.LastIndexOfFunc(func(a int) bool { return a == 0 })) //-1
+}
+```
+
 ### IsEmpty
 
 如果此列表不包含任何元素，则返回 true。

docs/api/packages/datastructure/hashmap.md

@@ -31,6 +31,7 @@ import (
 - [Iterate](#Iterate)
 - [Keys](#Keys)
 - [Values](#Values)
+- [FilterByValue](#FilterByValue)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -38,7 +39,7 @@ import (
 
 ### <span id="NewHashMap">NewHashMap</span>
 
-<p>新建默认容量（1 << 10）的HashMap指针实例</p>
+<p>新建默认容量（1 &lt&lt 10）的HashMap指针实例</p>
 
 <b>函数签名:</b>
 
@@ -276,7 +277,7 @@ func main() {
 
 ### <span id="Values">Values</span>
 
-<p>返回hashmap所有值的切片 (随机顺序).</p>
+<p>返回hashmap所有值的切片 (随机顺序)。</p>
 
 <b>函数签名:</b>
 
@@ -306,3 +307,40 @@ func main() {
 ```
 
 
+### <span id="FilterByValue">FilterByValue</span>
+
+<p>返回一个过滤后的HashMap。 如果任何值与 perdicate 函数不匹配，则返回 nil，否则返回包含选定值的 HashMap。</p>
+
+<b>函数签名:</b>
+
+```go
+func (hm *HashMap) FilterByValue(perdicate func(value any) bool) *HashMap
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := hashmap.NewHashMap()
+
+    hm.Put("a", 1)
+    hm.Put("b", 2)
+    hm.Put("c", 3)
+    hm.Put("d", 4)
+    hm.Put("e", 5)
+    hm.Put("f", 6)
+
+    filteredHM := hm.FilterByValue(func(value any) bool {
+        return value.(int) == 1 || value.(int) == 3
+    })
+
+    fmt.Println(filteredHM.Size()) //2
+}
+```

docs/api/packages/datastructure/heap.md

@@ -44,9 +44,9 @@ MaxHeap是通过slice实现的二叉堆树，根节点的key既大于等于左
 ```go
 type MaxHeap[T any] struct {
 	data       []T
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
-func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T]
+func NewMaxHeap[T any](comparator constraints.Comparator) *MaxHeap[T]
 ```
 <b>示例:</b>
 

docs/api/packages/datastructure/optional.md

@@ -0,0 +1,412 @@
+# Optional
+Optional类型代表一个可选的值，它要么包含一个实际值，要么为空。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/optional/optional.go](https://github.com/duke-git/lancet/blob/main/datastructure/optional/optional.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法
+```go
+import (
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+- [Of](#Of)
+- [FromNillable](#FromNillable)
+- [Default](#Default)
+- [IsNotNil](#IsNotNil)
+- [IsNil](#IsNil)
+- [IsNotNil](#IsNotNil)
+- [IfNotNilOrElse](#IfNotNilOrElse)
+- [Umwarp](#Umwarp)
+- [OrElse](#OrElse)
+- [OrElseGet](#OrElseGet)
+- [OrElseTrigger](#OrElseTrigger)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="Of">Of</span>
+<p>返回一个包含非空值的Optional。</p>
+
+<b>函数签名:</b>
+
+```go
+func Of[T any](value T) Optional[T]
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    value := 42
+    opt := optional.Of(value)
+
+    fmt.Println(opt.Get())
+
+    // Output:
+    // 42
+}
+```
+
+### <span id="FromNillable">FromNillable</span>
+<p>返回一个包含给定值的Optional，该值可能为空 (nil)。</p>
+
+<b>函数签名:</b>
+
+```go
+func FromNillable[T any](value *T) Optional[T]
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    var value *int = nil
+    opt := optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+    value = new(int)
+    *value = 42
+    opt = optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+
+    // Output:
+    // false
+    // true
+}
+```
+
+
+### <span id="Default">Default</span>
+<p>返回一个空Optional实例。</p>
+
+<b>函数签名:</b>
+
+```go
+func Default[T any]() Optional[T]
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    fmt.Println(optDefault.IsNil())
+
+    // Output:
+    // true
+}
+```
+
+
+### <span id="IsNil">IsNil</span>
+<p>验证Optional是否为空。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) IsNil() bool
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    fmt.Println(optDefault.IsNil())
+
+    // Output:
+    // true
+}
+```
+
+### <span id="IsNotNil">IsNotNil</span>
+<p>检查当前Optional内是否存在值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) IsNotNil() bool
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    var value *int = nil
+    opt := optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+    value = new(int)
+    *value = 42
+    opt = optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+
+    // Output:
+    // false
+    // true
+}
+```
+
+### <span id="IfNotNil">IfNotNil</span>
+<p>如果值存在，则使用action方法执行给定的操作。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) IfNotNil(action func(value T))
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+     "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    called := false
+    action := func(value int) { called = true }
+
+    optDefault := optional.Default[int]()
+    optDefault.IfNotNil(action)
+
+    fmt.Println(called)
+
+    called = false // Reset for next test
+    optWithValue := optional.Of(42)
+    optWithValue.IfNotNil(action)
+
+    fmt.Println(optWithValue.IsNotNil())
+
+    // Output:
+    // false
+    // true
+}
+```
+
+
+### <span id="IfNotNilOrElse">IfNotNilOrElse</span>
+<p>根据是否存在值执行相应的操作：有值则执行指定操作，没有值则执行默认操作。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) IfNotNilOrElse(action func(value T), fallbackAction func())
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    calledWithValue := false
+    valueAction := func(value int) { calledWithValue = true }
+    emptyAction := func() { t.Errorf("Empty action should not be called when value is present") }
+
+    optWithValue := optional.Of(42)
+    optWithValue.IfNotNilOrElse(valueAction, emptyAction)
+
+    fmt.Println(calledWithValue)
+
+    calledWithEmpty := false
+    valueAction = func(value int) { t.Errorf("Value action should not be called when value is not present") }
+    emptyAction = func() { calledWithEmpty = true }
+
+    optDefault := optional.Default[int]()
+    optDefault.IfNotNilOrElse(valueAction, emptyAction)
+
+    fmt.Println(calledWithEmpty)
+
+    // Output:
+    // true
+    // true
+}
+```
+
+### <span id="Unwrap">Unwrap</span>
+<p>如果存在，返回该值，否则引发panic。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) Unwrap() T
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    value := 42
+    opt := optional.Of(value)
+
+    fmt.Println(opt.Unwrap())
+
+    // Output:
+    // 42
+}
+```
+
+
+### <span id="OrElse">OrElse</span>
+<p>检查Optional值是否存在，如果存在，则直接返回该值。如果不存在，返回参数other值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) OrElse(other T) T
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Empty[int]()
+    val := optDefault.OrElse(100)
+    fmt.Println(val)
+
+    optWithValue := optional.Of(42)
+    val = optWithValue.OrElse(100)
+    fmt.Println(val)
+
+    // Output:
+    // 100
+    // 42
+}
+```
+
+
+### <span id="OrElseGet">OrElseGet</span>
+<p>检查Optional值是否存在，如果存在，则直接返回该值。如果不存在，则调用一个提供的函数 (supplier)，并返回该函数的执行结果。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) OrElseGet(action func() T) T
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    action := func() int { return 100 }
+
+    val := optDefault.OrElseGet(action)
+    fmt.Println(val)
+
+    // Output:
+    // 100
+}
+```
+
+### <span id="OrElseTrigger">OrElseTrigger</span>
+<p>检查Optional值是否存在，如果存在，则直接返回该值，否则返回错误。</p>
+
+<b>函数签名:</b>
+
+```go
+ OrElseTrigger(errorHandler func() error) (T, error)
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    _, err := optDefault.OrElseTrigger(func() error { return errors.New("no value") })
+    
+    fmt.Println(err.Error())
+
+    optWithValue := optional.Of(42)
+    val, err := optWithValue.OrElseTrigger(func() error { return errors.New("no value") })
+
+    fmt.Println(val)
+    fmt.Println(err)
+
+    // Output:
+    // no value
+    // 42
+    // nil
+}
+```

docs/api/packages/datastructure/queue.md

@@ -1092,7 +1092,7 @@ func main() {
 
 
 ### 4. PriorityQueue
-切片实现的额优先级队列。
+切片实现的优先级队列。
 
 ### <span id="NewPriorityQueue">NewPriorityQueue</span>
 <p>返回一个具有特定容量的PriorityQueue指针，参数 `comarator` 用于比较队列中T类型的值。</p>
@@ -1100,12 +1100,12 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func NewPriorityQueue[T any](capacity int, comparator lancetconstraints.Comparator) *PriorityQueue[T]
+func NewPriorityQueue[T any](capacity int, comparator constraints.Comparator) *PriorityQueue[T]
 
 type PriorityQueue[T any] struct {
 	items      []T
 	size       int
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
 ```
 <b>示例:</b>

docs/api/packages/datastructure/set.md

@@ -1,6 +1,6 @@
 # Set
 
-Set 集合数据结构，类似列表。Set 中元素不重复。
+集合数据结构，类似列表。Set中元素不重复。
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -22,9 +22,9 @@ import (
 
 ## 目录
 
--   [NewSet](#NewSet)
--   [NewSetFromSlice](#NewSetFromSlice)
--   [Values](#Values)
+-   [New](#New)
+-   [FromSlice](#FromSlice)
+-   [Values<sup>deprecated</sup>](#Values)
 -   [Add](#Add)
 -   [AddIfNotExist](#AddIfNotExist)
 -   [AddIfNotExistBy](#AddIfNotExistBy)
@@ -40,20 +40,23 @@ import (
 -   [Intersection](#Intersection)
 -   [SymmetricDifference](#SymmetricDifference)
 -   [Minus](#Minus)
+-   [Pop](#Pop)
+-   [ToSlice](#ToSlice)
+-   [ToSortedSlice](#ToSortedSlice)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
-### <span id="NewSet">NewSet</span>
+### <span id="New">New</span>
 
 <p>返回Set结构体对象</p>
 
 <b>函数签名:</b>
 
 ```go
-type Set[T comparable] map[T]bool
-func NewSet[T comparable](items ...T) Set[T]
+type Set[T comparable] map[T]struct{}
+func New[T comparable](items ...T) Set[T]
 ```
 
 <b>示例:</b>
@@ -67,19 +70,19 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int](1,2,2,3)
+    st := set.New[int](1,2,2,3)
     fmt.Println(st.Values()) //1,2,3
 }
 ```
 
-### <span id="NewSetFromSlice">NewSetFromSlice</span>
+### <span id="FromSlice">FromSlice</span>
 
 <p>基于切片创建集合</p>
 
 <b>函数签名:</b>
 
 ```go
-func NewSetFromSlice[T comparable](items []T) Set[T]
+func FromSlice[T comparable](items []T) Set[T]
 ```
 
 <b>示例:</b>
@@ -93,14 +96,16 @@ import (
 )
 
 func main() {
-    st := set.NewSetFromSlice([]int{1, 2, 2, 3})
+    st := set.FromSlice([]int{1, 2, 2, 3})
     fmt.Println(st.Values()) //1,2,3
 }
 ```
 
 ### <span id="Values">Values</span>
 
-<p>获取集合中所有元素的切片</p>
+<p>获取集合中所有元素的切片。</p>
+
+> ⚠️ 本函数已弃用，使用`ToSlice`代替。
 
 <b>函数签名:</b>
 
@@ -119,7 +124,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int](1,2,2,3)
+    st := set.New[int](1,2,2,3)
     fmt.Println(st.Values()) //1,2,3
 }
 ```
@@ -145,7 +150,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     fmt.Println(st.Values()) //1,2,3
@@ -173,7 +178,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     r1 := st.AddIfNotExist(1)
@@ -206,7 +211,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2)
 
     ok := st.AddIfNotExistBy(3, func(val int) bool {
@@ -245,7 +250,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     set.Delete(3)
@@ -274,7 +279,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     fmt.Println(st.Contain(1)) //true
@@ -303,9 +308,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(1, 2)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(1, 2)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.ContainAll(set2)) //true
     fmt.Println(set1.ContainAll(set3)) //false
@@ -333,7 +338,7 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
 
     fmt.Println(set1.Size()) //3
 }
@@ -360,7 +365,7 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
     set2 := set1.Clone()
 
     fmt.Println(set1.Size() == set2.Size()) //true
@@ -389,9 +394,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(1, 2, 3)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(1, 2, 3)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.Equal(set2)) //true
     fmt.Println(set1.Equal(set3)) //false
@@ -419,7 +424,7 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
     arr := []int{}
     set.Iterate(func(item int) {
         arr = append(arr, item)
@@ -450,7 +455,7 @@ import (
 )
 
 func main() {
-    s := set.NewSet(1, 2, 3, 4, 5)
+    s := set.New(1, 2, 3, 4, 5)
 
     var sum int
 
@@ -487,8 +492,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet()
+    set1 := set.New(1, 2, 3)
+    set2 := set.New()
 
     fmt.Println(set1.IsEmpty()) //false
     fmt.Println(set2.IsEmpty()) //true
@@ -516,8 +521,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Union(set2)
 
     fmt.Println(set3.Values()) //1,2,3,4,5
@@ -545,8 +550,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Intersection(set2)
 
     fmt.Println(set3.Values()) //2,3
@@ -574,8 +579,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.SymmetricDifference(set2)
 
     fmt.Println(set3.Values()) //1,4,5
@@ -603,9 +608,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set.NewSet(2, 3)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
+    set3 := set.New(2, 3)
 
     res1 := set1.Minus(set2)
     fmt.Println(res1.Values()) //1
@@ -636,7 +641,7 @@ import (
 )
 
 func main() {
-    s := set.NewSet[int]()
+    s := set.New[int]()
     s.Add(1)
     s.Add(2)
     s.Add(3)
@@ -647,3 +652,58 @@ func main() {
     fmt.Println(ok) // true
 }
 ```
+
+### <span id="ToSlice">ToSlice</span>
+
+<p>以切片的形式返回集合中所有的元素（无序）</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) ToSlice() (v T, ok bool)
+```
+
+<b>示例:</b>
+
+```go
+func main() {
+    s := set.New(1, 2, 3, 4, 5)
+
+    val := s.ToSlice()
+    fmt.Println(val) // [2 3 4 5 1]
+}
+```
+
+### <span id="ToSortedSlice">ToSortedSlice</span>
+
+<p>以切片的形式返回集合中所有的元素（按给定的规则排序）</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) ToSortedSlice() (v T, ok bool)
+```
+
+<b>示例:</b>
+
+```go
+func main() {
+    s1 := set.New(1, 2, 3, 4, 5)
+    type Person struct {
+		Name string
+		Age  int
+	}
+	s2 := FromSlice([]Person{{"Tom", 20}, {"Jerry", 18}, {"Spike", 25}})
+
+    res1 := s1.ToSortedSlice(func(v1, v2 int) bool {
+		return v1 < v2
+	})
+    
+    res2 := s2.ToSortedSlice(func(v1, v2 Person) bool {
+		return v1.Age < v2.Age
+	})
+    
+    fmt.Println(res1) // [1 2 3 4 5]
+    fmt.Println(res2) // [{Jerry 18} {Tom 20} {Spike 25}]
+}
+```

docs/api/packages/datastructure/tree.md

@@ -41,7 +41,7 @@ import (
 ## 文档
 
 ## 1. BSTree
-BSTree是一种二叉搜索树数据结构，其中每个节点有两个孩子，分别称为左孩子和右孩子。 在 BSTree 中：leftNode < rootNode < rightNode。 T类型应该实现lancetconstraints.Comparator。
+BSTree是一种二叉搜索树数据结构，其中每个节点有两个孩子，分别称为左孩子和右孩子。 在 BSTree 中：leftNode < rootNode < rightNode。 T类型应该实现constraints.Comparator。
 
 ### <span id="NewBSTree">NewBSTree</span>
 <p>返回BSTree指针实例</p>
@@ -49,11 +49,11 @@ BSTree是一种二叉搜索树数据结构，其中每个节点有两个孩子
 <b>函数签名:</b>
 
 ```go
-func NewBSTree[T any](rootData T, comparator lancetconstraints.Comparator) *BSTree[T]
+func NewBSTree[T any](rootData T, comparator constraints.Comparator) *BSTree[T]
 
 type BSTree[T any] struct {
 	root       *datastructure.TreeNode[T]
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
 
 type TreeNode[T any] struct {

docs/api/packages/datetime.md

@@ -23,9 +23,14 @@ import (
 ## 目录
 
 -   [AddDay](#AddDay)
+-   [AddWeek](#AddWeek)
+-   [AddMonth](#AddMonth)
 -   [AddHour](#AddHour)
 -   [AddMinute](#AddMinute)
 -   [AddYear](#AddYear)
+-   [AddDaySafe](#AddDaySafe)
+-   [AddMonthSafe](#AddMonthSafe)
+-   [AddYearSafe](#AddYearSafe)
 -   [BeginOfMinute](#BeginOfMinute)
 -   [BeginOfHour](#BeginOfHour)
 -   [BeginOfDay](#BeginOfDay)
@@ -64,6 +69,12 @@ import (
 -   [TimestampMilli](#TimestampMilli)
 -   [TimestampMicro](#TimestampMicro)
 -   [TimestampNano](#TimestampNano)
+-   [TrackFuncTime](#TrackFuncTime)
+-   [DaysBetween](#DaysBetween)
+-   [GenerateDatetimesBetween](#GenerateDatetimesBetween)
+-   [Min](#Min)
+-   [Max](#Max)
+-   [MaxMin](#MaxMin)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -103,10 +114,10 @@ import (
 <b>函数签名:</b>
 
 ```go
-func AddDay(t time.Time, day int64) time.Time
+func AddDay(t time.Time, days int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dIGbs_uTdFa)</span></b>
 
 ```go
 package main
@@ -118,20 +129,89 @@ import (
 )
 
 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")
 
-    tomorrow := datetime.AddDay(now, 1)
-    diff1 := tomorrow.Sub(now)
+    after1Day := datetime.AddDay(date, 1)
+    before1Day := datetime.AddDay(date, -1)
 
-    yesterday := datetime.AddDay(now, -1)
-    diff2 := yesterday.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after1Day.Format("2006-01-02 15:04:05"))
+    fmt.Println(before1Day.Format("2006-01-02 15:04:05"))
 
     // Output:
-    // 24h0m0s
-    // -24h0m0s
+    // 2021-01-02 00:00:00
+    // 2020-12-31 00:00:00
+}
+```
+
+### <span id="AddWeek">AddWeek</span>
+
+<p>将日期加/减星期数。</p>
+
+<b>函数签名:</b>
+
+```go
+func AddWeek(t time.Time, weeks int64) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/M9TqdMiaA2p)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date, _ := time.Parse("2006-01-02", "2021-01-01")
+
+    after2Weeks := datetime.AddWeek(date, 2)
+    before2Weeks := datetime.AddWeek(date, -2)
+
+    fmt.Println(after2Weeks.Format("2006-01-02"))
+    fmt.Println(before2Weeks.Format("2006-01-02"))
+
+    // Output:
+    // 2021-01-15
+    // 2020-12-18
+}
+```
+
+### <span id="AddMonth">AddMonth</span>
+
+<p>将日期加/减月数。</p>
+
+<b>函数签名:</b>
+
+```go
+func AddMonth(t time.Time, months int64) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DLoiOnpLvsN)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date, _ := time.Parse("2006-01-02", "2021-01-01")
+
+    after2Months := datetime.AddMonth(date, 2)
+    before2Months := datetime.AddMonth(date, -2)
+
+    fmt.Println(after2Months.Format("2006-01-02"))
+    fmt.Println(before2Months.Format("2006-01-02"))
+
+    // Output:
+    // 2021-03-01
+    // 2020-11-01
 }
 ```
 
@@ -142,10 +222,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func AddHour(t time.Time, hour int64) time.Time
+func AddHour(t time.Time, hours int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/rcMjd7OCsi5)</span></b>
 
 ```go
 package main
@@ -157,20 +237,17 @@ import (
 )
 
 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")
 
-    after2Hours := datetime.AddHour(now, 2)
-    diff1 := after2Hours.Sub(now)
+    after2Hours := datetime.AddHour(date, 2)
+    before2Hours := datetime.AddHour(date, -2)
 
-    before2Hours := datetime.AddHour(now, -2)
-    diff2 := before2Hours.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after2Hours.Format("2006-01-02 15:04:05"))
+    fmt.Println(before2Hours.Format("2006-01-02 15:04:05"))
 
     // Output:
-    // 2h0m0s
-    // -2h0m0s
+    // 2021-01-01 02:00:00
+    // 2020-12-31 22:00:00
 }
 ```
 
@@ -181,10 +258,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func AddMinute(t time.Time, minute int64) time.Time
+func AddMinute(t time.Time, minutes int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nT1heB1KUUK)</span></b>
 
 ```go
 package main
@@ -196,20 +273,17 @@ import (
 )
 
 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")
 
-    after2Minutes := datetime.AddMinute(now, 2)
-    diff1 := after2Minutes.Sub(now)
+    after2Minutes := datetime.AddMinute(date, 2)
+    before2Minutes := datetime.AddMinute(date, -2)
 
-    before2Minutes := datetime.AddMinute(now, -2)
-    diff2 := before2Minutes.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after2Minutes.Format("2006-01-02 15:04:05"))
+    fmt.Println(before2Minutes.Format("2006-01-02 15:04:05"))
 
     // Output:
-    // 2m0s
-    // -2m0s
+    // 2021-01-01 00:02:00
+    // 2020-12-31 23:58:00
 }
 ```
 
@@ -220,10 +294,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func AddYear(t time.Time, year int64) time.Time
+func AddYear(t time.Time, years int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/MqW2ujnBx10)</span></b>
 
 ```go
 package main
@@ -235,20 +309,137 @@ import (
 )
 
 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02", "2021-01-01")
 
-    after1Year := datetime.AddYear(now, 1)
-    diff1 := after1Year.Sub(now)
+    after2Years := AddYear(date, 2)
+    before2Years := AddYear(date, -2)
 
-    before1Year := datetime.AddYear(now, -1)
-    diff2 := before1Year.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after2Years.Format("2006-01-02"))
+    fmt.Println(before2Years.Format("2006-01-02"))
 
     // Output:
-    // 8760h0m0s
-    // -8760h0m0s
+    // 2023-01-01
+    // 2019-01-01
+}
+```
+
+### <span id="AddDaySafe">AddDaySafe</span>
+
+<p>增加/减少指定的天数，并确保日期是有效日期。</p>
+
+<b>函数签名:</b>
+
+```go
+func AddDaySafe(t time.Time, days int) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/JTohZFpoDJ3)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    leapYearDate1, _ := time.Parse("2006-01-02", "2024-02-29")
+    result1 := datetime.AddDaySafe(leapYearDate1, 1)
+
+    leapYearDate2, _ := time.Parse("2006-01-02", "2024-03-01")
+    result2 := datetime.AddDaySafe(leapYearDate2, -1)
+
+    nonLeapYearDate1, _ := time.Parse("2006-01-02", "2025-02-28")
+    result3 := datetime.AddDaySafe(nonLeapYearDate1, 1)
+
+    nonLeaYearDate2, _ := time.Parse("2006-01-02", "2025-03-01")
+    result4 := datetime.AddDaySafe(nonLeaYearDate2, -1)
+
+    fmt.Println(result1.Format("2006-01-02"))
+    fmt.Println(result2.Format("2006-01-02"))
+    fmt.Println(result3.Format("2006-01-02"))
+    fmt.Println(result4.Format("2006-01-02"))
+
+    // Output:
+    // 2024-03-01
+    // 2024-02-29
+    // 2025-03-01
+    // 2025-02-28
+}
+```
+
+### <span id="AddMonthSafe">AddMonthSafe</span>
+
+<p>增加/减少指定的月份，并确保日期是有效日期。</p>
+
+<b>函数签名:</b>
+
+```go
+func AddMonthSafe(t time.Time, months int) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KLw0lo6mbVW)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date1, _ := time.Parse("2006-01-02", "2025-01-31")
+    result1 := datetime.AddMonthSafe(date1, 1)
+
+    date2, _ := time.Parse("2006-01-02", "2024-02-29")
+    result2 := datetime.AddMonthSafe(date2, -1)
+
+    fmt.Println(result1.Format("2006-01-02"))
+    fmt.Println(result2.Format("2006-01-02"))
+
+    // Output:
+    // 2025-02-28
+    // 2024-01-29
+}
+```
+
+### <span id="AddYearSafe">AddYearSafe</span>
+
+<p>增加/减少指定的年份，并确保日期是有效日期。</p>
+
+<b>函数签名:</b>
+
+```go
+func AddYearSafe(t time.Time, years int) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KVGXWZZ54ZH)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date, _ := time.Parse("2006-01-02", "2020-02-29")
+
+    result1 := datetime.AddYearSafe(date, 1)
+    result2 := datetime.AddYearSafe(date, -1)
+
+    fmt.Println(result1.Format("2006-01-02"))
+    fmt.Println(result2.Format("2006-01-02"))
+
+    // Output:
+    // 2021-02-28
+    // 2019-02-28
 }
 ```
 
@@ -262,7 +453,7 @@ func main() {
 func BeginOfMinute(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ieOLVJ9CiFT)</span></b>
 
 ```go
 package main
@@ -294,7 +485,7 @@ func main() {
 func BeginOfHour(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GhdGFnDWpYs)</span></b>
 
 ```go
 package main
@@ -326,7 +517,7 @@ func main() {
 func BeginOfDay(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/94m_UT6cWs9)</span></b>
 
 ```go
 package main
@@ -355,10 +546,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func BeginOfWeek(t time.Time, beginFrom ...time.Weekday) time.Time
+func BeginOfWeek(t time.Time, beginFrom time.Weekday) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ynjoJPz7VNV)</span></b>
 
 ```go
 package main
@@ -371,12 +562,12 @@ import (
 
 func main() {
     input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-    result := datetime.BeginOfWeek(input)
+    result := datetime.BeginOfWeek(input, time.Monday)
 
     fmt.Println(result)
 
     // Output:
-    // 2023-01-08 00:00:00 +0000 UTC
+    // 2023-01-09 00:00:00 +0000 UTC
 }
 ```
 
@@ -390,7 +581,7 @@ func main() {
 func BeginOfMonth(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bWXVFsmmzwL)</span></b>
 
 ```go
 package main
@@ -422,7 +613,7 @@ func main() {
 func BeginOfYear(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/i326DSwLnV8)</span></b>
 
 ```go
 package main
@@ -454,7 +645,7 @@ func main() {
 func EndOfMinute(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/yrL5wGzPj4z)</span></b>
 
 ```go
 package main
@@ -486,7 +677,7 @@ func main() {
 func EndOfHour(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6ce3j_6cVqN)</span></b>
 
 ```go
 package main
@@ -518,7 +709,7 @@ func main() {
 func EndOfDay(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eMBOvmq5Ih1)</span></b>
 
 ```go
 package main
@@ -536,7 +727,7 @@ func main() {
     fmt.Println(result)
 
     // Output:
-    // 2023-01-08 23:59:59.999999999 +0000 UTC
+    // 2023-01-02 00:00:00 +0000 UTC
 }
 ```
 
@@ -547,10 +738,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func EndOfWeek(t time.Time, endWith ...time.Weekday) time.Time
+func EndOfWeek(t time.Time, endWith time.Weekday) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mGSA162YgX9)</span></b>
 
 ```go
 package main
@@ -563,12 +754,12 @@ import (
 
 func main() {
     input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-    result := datetime.EndOfWeek(input)
+    result := datetime.EndOfWeek(input, time.Sunday)
 
     fmt.Println(result)
 
     // Output:
-    // 2023-01-14 23:59:59.999999999 +0000 UTC
+    // 2023-01-08 23:59:59.999999999 +0000 UTC
 }
 ```
 
@@ -582,7 +773,7 @@ func main() {
 func EndOfMonth(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_GWh10B3Nqi)</span></b>
 
 ```go
 package main
@@ -614,7 +805,7 @@ func main() {
 func EndOfYear(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/G01cKlMCvNm)</span></b>
 
 ```go
 package main
@@ -646,7 +837,7 @@ func main() {
 func GetNowDate() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/PvfkPpcpBBf)</span></b>
 
 ```go
 package main
@@ -675,7 +866,7 @@ func main() {
 func GetNowTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/l7BNxCkTmJS)</span></b>
 
 ```go
 package main
@@ -704,7 +895,7 @@ func main() {
 func GetNowDateTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pI4AqngD0al)</span></b>
 
 ```go
 package main
@@ -733,7 +924,7 @@ func main() {
 func GetTodayStartTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/84siyYF7t99)</span></b>
 
 ```go
 package main
@@ -762,7 +953,7 @@ func main() {
 func GetTodayEndTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jjrLnfoqgn3)</span></b>
 
 ```go
 package main
@@ -791,7 +982,7 @@ func main() {
 func GetZeroHourTimestamp() int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/QmL2oIaGE3q)</span></b>
 
 ```go
 package main
@@ -820,7 +1011,7 @@ func main() {
 func GetNightTimestamp() int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UolysR3MYP1)</span></b>
 
 ```go
 package main
@@ -849,7 +1040,7 @@ func main() {
 func FormatTimeToStr(t time.Time, format string, timezone ...string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_Ia7M8H_OvE)</span></b>
 
 ```go
 package main
@@ -888,7 +1079,7 @@ func main() {
 func FormatStrToTime(str, format string, timezone ...string) (time.Time, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1h9FwdU8ql4)</span></b>
 
 ```go
 package main
@@ -927,7 +1118,7 @@ type theTime struct {
 func NewUnixNow() *theTime
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/U4PPx-9D0oz)</span></b>
 
 ```go
 package main
@@ -959,7 +1150,7 @@ type theTime struct {
 func NewUnix(unix int64) *theTime
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/psoSuh_kLRt)</span></b>
 
 ```go
 package main
@@ -991,7 +1182,7 @@ type theTime struct {
 func NewFormat(t string) (*theTime, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VkW08ZOaXPZ)</span></b>
 
 ```go
 package main
@@ -1023,7 +1214,7 @@ type theTime struct {
 func NewISO8601(iso8601 string) (*theTime, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mkhOHQkdeA2)</span></b>
 
 ```go
 package main
@@ -1052,7 +1243,7 @@ func main() {
 func (t *theTime) ToUnix() int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_LUiwAdocjy)</span></b>
 
 ```go
 package main
@@ -1081,7 +1272,7 @@ func main() {
 func (t *theTime) ToFormat() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VkW08ZOaXPZ)</span></b>
 
 ```go
 package main
@@ -1110,7 +1301,7 @@ func main() {
 func (t *theTime) ToFormatForTpl(tpl string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nyXxXcQJ8L5)</span></b>
 
 ```go
 package main
@@ -1140,7 +1331,7 @@ func main() {
 func (t *theTime) ToIso8601() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mkhOHQkdeA2)</span></b>
 
 ```go
 package main
@@ -1170,7 +1361,7 @@ func main() {
 func IsLeapYear(year int) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xS1eS2ejGew)</span></b>
 
 ```go
 package main
@@ -1203,7 +1394,7 @@ func main() {
 func BetweenSeconds(t1 time.Time, t2 time.Time) int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/n3YDRyfyXJu)</span></b>
 
 ```go
 package main
@@ -1240,7 +1431,7 @@ func main() {
 func DayOfYear(t time.Time) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/0hjqhTwFNlH)</span></b>
 
 ```go
 package main
@@ -1281,7 +1472,7 @@ func main() {
 func IsWeekend(t time.Time) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cupRM5aZOIY)</span></b>
 
 ```go
 package main
@@ -1321,7 +1512,7 @@ func main() {
 func NowDateOrTime(format string, timezone ...string) string
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EZ-begEjtT0)</span></b>
 
 ```go
 package main
@@ -1334,7 +1525,7 @@ import (
 func main() {
     result1 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss")
 
-	result2 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss", "EST")
+    result2 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss", "EST")
 
     fmt.Println(result1)
     fmt.Println(result2)
@@ -1355,7 +1546,7 @@ func main() {
 func Timestamp(timezone ...string) int64
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/iU5b7Vvjx6x)</span></b>
 
 ```go
 package main
@@ -1386,7 +1577,7 @@ func main() {
 func TimestampMilli(timezone ...string) int64
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4gvEusOTu1T)</span></b>
 
 ```go
 package main
@@ -1416,7 +1607,7 @@ func main() {
 func TimestampMicro(timezone ...string) int64
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2maANglKHQE)</span></b>
 
 ```go
 package main
@@ -1446,7 +1637,7 @@ func main() {
 func TimestampNano(timezone ...string) int64
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/A9Oq_COrcCF)</span></b>
 
 ```go
 package main
@@ -1464,4 +1655,199 @@ func main() {
     // Output:
     // 1690363051331788000
 }
+```
+
+### <span id="TrackFuncTime">TrackFuncTime</span>
+
+<p>测试函数执行时间。</p>
+
+<b>函数签名:</b>
+
+```go
+func TrackFuncTime(pre time.Time) func()
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/QBSEdfXHPTp)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    defer datetime.TrackFuncTime(time.Now())()
+
+    var n int
+    for i := 0; i < 5000000; i++ {
+        n++
+    }
+
+    fmt.Println(1) // Function main execution time:     1.460287ms
+}
+```
+
+### <span id="DaysBetween">DaysBetween</span>
+
+<p>返回两个日期之间的天数差。</p>
+
+<b>函数签名:</b>
+
+```go
+func DaysBetween(start, end time.Time) int
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qD6qGb3TbOy)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    start := time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC)
+    end := time.Date(2024, time.September, 10, 0, 0, 0, 0, time.UTC)
+
+    result := datetime.DaysBetween(start, end)
+
+    fmt.Println(result)
+
+    // Output:
+    // 9
+}
+```
+
+### <span id="GenerateDatetimesBetween">GenerateDatetimesBetween</span>
+
+<p>生成从start到end的所有日期时间的字符串列表。layout参数表示时间格式，例如"2006-01-02 15:04:05"，interval参数表示时间间隔，例如"1h"表示1小时，"30m"表示30分钟。</p>
+
+<b>函数签名:</b>
+
+```go
+func GenerateDatetimesBetween(start, end time.Time, layout string, interval string) ([]string, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6kHBpAxD9ZC)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    start := time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC)
+    end := time.Date(2024, time.September, 1, 2, 0, 0, 0, time.UTC)
+
+    layout := "2006-01-02 15:04:05"
+    interval := "1h"
+
+    result, err := datetime.GenerateDatetimesBetween(start, end, layout, interval)
+
+    fmt.Println(result)
+    fmt.Println(err)
+
+    // Output:
+    // [2024-09-01 00:00:00 2024-09-01 01:00:00 2024-09-01 02:00:00]
+    // <nil>
+}
+```
+
+### <span id="Min">Min</span>
+
+<p>返回最早时间。</p>
+
+<b>函数签名:</b>
+
+```go
+func Min(t1 time.Time, times ...time.Time) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/MCIDvHNOGGb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    minTime := datetime.Min(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(minTime)
+
+	// Output:
+	// 2024-09-01 00:00:00 +0000 UTC
+}
+```
+
+### <span id="Max">Max</span>
+
+<p>返回最晚时间。</p>
+
+<b>函数签名:</b>
+
+```go
+func Max(t1 time.Time, times ...time.Time) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9m6JMk1LB7-)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    maxTime := datetime.Min(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(maxTime)
+
+	// Output:
+	// 2024-09-02 00:00:00 +0000 UTC
+}
+```
+
+### <span id="MaxMin">MaxMin</span>
+
+<p>返回最早和最晚时间。</p>
+
+<b>函数签名:</b>
+
+```go
+func MaxMin(t1 time.Time, times ...time.Time) (maxTime time.Time, minTime time.Time)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/rbW51cDtM_2)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    max, min := datetime.MaxMin(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 3, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(max)
+	fmt.Println(min)
+
+	// Output:
+	// 2024-09-03 00:00:00 +0000 UTC
+	// 2024-09-01 00:00:00 +0000 UTC
+}
 ```

docs/api/packages/enum.md

@@ -0,0 +1,850 @@
+# Enum
+
+Enum 实现一个简单枚举工具包。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/enum/enum.go](https://github.com/duke-git/lancet/blob/main/enum/enum.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/enum"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [NewItem](#NewItem)
+-   [NewItemsFromPairs](#NewItemsFromPairs)
+-   [Value](#Value)
+-   [Name](#Name)
+-   [Valid](#Valid)
+-   [MarshalJSON](#MarshalJSON)
+-   [NewRegistry](#NewRegistry)
+-   [Add](#Add)
+-   [Remove](#Remove)
+-   [Update](#Update)
+-   [GetByValue](#GetByValue)
+-   [GetByName](#GetByName)
+-   [Items](#Items)
+-   [Contains](#Contains)
+-   [Size](#Size)
+-   [Range](#Range)
+-   [SortedItems](#SortedItems)
+-   [Filter](#Filter)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="NewItem">NewItem</span>
+
+<p>创建枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func NewItem[T comparable](value T, name string) *Item[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8qNsLw01HD5)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    fmt.Println(item1.Name(), item1.Value())
+    fmt.Println(item2.Name(), item2.Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="NewItemsFromPairs">NewItemsFromPairs</span>
+
+<p>从Pair结构体的切片创建枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func NewItemsFromPairs[T comparable](pairs ...Pair[T]) []*Item[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xKnoGa7gnev)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    items := enum.NewItemsFromPairs(
+        enum.Pair[Status]{Value: Active, Name: "Active"},
+        enum.Pair[Status]{Value: Inactive, Name: "Inactive"},
+    )
+
+    fmt.Println(items[0].Name(), items[0].Value())
+    fmt.Println(items[1].Name(), items[1].Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Value">Value</span>
+
+<p>返回枚举项的值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (it *Item[T]) Value() T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xKnoGa7gnev)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    items := enum.NewItemsFromPairs(
+        enum.Pair[Status]{Value: Active, Name: "Active"},
+        enum.Pair[Status]{Value: Inactive, Name: "Inactive"},
+    )
+
+    fmt.Println(items[0].Name(), items[0].Value())
+    fmt.Println(items[1].Name(), items[1].Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Name">Name</span>
+
+<p>返回枚举项的名称。</p>
+
+<b>函数签名:</b>
+
+```go
+func (it *Item[T]) Name() string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xKnoGa7gnev)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    items := enum.NewItemsFromPairs(
+        enum.Pair[Status]{Value: Active, Name: "Active"},
+        enum.Pair[Status]{Value: Inactive, Name: "Inactive"},
+    )
+
+    fmt.Println(items[0].Name(), items[0].Value())
+    fmt.Println(items[1].Name(), items[1].Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Valid">Valid</span>
+
+<p>检查枚举项是否有效。如果提供了自定义检查函数，将使用该函数验证值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (it *Item[T]) Valid(checker ...func(T) bool) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pA3lYY2VSm3)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    item := enum.NewItem(Active, "Active")
+    fmt.Println(item.Valid())
+
+    invalidItem := enum.NewItem(Unknown, "")
+    fmt.Println(invalidItem.Valid())
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="MarshalJSON">MarshalJSON</span>
+
+<p>枚举项实现json.Marshaler接口。</p>
+
+<b>函数签名:</b>
+
+```go
+func (it *Item[T]) MarshalJSON() ([]byte, error)
+func (it *Item[T]) UnmarshalJSON(data []byte) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zIZEdAnneB5)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    item := enum.NewItem(Active, "Active")
+    data, _ := item.MarshalJSON()
+    fmt.Println(string(data))
+
+    var unmarshaledItem enum.Item[Status]
+    _ = unmarshaledItem.UnmarshalJSON(data)
+    fmt.Println(unmarshaledItem.Name(), unmarshaledItem.Value())
+
+    // Output:
+    // {"name":"Active","value":1}
+    // Active 1
+}
+```
+
+### <span id="NewRegistry">NewRegistry</span>
+
+<p>Registry 定义了一个通用的枚举注册表结构体。</p>
+
+<b>函数签名:</b>
+
+```go
+func NewRegistry[T comparable](items ...*Item[T]) *Registry[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ABEXsYfJKMo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    registry.Add(item1, item2)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("Found by value:", item.Name())
+    }
+
+    if item, found := registry.GetByName("Inactive"); found {
+        fmt.Println("Found by name:", item.Value())
+    }
+
+    // Output:
+    // Found by value: Active
+    // Found by name: 2
+}
+```
+
+### <span id="Add">Add</span>
+
+<p>向枚举注册表添加枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Add(items ...*Item[T])
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ABEXsYfJKMo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    registry.Add(item1, item2)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("Found by value:", item.Name())
+    }
+
+    if item, found := registry.GetByName("Inactive"); found {
+        fmt.Println("Found by name:", item.Value())
+    }
+
+    // Output:
+    // Found by value: Active
+    // Found by name: 2
+}
+```
+
+### <span id="Remove">Remove</span>
+
+<p>在枚举注册表中删除枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Remove(value T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dSG84wQ3TuC)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+
+    registry.Add(item1)
+    fmt.Println("Size before removal:", registry.Size())
+
+    removed := registry.Remove(Active)
+    fmt.Println("Removed:", removed)
+    fmt.Println("Size after removal:", registry.Size())
+
+    // Output:
+    // Size before removal: 1
+    // Removed: true
+    // Size after removal: 0
+}
+```
+
+### <span id="Update">Update</span>
+
+<p>在枚举注册表中更新枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Update(value T, newName string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Ol0moT1J9Xl)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+
+    registry.Add(item1)
+    updated := registry.Update(Active, "Activated")
+    fmt.Println("Updated:", updated)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("New name:", item.Name())
+    }
+
+    // Output:
+    // Updated: true
+    // New name: Activated
+}
+```
+
+### <span id="GetByValue">GetByValue</span>
+
+<p>在枚举注册表中通过值获取枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) GetByValue(value T) (*Item[T], bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/niJ1U2KlE_m)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item := enum.NewItem(Active, "Active")
+
+    registry.Add(item)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("Found name by value:", item.Name())
+    }
+
+    // Output:
+    // Found name by value: Active
+}
+```
+
+### <span id="GetByName">GetByName</span>
+
+<p>在枚举注册表中通过名称获取枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) GetByName(name string) (*Item[T], bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/49ie_gpqH0m)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item := enum.NewItem(Active, "Active")
+
+    registry.Add(item)
+
+    if item, found := registry.GetByName("Active"); found {
+        fmt.Println("Found value by name:", item.Value())
+    }
+
+    // Output:
+    // Found value by name: 1
+}
+```
+
+### <span id="Items">Items</span>
+
+<p>返回枚举注册表中的枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Items() []*Item[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lAJFAradbvQ)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    registry.Add(item1, item2)
+
+    for _, item := range registry.Items() {
+        fmt.Println(item.Name(), item.Value())
+    }
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Contains">Contains</span>
+
+<p>检查注册表中是否存在具有给定值的枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Contains(value T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_T-lPYkZn2j)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item := enum.NewItem(Active, "Active")
+    registry.Add(item)
+
+    fmt.Println(registry.Contains(Active))
+    fmt.Println(registry.Contains(Inactive))
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="Size">Size</span>
+
+<p>返回注册表中枚举项的数目。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Size() int
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/TeDArWhlQe2)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    fmt.Println("Initial size:", registry.Size())
+
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+    registry.Add(item1, item2)
+
+    fmt.Println("Size after adding items:", registry.Size())
+
+    registry.Remove(Active)
+    fmt.Println("Size after removing an item:", registry.Size())
+
+    // Output:
+    // Initial size: 0
+    // Size after adding items: 2
+    // Size after removing an item: 1
+}
+```
+
+### <span id="Range">Range</span>
+
+<p>遍历注册表中的所有枚举项，并应用给定的函数。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Range(fn func(*Item[T]) bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GPsZbQbefWN)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+    registry.Add(item1, item2)
+
+    registry.Range(func(item *enum.Item[Status]) bool {
+        fmt.Println(item.Name(), item.Value())
+        return true // continue iteration
+    })
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="SortedItems">SortedItems</span>
+
+<p>返回按给定比较函数排序的所有枚举项的切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) SortedItems(less func(*Item[T], *Item[T]) bool) []*Item[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tN9RE_m_WEI)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Inactive, "Inactive")
+    item2 := enum.NewItem(Active, "Active")
+    registry.Add(item1, item2)
+
+    for _, item := range registry.SortedItems(func(i1, i2 *enum.Item[Status]) bool {
+        return i1.Value() < i2.Value()
+    }) {
+        fmt.Println(item.Name(), item.Value())
+    }
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Filter">Filter</span>
+
+<p>返回满足给定谓词函数的枚举项切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Filter(predicate func(*Item[T]) bool) []*Item[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uTUpTdcyoCU)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+    registry.Add(item1, item2)
+
+    activeItems := registry.Filter(func(item *enum.Item[Status]) bool {
+        return item.Value() == Active
+    })
+
+    for _, item := range activeItems {
+        fmt.Println(item.Name(), item.Value())
+    }
+
+    // Output:
+    // Active 1
+}
+```

docs/api/packages/eventbus.md

@@ -0,0 +1,407 @@
+# EventBus
+
+EventbBus是一个事件总线，用于在应用程序中处理事件。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/eventbus/eventbus.go](https://github.com/duke-git/lancet/blob/main/eventbus/eventbus.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/eventbus"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [NewEventBus](#NewEventBus)
+-   [Subscribe](#Subscribe)
+-   [Unsubscribe](#Unsubscribe)
+-   [Publish](#Publish)
+-   [ClearListeners](#ClearListeners)
+-   [ClearListenersByTopic](#ClearListenersByTopic)
+-   [GetListenersCount](#GetListenersCount)
+-   [GetAllListenersCount](#GetAllListenersCount)
+-   [GetEvents](#GetEvents)
+-   [SetErrorHandler](#SetErrorHandler)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="NewEventBus">NewEventBus</span>
+
+<p>创建EventBus实例。</p>
+
+<b>函数签名:</b>
+
+```go
+func NewEventBus[T any]() *EventBus[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gHbOPV_NUOJ)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/eventbus"
+)
+
+func main() {
+    eb := eventbus.NewEventBus[int]()
+
+    receivedData := 0
+    listener := func(eventData int) {
+        receivedData = eventData
+    }
+
+    eb.Subscribe("event1", listener, false, 0, nil)
+    eb.Publish(eventbus.Event[int]{Topic: "event1", Payload: 1})
+
+    fmt.Println(receivedData)
+
+    // Output:
+    // 1
+}
+```
+
+### <span id="Subscribe">Subscribe</span>
+
+<p>订阅具有特定事件主题和监听函数的事件。支持异步，事件优先级，事件过滤器。</p>
+
+<b>函数签名:</b>
+
+```go
+func (eb *EventBus[T]) Subscribe(topic string, listener func(eventData T), async bool, priority int, filter func(eventData T) bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EYGf_8cHei-)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/eventbus"
+)
+
+func main() {
+    eb := eventbus.NewEventBus[int]()
+
+    receivedData := 0
+    listener := func(eventData int) {
+        receivedData = eventData
+    }
+
+    filter := func(eventData int) bool {
+        return eventData == 1
+    }
+
+    eb.Subscribe("event1", listener, false, 0, filter)
+
+    eb.Publish(eventbus.Event[int]{Topic: "event1", Payload: 1})
+    eb.Publish(eventbus.Event[int]{Topic: "event1", Payload: 2})
+
+    fmt.Println(receivedData)
+
+    // Output:
+    // 1
+}
+```
+
+### <span id="Unsubscribe">Unsubscribe</span>
+
+<p>取消订阅具有特定事件主题的事件。</p>
+
+<b>函数签名:</b>
+
+```go
+func (eb *EventBus[T]) Unsubscribe(topic string, listener func(eventData T))
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Tmh7Ttfvprf)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/eventbus"
+)
+
+func main() {
+    eb := eventbus.NewEventBus[int]()
+
+    receivedData := 0
+    listener := func(eventData int) {
+        receivedData = eventData
+    }
+
+    eb.Subscribe("event1", listener, false, 0, nil)
+    eb.Unsubscribe("event1", listener)
+
+    eb.Publish(eventbus.Event[int]{Topic: "event1", Payload: 1})
+
+    fmt.Println(receivedData)
+
+    // Output:
+    // 0
+}
+```
+
+### <span id="Publish">Publish</span>
+
+<p>发布一个带有特定事件主题和数据负载的事件。</p>
+
+<b>函数签名:</b>
+
+```go
+func (eb *EventBus[T]) Publish(event eventbus.Event[T])
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gHTtVexFSH9)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/eventbus"
+)
+
+func main() {
+    eb := eventbus.NewEventBus[int]()
+
+    eb.Subscribe("event1", func(eventData int) {
+        fmt.Println(eventData)
+    }, false, 0, nil)
+
+    eb.Publish(eventbus.Event[int]{Topic: "event1", Payload: 1})
+
+    // Output:
+    // 1
+}
+```
+
+### <span id="ClearListeners">ClearListeners</span>
+
+<p>清空所有事件监听器。</p>
+
+<b>函数签名:</b>
+
+```go
+func (eb *EventBus[T]) ClearListeners()
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KBfBYlKPgqD)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/eventbus"
+)
+
+func main() {
+    eb := eventbus.NewEventBus[int]()
+
+    receivedData := 0
+    listener := func(eventData int) {
+        receivedData = eventData
+    }
+
+    eb.Subscribe("event1", listener, false, 0, nil)
+    eb.Subscribe("event2", listener, false, 0, nil)
+
+    eb.ClearListeners()
+
+    eb.Publish(eventbus.Event[int]{Topic: "event1", Payload: 1})
+    eb.Publish(eventbus.Event[int]{Topic: "event2", Payload: 2})
+
+    fmt.Println(receivedData)
+
+    // Output:
+    // 0
+}
+```
+
+### <span id="ClearListenersByTopic">ClearListenersByTopic</span>
+
+<p>清空特定事件监听器。</p>
+
+<b>函数签名:</b>
+
+```go
+func (eb *EventBus[T]) ClearListenersByTopic(topic string)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gvMljmJOZmU)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/eventbus"
+)
+
+func main() {
+    eb := eventbus.NewEventBus[int]()
+
+    receivedData := 0
+    listener := func(eventData int) {
+        receivedData = eventData
+    }
+
+    eb.Subscribe("event1", listener, false, 0, nil)
+    eb.Subscribe("event2", listener, false, 0, nil)
+    
+    eb.ClearListenersByTopic("event1")
+
+    eb.Publish(eventbus.Event[int]{Topic: "event1", Payload: 1})
+    eb.Publish(eventbus.Event[int]{Topic: "event2", Payload: 2})
+
+    fmt.Println(receivedData)
+
+    // Output:
+    // 2
+}
+```
+
+### <span id="GetListenersCount">GetListenersCount</span>
+
+<p>获取特定事件的监听器数量。</p>
+
+<b>函数签名:</b>
+
+```go
+func (eb *EventBus[T]) GetListenersCount(topic string) int
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/j6yaJ2xAmFz)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/eventbus"
+)
+
+func main() {
+    eb := eventbus.NewEventBus[int]()
+
+    eb.Subscribe("event1", func(eventData int) {}, false, 0, nil)
+    eb.Subscribe("event2", func(eventData int) {}, false, 0, nil)
+
+    count := eb.GetListenersCount("event1")
+
+    fmt.Println(count)
+
+    // Output:
+    // 1
+}
+```
+
+### <span id="GetAllListenersCount">GetAllListenersCount</span>
+
+<p>获取所有事件的监听器数量。</p>
+
+<b>函数签名:</b>
+
+```go
+func (eb *EventBus[T]) GetAllListenersCount() int
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/PUlr0xcpEOz)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/eventbus"
+)
+
+func main() {
+    eb := eventbus.NewEventBus[int]()
+
+    eb.Subscribe("event1", func(eventData int) {}, false, 0, nil)
+    eb.Subscribe("event2", func(eventData int) {}, false, 0, nil)
+
+    count := eb.GetAllListenersCount()
+
+    fmt.Println(count)
+
+    // Output:
+    // 2
+}
+```
+
+### <span id="GetEvents">GetEvents</span>
+
+<p>获取所有事件的topic。</p>
+
+<b>函数签名:</b>
+
+```go
+func (eb *EventBus[T]) GetEvents() []string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/etgjjcOtAjX)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/eventbus"
+)
+
+func main() {
+    eb := eventbus.NewEventBus[int]()
+
+    eb.Subscribe("event1", func(eventData int) {}, false, 0, nil)
+    eb.Subscribe("event2", func(eventData int) {}, false, 0, nil)
+
+    events := eb.GetEvents()
+
+    for _, event := range events {
+        fmt.Println(event)
+    }
+
+    // Output:
+    // event2
+    // event1
+}
+```
+
+### <span id="SetErrorHandler">SetErrorHandler</span>
+
+<p>设置事件的错误处理函数。</p>
+
+<b>函数签名:</b>
+
+```go
+func (eb *EventBus[T]) SetErrorHandler(handler func(err error))
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gmB0gnFe5mc)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/eventbus"
+)
+
+func main() {
+    eb := eventbus.NewEventBus[int]()
+
+    eb.SetErrorHandler(func(err error) {
+		fmt.Println(err)
+	})
+
+	eb.Subscribe("event1", func(eventData int) {
+		panic("error")
+	}, false, 0, nil)
+
+	eb.Publish(eventbus.Event[int]{Topic: "event1", Payload: 1})
+
+	// Output:
+	// error
+}
+```

docs/api/packages/fileutil.md

@@ -26,6 +26,7 @@ import (
 -   [CreateFile](#CreateFile)
 -   [CreateDir](#CreateDir)
 -   [CopyFile](#CopyFile)
+-   [CopyDir](#CopyDir)
 -   [CurrentPath](#CurrentPath)
 -   [FileMode](#FileMode)
 -   [MiMeType](#MiMeType)
@@ -34,6 +35,7 @@ import (
 -   [IsDir](#IsDir)
 -   [ListFileNames](#ListFileNames)
 -   [RemoveFile](#RemoveFile)
+-   [RemoveDir](#RemoveDir)
 -   [ReadFileToString](#ReadFileToString)
 -   [ReadFileByLine](#ReadFileByLine)
 -   [Zip](#Zip)
@@ -45,8 +47,13 @@ import (
 -   [Sha](#Sha)
 -   [ReadCsvFile](#ReadCsvFile)
 -   [WriteCsvFile](#WriteCsvFile)
+-   [WriteMapsToCsv](#WriteMapsToCsv)
 -   [WriteStringToFile](#WriteStringToFile)
 -   [WriteBytesToFile](#WriteBytesToFile)
+-   [ReadFile](#ReadFile)
+-   [ChunkRead](#ChunkRead)
+-   [ParallelChunkRead](#ParallelChunkRead)
+-   [GetExeOrDllVersion](#GetExeOrDllVersion)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -62,7 +69,7 @@ import (
 func ClearFile(path string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/NRZ0ZT-G94H)</span></b>
 
 ```go
 package main
@@ -90,7 +97,7 @@ func main() {
 func CreateFile(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lDt8PEsTNKI)</span></b>
 
 ```go
 package main
@@ -116,7 +123,7 @@ func main() {
 func CreateDir(absPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qUuCe1OGQnM)</span></b>
 
 ```go
 package main
@@ -142,7 +149,7 @@ func main() {
 func CopyFile(srcPath string, dstPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Jg9AMJMLrJi)</span></b>
 
 ```go
 package main
@@ -160,6 +167,34 @@ func main() {
 }
 ```
 
+### <span id="CopyDir">CopyDir</span>
+
+<p>拷贝文件夹到目标路径，会递归复制文件夹下所有的文件及文件夹，并且访问权限也与源文件夹保持一致。当dstPath存在时会返回error</p>
+
+<b>函数签名:</b>
+
+```go
+func CopyDir(srcPath string, dstPath string) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YAyFTA_UuPb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    err := fileutil.CopyFile("./test_src", "./test_dest")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
+
 ### <span id="CurrentPath">CurrentPath</span>
 
 <p>返回当前位置的绝对路径。</p>
@@ -170,7 +205,7 @@ func main() {
 func CurrentPath() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s74a9iBGcSw)</span></b>
 
 ```go
 package main
@@ -196,7 +231,7 @@ func main() {
 func FileMode(path string) (fs.FileMode, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2l2hI42fA3p)</span></b>
 
 ```go
 package main
@@ -225,7 +260,7 @@ func main() {
 func MiMeType(file any) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bd5sevSUZNu)</span></b>
 
 ```go
 package main
@@ -256,7 +291,7 @@ func main() {
 func IsExist(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nKKXt8ZQbmh)</span></b>
 
 ```go
 package main
@@ -283,7 +318,7 @@ func main() {
 func IsLink(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/TL-b-Kzvf44)</span></b>
 
 ```go
 package main
@@ -309,7 +344,7 @@ func main() {
 func IsDir(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/WkVwEKqtOWk)</span></b>
 
 ```go
 package main
@@ -338,7 +373,7 @@ func main() {
 func ListFileNames(path string) ([]string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Tjd7Y07rejl)</span></b>
 
 ```go
 package main
@@ -356,15 +391,15 @@ func main() {
 
 ### <span id="RemoveFile">RemoveFile</span>
 
-<p>删除文件</p>
+<p>删除文件，支持传入删除前的回调函数。</p>
 
 <b>函数签名:</b>
 
 ```go
-func RemoveFile(path string) error
+func RemoveFile(path string, onDelete ...func(path string)) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/P2y0XW8a1SH)</span></b>
 
 ```go
 package main
@@ -382,6 +417,41 @@ func main() {
 }
 ```
 
+### <span id="RemoveDir">RemoveDir</span>
+
+<p>删除目录，支持传入删除前的回调函数。</p>
+
+<b>函数签名:</b>
+
+```go
+func RemoveDir(path string, onDelete ...func(path string)) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Oa6KnPek2uy)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    var deletedPaths []string
+
+	err := fileutil.RemoveDir("./tempdir", func(p string) {
+		deletedPaths = append(deletedPaths, p)
+	})
+
+    if err != nil {
+        fmt.Println(err)
+    }
+
+    fmt.Println(deletedPaths)
+}
+```
+
 ### <span id="ReadFileToString">ReadFileToString</span>
 
 <p>读取文件内容并返回字符串</p>
@@ -392,7 +462,7 @@ func main() {
 func ReadFileToString(path string) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cmfwp_5SQTp)</span></b>
 
 ```go
 package main
@@ -425,7 +495,7 @@ func main() {
 func ReadFileByLine(path string)([]string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/svJP_7ZrBrD)</span></b>
 
 ```go
 package main
@@ -459,7 +529,7 @@ func main() {
 func Zip(fpath string, destPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/j-3sWBp8ik_P)</span></b>
 
 ```go
 package main
@@ -487,7 +557,7 @@ func main() {
 func ZipAppendEntry(fpath string, destPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cxvaT8TRNQp)</span></b>
 
 ```go
 package main
@@ -515,7 +585,7 @@ func main() {
 func UnZip(zipFile string, destPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g0w34kS7B8m)</span></b>
 
 ```go
 package main
@@ -526,7 +596,7 @@ import (
 )
 
 func main() {
-    err := fileutil.Zip("./test.zip", "./unzip/test.txt")
+    err := fileutil.UnZip("./test.zip", "./test.txt")
     if err != nil {
         fmt.Println(err)
     }
@@ -543,7 +613,7 @@ func main() {
 func IsZipFile(filepath string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9M0g2j_uF_e)</span></b>
 
 ```go
 package main
@@ -569,7 +639,7 @@ func main() {
 func FileSize(path string) (int64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/H9Z05uD-Jjc)</span></b>
 
 ```go
 package main
@@ -601,7 +671,7 @@ func main() {
 func MTime(filepath string) (int64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s_Tl7lZoAaY)</span></b>
 
 ```go
 package main
@@ -633,7 +703,7 @@ func main() {
 func Sha(filepath string, shaType ...int) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VfEEcO2MJYf)</span></b>
 
 ```go
 package main
@@ -668,10 +738,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func ReadCsvFile(filepath string) ([][]string, error)
+func ReadCsvFile(filepath string, delimiter ...rune) ([][]string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OExTkhGEd3_u)</span></b>
 
 ```go
 package main
@@ -700,10 +770,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func WriteCsvFile(filepath string, records [][]string, append bool) error
+func WriteCsvFile(filepath string, records [][]string, append bool, delimiter ...rune) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dAXm58Q5U1o)</span></b>
 
 ```go
 package main
@@ -742,6 +812,59 @@ func main() {
 }
 ```
 
+### <span id="WriteMapsToCsv">WriteMapsToCsv</span>
+
+<p>将map切片写入csv文件中。</p>
+
+<b>函数签名:</b>
+
+```go
+// filepath: CSV文件路径。
+// records: 写入文件的map切片。map值必须为基本类型。会以map键的字母顺序写入。
+// appendToExistingFile: 是否为追加写模式。
+// delimiter: CSV文件分割符。
+// headers: CSV文件表头顺序（需要与map key保持一致)，不指定时按字母排序。
+func WriteMapsToCsv(filepath string, records []map[string]any, appendToExistingFile bool, delimiter rune, headers ...[]string) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/umAIomZFV1c)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    fpath := "./test.csv"
+    fileutil.CreateFile(fpath)
+
+    f, _ := os.OpenFile(fpath, os.O_WRONLY|os.O_TRUNC, 0777)
+    defer f.Close()
+
+    records := []map[string]any{
+        {"Name": "Lili", "Age": "22", "Gender": "female"},
+        {"Name": "Jim", "Age": "21", "Gender": "male"},
+    }
+
+    headers := []string{"Name", "Age", "Gender"}
+    err := fileutil.WriteMapsToCsv(csvFilePath, records, false, ';', headers)
+
+    if err != nil {
+        log.Fatal(err)
+    }
+
+    content, err := fileutil.ReadCsvFile(csvFilePath, ';')
+
+    fmt.Println(content)
+
+    // Output:
+    // [[Name Age Gender] [Lili 22 female] [Jim 21 male]]
+}
+```
+
 ### <span id="WriteBytesToFile">WriteBytesToFile</span>
 
 <p>将bytes写入文件。</p>
@@ -752,7 +875,7 @@ func main() {
 func WriteBytesToFile(filepath string, content []byte) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s7QlDxMj3P8)</span></b>
 
 ```go
 package main
@@ -801,7 +924,7 @@ func main() {
 func WriteStringToFile(filepath string, content string, append bool) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GhLS6d8lH_g)</span></b>
 
 ```go
 package main
@@ -839,3 +962,186 @@ func main() {
     // hello
 }
 ```
+
+### <span id="ReadFile">ReadFile</span>
+
+<p>读取文件或者URL。</p>
+
+<b>函数签名:</b>
+
+```go
+func ReadFile(path string) (reader io.ReadCloser, closeFn func(), err error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uNep3Tr8fqF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    reader, fn, err := fileutil.ReadFile("https://httpbin.org/robots.txt")
+    if err != nil {
+        return
+    }
+    defer fn()
+
+    dat, err := io.ReadAll(reader)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(string(dat))
+
+    // Output:
+    // User-agent: *
+    // Disallow: /deny
+}
+```
+
+### <span id="ChunkRead">ChunkRead</span>
+
+<p>从文件的指定偏移读取块并返回块内所有行。</p>
+
+<b>函数签名:</b>
+
+```go
+func ChunkRead(file *os.File, offset int64, size int, bufPool *sync.Pool) ([]string, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/r0hPmKWhsgf)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    const mb = 1024 * 1024
+    const defaultChunkSizeMB = 100
+
+    // test1.csv file content:
+    // Lili,22,female
+    // Jim,21,male
+    filePath := "./testdata/test1.csv" // 替换为你的文件路径
+    f, err := os.Open(filePath)
+    if err != nil {
+        return
+    }
+
+    defer f.Close()
+
+    var bufPool = sync.Pool{
+        New: func() interface{} {
+            return make([]byte, 0, defaultChunkSizeMB*mb)
+        },
+    }
+
+    lines, err := fileutil.ChunkRead(f, 0, 100, &bufPool)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(lines[0])
+    fmt.Println(lines[1])
+
+    // Output:
+    // Lili,22,female
+    // Jim,21,male
+}
+```
+
+### <span id="ParallelChunkRead">ParallelChunkRead</span>
+
+<p>并行读取文件并将每个块的行发送到指定通道。</p>
+
+<b>函数签名:</b>
+
+```go
+// filePath:文件路径
+// chunkSizeMB: 分块的大小（单位MB，设置为0时使用默认100MB）,设置过大反而不利，视情调整
+// maxGoroutine: 并发读取分块的数量，设置为0时使用CPU核心数
+// linesCh: 用于接收返回结果的通道。
+func ParallelChunkRead(filePath string, linesCh chan<- []string, chunkSizeMB, maxGoroutine int) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/teMXnCsdSEw)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    const mb = 1024 * 1024
+    const defaultChunkSizeMB = 100 // 默认值
+
+    numParsers := runtime.NumCPU()
+
+    linesCh := make(chan []string, numParsers)
+
+    // test1.csv file content:
+    // Lili,22,female
+    // Jim,21,male
+    filePath := "./testdata/test1.csv"
+
+    go fileutil.ParallelChunkRead(filePath, linesCh, defaultChunkSizeMB, numParsers)
+
+    var totalLines int
+    for lines := range linesCh {
+        totalLines += len(lines)
+
+        for _, line := range lines {
+            fmt.Println(line)
+        }
+    }
+
+    fmt.Println(totalLines)
+
+    // Output:
+    // Lili,22,female
+    // Jim,21,male
+    // 2
+}
+```
+
+### <span id="GetExeOrDllVersion">GetExeOrDllVersion</span>
+
+<p>返回exe,dll文件版本号(仅Window平台).</p>
+
+<b>函数签名:</b>
+
+```go
+func GetExeOrDllVersion(filePath string) (string, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/iLRrDBhE38E)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    v, err := fileutil.GetExeOrDllVersion(`C:\Program Files\Tencent\WeChat\WeChat.exe`)
+	if err != nil {
+		panic(err)
+    }
+    fmt.Println(v)
+    // Output:
+    // 3.9.10.19
+}
+```

docs/api/packages/formatter.md

@@ -0,0 +1,444 @@
+# Formatter
+
+formatter 格式化器包含一些数据格式化处理方法。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/formatter/formatter.go](https://github.com/duke-git/lancet/blob/main/formatter/formatter.go)
+-   [https://github.com/duke-git/lancet/blob/main/formatter/byte.go](https://github.com/duke-git/lancet/blob/main/formatter/byte.go)
+-   [https://github.com/duke-git/lancet/blob/main/formatter/address.go](https://github.com/duke-git/lancet/blob/main/formatter/address.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/formatter"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [Comma](#Comma)
+-   [Pretty](#Pretty)
+-   [PrettyToWriter](#PrettyToWriter)
+-   [DecimalBytes](#DecimalBytes)
+-   [BinaryBytes](#BinaryBytes)
+-   [ParseDecimalBytes](#ParseDecimalBytes)
+-   [ParseBinaryBytes](#ParseBinaryBytes)
+-   [ParseCNAddress](#ParseCNAddress)
+-   [ParsePersonInfo](#ParsePersonInfo)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="Comma">Comma</span>
+
+<p>用逗号每隔3位分割数字/字符串，支持添加前缀符号。参数value必须是数字或者可以转为数字的字符串, 否则返回空字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func Comma[T constraints.Float | constraints.Integer | string](value T, prefixSymbol string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1 := formatter.Comma("123", "")
+    result2 := formatter.Comma("12345", "$")
+    result3 := formatter.Comma(1234567, "￥")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 123
+    // $12,345
+    // ￥1,234,567
+}
+```
+
+### <span id="Pretty">Pretty</span>
+
+<p>返回pretty JSON字符串.</p>
+
+<b>函数签名:</b>
+
+```go
+func Pretty(v any) (string, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YsciGj3FH2x)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1, _ := formatter.Pretty([]string{"a", "b", "c"})
+    result2, _ := formatter.Pretty(map[string]int{"a": 1})
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // [
+    //     "a",
+    //     "b",
+    //     "c"
+    // ]
+    // {
+    //     "a": 1
+    // }
+}
+```
+
+### <span id="PrettyToWriter">PrettyToWriter</span>
+
+<p>Pretty encode数据到writer。</p>
+
+<b>函数签名:</b>
+
+```go
+func PrettyToWriter(v any, out io.Writer) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/LPLZ3lDi5ma)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    type User struct {
+        Name string `json:"name"`
+        Aage uint   `json:"age"`
+    }
+    user := User{Name: "King", Aage: 10000}
+
+    buf := &bytes.Buffer{}
+    err := formatter.PrettyToWriter(user, buf)
+
+    fmt.Println(buf)
+    fmt.Println(err)
+
+    // Output:
+    // {
+    //     "name": "King",
+    //     "age": 10000
+    // }
+    //
+    // <nil>
+}
+```
+
+### <span id="DecimalBytes">DecimalBytes</span>
+
+<p>返回十进制标准（以1000为基数）下的可读字节单位字符串。precision参数指定小数点后的位数，默认为4。</p>
+
+<b>函数签名:</b>
+
+```go
+func DecimalBytes(size float64, precision ...int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/FPXs1suwRcs)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1 := formatter.DecimalBytes(1000)
+    result2 := formatter.DecimalBytes(1024)
+    result3 := formatter.DecimalBytes(1234567)
+    result4 := formatter.DecimalBytes(1234567, 3)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 1KB
+    // 1.024KB
+    // 1.2346MB
+    // 1.235MB
+}
+```
+
+### <span id="BinaryBytes">BinaryBytes</span>
+
+<p>返回binary标准（以1024为基数）下的可读字节单位字符串。precision参数指定小数点后的位数，默认为4。</p>
+
+<b>函数签名:</b>
+
+```go
+func BinaryBytes(size float64, precision ...int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/G9oHHMCAZxP)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1 := formatter.BinaryBytes(1024)
+    result2 := formatter.BinaryBytes(1024 * 1024)
+    result3 := formatter.BinaryBytes(1234567)
+    result4 := formatter.BinaryBytes(1234567, 2)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 1KiB
+    // 1MiB
+    // 1.1774MiB
+    // 1.18MiB
+}
+```
+
+### <span id="ParseDecimalBytes">ParseDecimalBytes</span>
+
+<p>将字节单位字符串转换成其所表示的字节数（以1000为基数）。</p>
+
+<b>函数签名:</b>
+
+```go
+func ParseDecimalBytes(size string) (uint64, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Am98ybWjvjj)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1, _ := formatter.ParseDecimalBytes("12")
+    result2, _ := formatter.ParseDecimalBytes("12k")
+    result3, _ := formatter.ParseDecimalBytes("12 Kb")
+    result4, _ := formatter.ParseDecimalBytes("12.2 kb")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 12
+    // 12000
+    // 12000
+    // 12200
+}
+```
+
+### <span id="ParseBinaryBytes">ParseBinaryBytes</span>
+
+<p>将字节单位字符串转换成其所表示的字节数（以1024为基数）。</p>
+
+<b>函数签名:</b>
+
+```go
+func ParseBinaryBytes(size string) (uint64, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/69v1tTT62x8)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1, _ := formatter.ParseBinaryBytes("12")
+    result2, _ := formatter.ParseBinaryBytes("12ki")
+    result3, _ := formatter.ParseBinaryBytes("12 KiB")
+    result4, _ := formatter.ParseBinaryBytes("12.2 kib")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 12
+    // 12288
+    // 12288
+    // 12492
+}
+```
+
+### <span id="ParseCNAddress">ParseCNAddress</span>
+
+<p>智能解析中国地址字符串并提取结构化信息。可以解析带或不带用户信息（姓名、电话、身份证等）的地址。当 withUser 为 true 时，从地址字符串中提取用户信息。当 withUser 为 false 时，仅解析位置信息。支持多种地址格式：标准格式、紧凑格式、带关键词格式、县级市格式等。</p>
+
+<b>函数签名:</b>
+
+```go
+func ParseCNAddress(str string, withUser bool) *AddressInfo
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/o5l09hQopEV)</span></b>
+
+```go
+package main
+
+import (
+    "encoding/json"
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    // 解析包含用户信息的完整地址
+    result1 := formatter.ParseCNAddress("张三 13800138000 北京市朝阳区建国路1号", true)
+    jsonData1, _ := json.MarshalIndent(result1, "", "  ")
+    fmt.Println("示例 1 - 带用户信息:")
+    fmt.Println(string(jsonData1))
+
+    // 仅解析地址，不提取用户信息
+    result2 := formatter.ParseCNAddress("北京市海淀区中关村大街1号", false)
+    fmt.Printf("\n示例 2 - 仅地址:\n")
+    fmt.Printf("省: %s, 市: %s, 区: %s, 街道: %s\n",
+        result2.Province, result2.City, result2.Region, result2.Street)
+
+    // 解析县级市地址
+    result3 := formatter.ParseCNAddress("河北省石家庄市新乐市经济开发区兴工街10号", false)
+    fmt.Printf("\n示例 3 - 县级市:\n")
+    fmt.Printf("省: %s, 市: %s, 区/县: %s, 街道: %s\n",
+        result3.Province, result3.City, result3.Region, result3.Street)
+
+    // 紧凑格式
+    result4 := formatter.ParseCNAddress("马云13593464918陕西省西安市雁塔区丈八沟街道", true)
+    fmt.Printf("\n示例 4 - 紧凑格式:\n")
+    fmt.Printf("姓名: %s, 电话: %s, 地址: %s%s%s%s\n",
+        result4.Name, result4.Mobile, result4.Province, result4.City, result4.Region, result4.Street)
+
+    // Output:
+    // 示例 1 - 带用户信息:
+    // {
+    //   "name": "张三",
+    //   "mobile": "13800138000",
+    //   "idn": "",
+    //   "postcode": "",
+    //   "province": "北京",
+    //   "city": "北京市",
+    //   "region": "朝阳区",
+    //   "street": "建国路1号",
+    //   "addr": "北京市朝阳区建国路1号"
+    // }
+    //
+    // 示例 2 - 仅地址:
+    // 省: 北京, 市: 北京市, 区: 海淀区, 街道: 中关村大街1号
+    //
+    // 示例 3 - 县级市:
+    // 省: 河北省, 市: 石家庄市, 区/县: 新乐市, 街道: 经济开发区兴工街10号
+    //
+    // 示例 4 - 紧凑格式:
+    // 姓名: 马云, 电话: 13593464918, 地址: 陕西省西安市雁塔区丈八沟街道
+}
+```
+
+### <span id="ParsePersonInfo">ParsePersonInfo</span>
+
+<p>从地址字符串中提取用户信息（姓名、电话、身份证、邮编）。将个人信息与地址分离，支持带标签格式、紧凑格式、带分隔符格式。返回包含提取的用户信息和清理后地址字符串的 AddressInfo。</p>
+
+<b>函数签名:</b>
+
+```go
+func ParsePersonInfo(str string) *AddressInfo
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/JO-uTlJlTy7)</span></b>
+
+```go
+package main
+
+import (
+    "encoding/json"
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    // 提取姓名和手机号
+    result1 := formatter.ParsePersonInfo("张三 13800138000 北京市朝阳区")
+    fmt.Println("示例 1 - 姓名和手机号:")
+    fmt.Printf("姓名: %s, 手机: %s, 地址: %s\n", result1.Name, result1.Mobile, result1.Addr)
+
+    // 提取身份证号
+    result2 := formatter.ParsePersonInfo("李四 110101199001011234 上海市")
+    fmt.Println("\n示例 2 - 身份证号:")
+    fmt.Printf("姓名: %s, 身份证: %s, 地址: %s\n", result2.Name, result2.IDN, result2.Addr)
+
+    // 带标签格式
+    result3 := formatter.ParsePersonInfo("收货人：王五 电话：13900139000 收货地址：天津市河西区友谊路20号")
+    jsonData3, _ := json.MarshalIndent(result3, "", "  ")
+    fmt.Println("\n示例 3 - 带标签格式:")
+    fmt.Println(string(jsonData3))
+
+    // Output:
+    // 示例 1 - 姓名和手机号:
+    // 姓名: 张三, 手机: 13800138000, 地址: 北京市朝阳区
+    //
+    // 示例 2 - 身份证号:
+    // 姓名: 李四, 身份证: 110101199001011234, 地址: 上海市
+    //
+    // 示例 3 - 带标签格式:
+    // {
+    //   "name": "王五",
+    //   "mobile": "13900139000",
+    //   "idn": "",
+    //   "postcode": "",
+    //   "province": "",
+    //   "city": "",
+    //   "region": "",
+    //   "street": "",
+    //   "addr": "天津市河西区友谊路20号"
+    // }
+}
+```

docs/api/packages/function.md

@@ -0,0 +1,786 @@
+# Function
+
+function 函数包控制函数执行流程，包含部分函数式编程。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/function/function.go](https://github.com/duke-git/lancet/blob/main/function/function.go)
+-   [https://github.com/duke-git/lancet/blob/main/function/predicate.go](https://github.com/duke-git/lancet/blob/main/function/predicate.go)
+-   [https://github.com/duke-git/lancet/blob/main/function/watcher.go](https://github.com/duke-git/lancet/blob/main/function/watcher.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/function"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [After](#After)
+-   [Before](#Before)
+-   [CurryFn](#CurryFn)
+-   [Compose](#Compose)
+-   [Debounce](#Debounce)
+-   [Debounced<sup>deprecated</sup>](#Debounced)
+-   [Delay](#Delay)
+-   [Schedule](#Schedule)
+-   [Pipeline](#Pipeline)
+-   [Watcher](#Watcher)
+-   [And](#And)
+-   [Or](#Or)
+-   [Negate](#Negate)
+-   [Nor](#Nor)
+-   [Xnor](#Xnor)
+-   [Nand](#Nand)
+-   [AcceptIf](#AcceptIf)
+-   [Throttle](#Throttle)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="After">After</span>
+
+<p>创建一个函数，当他被调用n或更多次之后将马上触发fn</p>
+
+<b>函数签名:</b>
+
+```go
+func After(n int, fn any) func(args ...any) []reflect.Value
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    fn := function.After(2, func() {
+        fmt.Println("hello")
+    })
+
+    fn()
+    fn()
+
+    // Output:
+    // hello
+}
+```
+
+### <span id="Before">Before</span>
+
+<p>创建一个函数，调用次数不超过n次，之后再调用这个函数，将返回一次最后调用fn的结果</p>
+
+<b>函数签名:</b>
+
+```go
+func Before(n int, fn any) func(args ...any) []reflect.Value
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/0HqUDIFZ3IL)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    fn := function.Before(2, func() {
+        fmt.Println("hello")
+    })
+
+    fn()
+    fn()
+    fn()
+    fn()
+
+    // Output:
+    // hello
+    // hello
+}
+```
+
+### <span id="CurryFn">CurryFn</span>
+
+<p>创建柯里化函数</p>
+
+<b>函数签名:</b>
+
+```go
+type CurryFn[T any] func(...T) T
+func (cf CurryFn[T]) New(val T) func(...T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/5HopfDwANKX)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    add := func(a, b int) int {
+        return a + b
+    }
+
+    var addCurry function.CurryFn[int] = func(values ...int) int {
+        return add(values[0], values[1])
+    }
+    add1 := addCurry.New(1)
+
+    result := add1(2)
+
+    fmt.Println(result)
+
+    // Output:
+    // 3
+}
+```
+
+### <span id="Compose">Compose</span>
+
+<p>从右至左组合函数列表fnList，返回组合后的函数</p>
+
+<b>函数签名:</b>
+
+```go
+func Compose[T any](fnList ...func(...T) T) func(...T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KKfugD4PKYF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    toUpper := func(strs ...string) string {
+        return strings.ToUpper(strs[0])
+    }
+    toLower := func(strs ...string) string {
+        return strings.ToLower(strs[0])
+    }
+    transform := function.Compose(toUpper, toLower)
+
+    result := transform("aBCde")
+
+    fmt.Println(result)
+
+    // Output:
+    // ABCDE
+}
+```
+
+### <span id="Debounce">Debounce</span>
+
+<p>创建一个函数的去抖动版本。该去抖动函数仅在上次调用后的指定延迟时间过去之后才会调用原始函数。支持取消去抖动。</p>
+
+<b>函数签名:</b>
+
+```go
+func Debounce(fn func(), delay time.Duration) (debouncedFn func(), cancelFn func())
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/-dGFrYn_1Zi)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    callCount := 0
+    fn := func() {
+        callCount++
+    }
+
+    debouncedFn, _ := function.Debounce(fn, 500*time.Millisecond)
+
+    for i := 0; i < 10; i++ {
+        debouncedFn()
+        time.Sleep(50 * time.Millisecond)
+    }
+
+    time.Sleep(1 * time.Second)
+    fmt.Println(callCount)
+
+    debouncedFn()
+
+    time.Sleep(1 * time.Second)
+    fmt.Println(callCount)
+
+    // Output:
+    // 1
+    // 2
+}
+```
+
+### <span id="Debounced">Debounced</span>
+
+<p>创建一个函数的去抖动版本。</p>
+
+> ⚠️ 本函数已弃用. 使用 `Debounce` 代替.
+
+<b>函数签名:</b>
+
+```go
+func Debounced(fn func(), duration time.Duration) func()
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/absuEGB_GN7)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    count := 0
+
+    add := func() {
+        count++
+    }
+
+    debouncedAdd := function.Debounced(add, 50*time.Microsecond)
+
+    debouncedAdd()
+    debouncedAdd()
+    debouncedAdd()
+    debouncedAdd()
+
+    time.Sleep(100 * time.Millisecond)
+
+    fmt.Println(count)
+
+    debouncedAdd()
+
+    time.Sleep(100 * time.Millisecond)
+
+    fmt.Println(count)
+
+    // Output:
+    // 1
+    // 2
+}
+```
+
+### <span id="Delay">Delay</span>
+
+<p>延迟delay时间后调用函数</p>
+
+<b>函数签名:</b>
+
+```go
+func Delay(delay time.Duration, fn any, args ...any)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Ivtc2ZE-Tye)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    var print = func(s string) {
+        fmt.Println(s)
+    }
+
+    function.Delay(2*time.Second, print, "hello")
+
+    // Output:
+    // hello
+}
+```
+
+### <span id="Schedule">Schedule</span>
+
+<p>每次持续时间调用函数，直到关闭返回的 bool chan</p>
+
+<b>函数签名:</b>
+
+```go
+func Schedule(d time.Duration, fn any, args ...any) chan bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hbON-Xeyn5N)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    count := 0
+
+    increase := func() {
+        count++
+    }
+
+    stop := function.Schedule(2*time.Second, increase)
+
+    time.Sleep(2 * time.Second)
+    close(stop)
+
+    fmt.Println(count)
+
+    // Output:
+    // 2
+}
+```
+
+### <span id="Pipeline">Pipeline</span>
+
+<p>执行函数pipeline.</p>
+
+<b>函数签名:</b>
+
+```go
+func Pipeline[T any](funcs ...func(T) T) func(T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mPdUVvj6HD6)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    addOne := func(x int) int {
+        return x + 1
+    }
+    double := func(x int) int {
+        return 2 * x
+    }
+    square := func(x int) int {
+        return x * x
+    }
+
+    fn := function.Pipeline(addOne, double, square)
+
+    result := fn(2)
+
+    fmt.Println(result)
+
+    // Output:
+    // 36
+}
+```
+
+### <span id="Watcher">Watcher</span>
+
+<p>Watcher用于记录代码执行时间。可以启动/停止/重置手表定时器。获取函数执行的时间。</p>
+
+<b>函数签名:</b>
+
+```go
+type Watcher struct {
+    startTime int64
+    stopTime  int64
+    excuting  bool
+}
+func NewWatcher() *Watcher
+func (w *Watcher) Start()
+func (w *Watcher) Stop()
+func (w *Watcher) Reset()
+func (w *Watcher) GetElapsedTime() time.Duration
+
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/l2yrOpCLd1I)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    w := function.NewWatcher()
+
+    w.Start()
+
+    longRunningTask()
+
+    fmt.Println(w.excuting) //true
+
+    w.Stop()
+
+    eapsedTime := w.GetElapsedTime().Milliseconds()
+
+    fmt.Println(eapsedTime)
+
+    w.Reset()
+
+}
+
+func longRunningTask() {
+    var slice []int64
+    for i := 0; i < 10000000; i++ {
+        slice = append(slice, int64(i))
+    }
+}
+
+```
+
+### <span id="And">And</span>
+
+<p>返回一个复合谓词判断函数，该判断函数表示一组谓词的逻辑and操作。只有当所有谓词判断函数对于给定的值都返回true时，返回true, 否则返回false。</p>
+
+<b>函数签名:</b>
+
+```go
+func And[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dTBHJMQ0zD2)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isNumericAndLength5 := function.And(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(isNumericAndLength5("12345"))
+    fmt.Println(isNumericAndLength5("1234"))
+    fmt.Println(isNumericAndLength5("abcde"))
+
+    // Output:
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="Or">Or</span>
+
+<p>返回一个复合谓词判断函数，该判断函数表示一组谓词的逻辑or操作。只有当所有谓词判断函数对于给定的值都返回false时，返回false, 否则返回true。</p>
+
+<b>函数签名:</b>
+
+```go
+func Or[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/LitCIsDFNDA)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    containsDigitOrSpecialChar := function.Or(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return strings.ContainsAny(s, "!@#$%") },
+    )
+
+    fmt.Println(containsDigitOrSpecialChar("hello!"))
+    fmt.Println(containsDigitOrSpecialChar("hello"))
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="Negate">Negate</span>
+
+<p>返回一个谓词函数，该谓词函数表示当前谓词的逻辑否定。</p>
+
+<b>函数签名:</b>
+
+```go
+func Negate[T any](predicate func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jbI8BtgFnVE)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    // Define some simple predicates for demonstration
+    isUpperCase := func(s string) bool {
+        return strings.ToUpper(s) == s
+    }
+    isLowerCase := func(s string) bool {
+        return strings.ToLower(s) == s
+    }
+    isMixedCase := function.Negate(function.Or(isUpperCase, isLowerCase))
+
+    fmt.Println(isMixedCase("ABC"))
+    fmt.Println(isMixedCase("AbC"))
+
+    // Output:
+    // false
+    // true
+}
+```
+
+
+### <span id="Nor">Nor</span>
+
+<p>返回一个组合谓词函数，表示给定值上所有谓词逻辑非或 (nor) 的结果。只有当所有谓词函数对给定值都返回false时，该组合谓词函数才返回true。</p>
+
+<b>函数签名:</b>
+
+```go
+func Nor[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2KdCoBEOq84)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    match := function.Nor(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(match("dbcdckkeee"))
+
+
+    match = function.Nor(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(match("0123456789"))
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="Nand">Nand</span>
+
+<p>返回一个复合谓词函数，表示给定谓词函数列表的逻辑非与 (NAND)。仅当列表中所有函数对给定参数返回false时，才返回true，否则返回false。</p>
+
+<b>函数签名:</b>
+
+```go
+func Nand[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Rb-FdNGpgSO)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isNumericAndLength5 := function.Nand(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(isNumericAndLength5("12345"))
+    fmt.Println(isNumericAndLength5("1234"))
+    fmt.Println(isNumericAndLength5("abcdef"))
+
+    // Output:
+    // false
+    // false
+    // true
+}
+```
+
+### <span id="Xnor">Xnor</span>
+
+<p>返回一个复合谓词函数，表示给定一组谓词函数的逻辑异或 (XNOR)。只有当所有 谓词函数对给参数都返回true或false时，该谓词函数才返回true。</p>
+
+<b>函数签名:</b>
+
+```go
+func Xnor[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/FJxko8SFbqc)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isEven := func(i int) bool { return i%2 == 0 }
+    isPositive := func(i int) bool { return i > 0 }
+
+    match := function.Xnor(isEven, isPositive)
+
+    fmt.Println(match(2))
+    fmt.Println(match(-3))
+    fmt.Println(match(3))
+
+    // Output:
+    // true
+    // true
+    // false
+}
+```
+
+### <span id="AcceptIf">AcceptIf</span>
+
+<p>AcceptIf函数会返回另一个函数，该函数的签名与 apply 函数相同，但同时还会包含一个布尔值来表示成功或失败。</p>
+
+<b>函数签名:</b>
+
+```go
+func AcceptIf[T any](predicate func(T) bool, apply func(T) T) func(T) (T, bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/XlXHHtzCf7d)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    adder := function.AcceptIf(
+        function.And(
+            func(x int) bool {
+                return x > 10
+            }, func(x int) bool {
+                return x%2 == 0
+            }),
+        func(x int) int {
+            return x + 1
+        },
+    )
+
+    result, ok := adder(20)
+    fmt.Println(result)
+    fmt.Println(ok)
+
+    result, ok = adder(21)
+    fmt.Println(result)
+    fmt.Println(ok)
+
+    // Output:
+    // 21
+    // true
+    // 0
+    // false
+}
+
+```
+
+### <span id="Throttle">Throttle</span>
+
+<p>创建一个函数的节流版本。返回的函数保证在每个时间间隔内最多只会被调用一次。</p>
+
+<b>函数签名:</b>
+
+```go
+func Throttle(fn func(), interval time.Duration) func()
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HpoMov-tJSN)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    callCount := 0
+
+    fn := func() {
+        callCount++
+    }
+
+    throttledFn := function.Throttle(fn, 1*time.Second)
+
+    for i := 0; i < 5; i++ {
+        throttledFn()
+    }
+
+    time.Sleep(1 * time.Second)
+
+    fmt.Println(callCount)
+
+    // Output:
+    // 1
+}
+```

docs/api/packages/mathutil.md

@@ -33,7 +33,11 @@ import (
 -   [Percent](#Percent)
 -   [RoundToFloat](#RoundToFloat)
 -   [RoundToString](#RoundToString)
--   [TruncRound](#TruncRound)
+-   [T运行cRound](#T运行cRound)
+-   [CeilToFloat](#CeilToFloat)
+-   [CeilToString](#CeilToString)
+-   [FloorToFloat](#FloorToFloat)
+-   [FloorToString](#FloorToString)
 -   [Range](#Range)
 -   [RangeWithStep](#RangeWithStep)
 -   [AngleToRadian](#AngleToRadian)
@@ -47,10 +51,15 @@ import (
 -   [Log](#Log)
 -   [Sum](#Sum)
 -   [Abs](#Abs)
+-   [Div](#Div)
+-   [Variance](#Variance)
+-   [StdDev](#StdDev)
+-   [Permutation](#Permutation)
+-   [Combination](#Combination)
 
 <div STYLE="page-break-after: always;"></div>
 
-## Documentation
+## 文档
 
 ### <span id="Average">Average</span>
 
@@ -59,10 +68,10 @@ import (
 <b>函数签名:</b>
 
 ```go
-func Average[T constraints.Integer | constraints.Float](numbers ...T) T
+func Average[T constraints.Integer | constraints.Float](numbers ...T) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HFd70x4DrMj)</span></b>
 
 ```go
 package main
@@ -82,7 +91,7 @@ func main() {
     fmt.Println(result2)
 
     // Output:
-    // 1
+    // 1.5
     // 1.3
 }
 ```
@@ -97,7 +106,7 @@ func main() {
 func Exponent(x, n int64) int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Vv7LBwER-pz)</span></b>
 
 ```go
 package main
@@ -133,7 +142,7 @@ func main() {
 func Fibonacci(first, second, n int) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IscseUNMuUc)</span></b>
 
 ```go
 package main
@@ -169,7 +178,7 @@ func main() {
 func Factorial(x uint) uint
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tt6LdOK67Nx)</span></b>
 
 ```go
 package main
@@ -205,7 +214,7 @@ func main() {
 func Max[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cN8DHI0rTkH)</span></b>
 
 ```go
 package main
@@ -238,7 +247,7 @@ func main() {
 func MaxBy[T any](slice []T, comparator func(T, T) bool) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pbe2MT-7DV2)</span></b>
 
 ```go
 package main
@@ -282,7 +291,7 @@ func main() {
 func Min[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pbe2MT-7DV2)</span></b>
 
 ```go
 package main
@@ -315,7 +324,7 @@ func main() {
 func MinBy[T any](slice []T, comparator func(T, T) bool) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/N9qgYg_Ho6f)</span></b>
 
 ```go
 package main
@@ -359,7 +368,7 @@ func main() {
 func Percent(val, total float64, n int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s0NdFCtwuyd)</span></b>
 
 ```go
 package main
@@ -392,10 +401,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func RoundToFloat(x float64, n int) float64
+func RoundToFloat[T constraints.Float | constraints.Integer](x T, n int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ghyb528JRJL)</span></b>
 
 ```go
 package main
@@ -428,10 +437,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func RoundToString(x float64, n int) string
+func RoundToString[T constraints.Float | constraints.Integer](x T, n int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/kZwpBRAcllO)</span></b>
 
 ```go
 package main
@@ -464,10 +473,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func TruncRound(x float64, n int) float64
+func TruncRound[T constraints.Float | constraints.Integer](x T, n int) T 
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/aumarSHIGzP)</span></b>
 
 ```go
 package main
@@ -493,6 +502,150 @@ func main() {
 }
 ```
 
+### <span id="CeilToFloat">CeilToFloat</span>
+
+<p>向上舍入（进一法），保留n位小数。</p>
+
+<b>函数签名:</b>
+
+```go
+func CeilToFloat[T constraints.Float | constraints.Integer](x T, n int) float64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8hOeSADZPCo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.CeilToFloat(3.14159, 1)
+    result2 := mathutil.CeilToFloat(3.14159, 2)
+    result3 := mathutil.CeilToFloat(5, 4)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 3.2
+    // 3.15
+    // 5
+}
+```
+
+### <span id="CeilToString">CeilToString</span>
+
+<p>向上舍入（进一法），保留n位小数，返回字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func CeilToString[T constraints.Float | constraints.Integer](x T, n int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wy5bYEyUKKG)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.CeilToString(3.14159, 1)
+    result2 := mathutil.CeilToString(3.14159, 2)
+    result3 := mathutil.CeilToString(5, 4)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 3.2
+    // 3.15
+    // 5.0000
+}
+```
+
+### <span id="FloorToFloat">FloorToFloat</span>
+
+<p>向下舍入（去尾法），保留n位小数。</p>
+
+<b>函数签名:</b>
+
+```go
+func FloorToFloat[T constraints.Float | constraints.Integer](x T, n int) float64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vbCBrQHZEED)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.FloorToFloat(3.14159, 1)
+    result2 := mathutil.FloorToFloat(3.14159, 2)
+    result3 := mathutil.FloorToFloat(5, 4)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 3.1
+    // 3.14
+    // 5
+}
+```
+
+### <span id="FloorToString">FloorToString</span>
+
+<p>向下舍入（去尾法），保留n位小数，返回字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func FloorToString[T constraints.Float | constraints.Integer](x T, n int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Qk9KPd2IdDb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.FloorToString(3.14159, 1)
+    result2 := mathutil.FloorToString(3.14159, 2)
+    result3 := mathutil.FloorToString(5, 4)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 3.1
+    // 3.14
+    // 5.0000
+}
+```
+
 ### <span id="Range">Range</span>
 
 <p>根据指定的起始值和数量，创建一个数字切片。</p>
@@ -503,7 +656,7 @@ func main() {
 func Range[T constraints.Integer | constraints.Float](start T, count int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9ke2opxa8ZP)</span></b>
 
 ```go
 package main
@@ -542,7 +695,7 @@ func main() {
 func RangeWithStep[T constraints.Integer | constraints.Float](start, end, step T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/akLWz0EqOSM)</span></b>
 
 ```go
 package main
@@ -581,7 +734,7 @@ func main() {
 func AngleToRadian(angle float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CIvlICqrHql)</span></b>
 
 ```go
 package main
@@ -617,7 +770,7 @@ func main() {
 func RadianToAngle(radian float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dQtmOTUOMgi)</span></b>
 
 ```go
 package main
@@ -653,7 +806,7 @@ func main() {
 func PointDistance(x1, y1, x2, y2 float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/RrG4JIaziM8)</span></b>
 
 ```go
 package main
@@ -683,7 +836,7 @@ func main() {
 func IsPrime(n int) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Rdd8UTHZJ7u)</span></b>
 
 ```go
 package main
@@ -722,7 +875,7 @@ func main() {
 func GCD[T constraints.Integer](integers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CiEceLSoAKB)</span></b>
 
 ```go
 package main
@@ -764,7 +917,7 @@ func main() {
 func LCM[T constraints.Integer](integers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EjcZxfY7G_g)</span></b>
 
 ```go
 package main
@@ -800,7 +953,7 @@ func main() {
 func Cos(radian float64, precision ...int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Sm89LoIfvFq)</span></b>
 
 ```go
 package main
@@ -842,7 +995,7 @@ func main() {
 func Sin(radian float64, precision ...int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/TWMQlMywDsP)</span></b>
 
 ```go
 package main
@@ -884,7 +1037,7 @@ func main() {
 func Log(n, base float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_d4bi8oyhat)</span></b>
 
 ```go
 package main
@@ -896,8 +1049,8 @@ import (
 
 func main() {
     result1 := mathutil.Log(8, 2)
-    result2 := mathutil.TruncRound(mathutil.Log(5, 2), 2)
-    result3 := mathutil.TruncRound(mathutil.Log(27, 3), 0)
+    result2 := mathutil.T运行cRound(mathutil.Log(5, 2), 2)
+    result3 := mathutil.T运行cRound(mathutil.Log(27, 3), 0)
 
     fmt.Println(result1)
     fmt.Println(result2)
@@ -920,7 +1073,7 @@ func main() {
 func Sum[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1To2ImAMJA7)</span></b>
 
 ```go
 package main
@@ -953,7 +1106,7 @@ func main() {
 func Abs[T constraints.Integer | constraints.Float](x T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fsyBh1Os-1d)</span></b>
 
 ```go
 package main
@@ -965,16 +1118,184 @@ import (
 
 func main() {
     result1 := Abs(-1)
-	result2 := Abs(-0.1)
-	result3 := Abs(float32(0.2))
+    result2 := Abs(-0.1)
+    result3 := Abs(float32(0.2))
 
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
 
-	// Output:
-	// 1
-	// 0.1
-	// 0.2
+    // Output:
+    // 1
+    // 0.1
+    // 0.2
 }
 ```
+
+### <span id="Div">Div</span>
+
+<p>除法运算。</p>
+
+<b>函数签名:</b>
+
+```go
+func Div[T constraints.Float | constraints.Integer](x T, y T) float64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/WLxDdGXXYat)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.Div(9, 4)
+    result2 := mathutil.Div(1, 2)
+    result3 := mathutil.Div(0, 666)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 2.25
+    // 0.5
+    // 0
+}
+```
+
+### <span id="Variance">Variance</span>
+
+<p>计算方差。</p>
+
+<b>函数签名:</b>
+
+```go
+func Variance[T constraints.Float | constraints.Integer](numbers []T) float64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[示例](https://go.dev/play/p/uHuV4YgXf8F)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.Variance([]int{1, 2, 3, 4, 5})
+    result2 := mathutil.Variance([]float64{1.1, 2.2, 3.3, 4.4, 5.5})
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 2
+    // 2.42
+}
+```
+
+### <span id="StdDev">StdDev</span>
+
+<p>计算标准差。</p>
+
+<b>函数签名:</b>
+
+```go
+func StdDev[T constraints.Float | constraints.Integer](numbers []T) float64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/FkNZDXvHD2l)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.TruncRound(mathutil.StdDev([]int{1, 2, 3, 4, 5}), 2)
+    result2 := mathutil.TruncRound(mathutil.StdDev([]float64{1.1, 2.2, 3.3, 4.4, 5.5}), 2)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 1.41
+    // 1.55
+}
+```
+
+### <span id="Permutation">Permutation</span>
+
+<p>计算排列数P(n, k)。</p>
+
+<b>函数签名:</b>
+
+```go
+func Permutation(n, k uint) uint
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/MgobwH_FOxj)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.Permutation(5, 3)
+    result2 := mathutil.Permutation(5, 5)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 60
+    // 120
+}
+```
+
+### <span id="Combination">Combination</span>
+
+<p>计算组合数C(n, k)。</p>
+
+<b>函数签名:</b>
+
+```go
+func Combination(n, k uint) uint
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ENFQRDQUFi9)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.Combination(5, 3)
+    result2 := mathutil.Combination(5, 5)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 10
+    // 1
+}
+```

docs/api/packages/netutil.md

@@ -48,6 +48,8 @@ import (
 -   [UploadFile](#UploadFile)
 -   [IsPingConnected](#IsPingConnected)
 -   [IsTelnetConnected](#IsTelnetConnected)
+-   [BuildUrl](#BuildUrl)
+-   [AddQueryParams](#AddQueryParams)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -63,7 +65,7 @@ import (
 func ConvertMapToQueryString(param map[string]any) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jnNt_qoSnRi)</span></b>
 
 ```go
 package main
@@ -98,7 +100,7 @@ func main() {
 func EncodeUrl(urlStr string) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bsZ6BRC4uKI)</span></b>
 
 ```go
 package main
@@ -133,7 +135,7 @@ func main() {
 func GetInternalIp() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fxnna_LLD9u)</span></b>
 
 ```go
 package main
@@ -165,7 +167,7 @@ func main() {
 func GetIps() []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/NUFfcEmukx1)</span></b>
 
 ```go
 package main
@@ -195,7 +197,7 @@ func main() {
 func GetMacAddrs() []string {
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Rq9UUBS_Xp1)</span></b>
 
 ```go
 package main
@@ -239,7 +241,7 @@ type PublicIpInfo struct {
 }
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YDxIfozsRHR)</span></b>
 
 ```go
 package main
@@ -269,7 +271,7 @@ func main() {
 func GetRequestPublicIp(req *http.Request) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/kxU-YDc_eBo)</span></b>
 
 ```go
 package main
@@ -307,7 +309,7 @@ func main() {
 func IsPublicIP(IP net.IP) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nmktSQpJZnn)</span></b>
 
 ```go
 package main
@@ -344,7 +346,7 @@ func main() {
 func IsInternalIP(IP net.IP) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sYGhXbgO4Cb)</span></b>
 
 ```go
 package main
@@ -388,7 +390,7 @@ type HttpRequest struct {
 }
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -445,7 +447,7 @@ func NewHttpClientWithConfig(config *HttpClientConfig) *HttpClient
 
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -476,7 +478,7 @@ func main() {
 func (client *HttpClient) SendRequest(request *HttpRequest) (*http.Response, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -530,7 +532,7 @@ func main() {
 func (client *HttpClient) DecodeResponse(resp *http.Response, target any) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -584,7 +586,7 @@ func main() {
 func StructToUrlValues(targetStruct any) url.Values
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pFqMkM40w9z)</span></b>
 
 ```go
 package main
@@ -624,7 +626,9 @@ func main() {
 
 ### <span id="HttpGet">HttpGet</span>
 
-<p>发送http get请求。(已废弃:使用SendRequest)</p>
+<p>发送http get请求。</p>
+
+> ⚠️ 本函数已弃用，使用`SendRequest`代替。
 
 <b>函数签名:</b>
 
@@ -666,7 +670,9 @@ func main() {
 
 ### <span id="HttpPost">HttpPost</span>
 
-<p>发送http post请求。(已废弃:使用SendRequest)</p>
+<p>发送http post请求。</p>
+
+> ⚠️ 本函数已弃用，使用`SendRequest`代替。
 
 <b>函数签名:</b>
 
@@ -713,7 +719,9 @@ func main() {
 
 ### <span id="HttpPut">HttpPut</span>
 
-<p>发送http put请求。(已废弃:使用SendRequest)</p>
+<p>发送http put请求。</p>
+
+> ⚠️ 本函数已弃用，使用`SendRequest`代替。
 
 <b>函数签名:</b>
 
@@ -763,7 +771,9 @@ func main() {
 
 ### <span id="HttpDelete">HttpDelete</span>
 
-<p>发送http delete请求。(已废弃:使用SendRequest)</p>
+<p>发送http delete请求。</p>
+
+> ⚠️ 本函数已弃用，使用`SendRequest`代替。
 
 <b>函数签名:</b>
 
@@ -802,7 +812,9 @@ func main() {
 
 ### <span id="HttpPatch">HttpPatch</span>
 
-<p>发送http patch请求。(已废弃:使用SendRequest)</p>
+<p>发送http patch请求。</p>
+
+> ⚠️ 本函数已弃用，使用`SendRequest`代替。
 
 <b>函数签名:</b>
 
@@ -966,7 +978,7 @@ func main() {
 func IsPingConnected(host string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/q8OzTijsA87)</span></b>
 
 ```go
 package main
@@ -999,7 +1011,7 @@ func main() {
 func IsTelnetConnected(host string, port string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/yiLCGtQv_ZG)</span></b>
 
 ```go
 package main
@@ -1021,3 +1033,83 @@ func main() {
     // false
 }
 ```
+
+### <span id="BuildUrl">BuildUrl</span>
+
+<p>创建url字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func BuildUrl(scheme, host, path string, query map[string][]string) (string, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/JLXl1hZK7l4)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+    urlStr, err := netutil.BuildUrl(
+		"https",
+		"example.com",
+		"query",
+		map[string][]string{
+			"a": {"foo", "bar"},
+			"b": {"baz"},
+		},
+	)
+
+	fmt.Println(urlStr)
+	fmt.Println(err)
+
+	// Output:
+	// https://example.com/query?a=foo&a=bar&b=baz
+	// <nil>
+}
+```
+
+### <span id="AddQueryParams">AddQueryParams</span>
+
+<p>向url添加查询参数。</p>
+
+<b>函数签名:</b>
+
+```go
+func AddQueryParams(urlStr string, params map[string][]string) (string, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/JLXl1hZK7l4)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+    urlStr, err := netutil.BuildUrl(
+		"https",
+		"example.com",
+		"query",
+		map[string][]string{
+			"a": {"foo", "bar"},
+			"b": {"baz"},
+		},
+	)
+
+	fmt.Println(urlStr)
+	fmt.Println(err)
+
+	// Output:
+	// https://example.com/query?a=foo&a=bar&b=baz
+	// <nil>
+}
+```

docs/api/packages/pointer.md

@@ -25,8 +25,8 @@ import (
 -   [Of](#Of)
 -   [Unwrap](#Unwrap)
 -   [ExtractPointer](#ExtractPointer)
--   [UnwarpOr](#UnwarpOr)
--   [UnwarpOrDefault](#UnwarpOrDefault)
+-   [UnwrapOr](#UnwrapOr)
+-   [UnwrapOrDefault](#UnwrapOrDefault)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -42,7 +42,7 @@ import (
 func Of[T any](v T) *T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HFd70x4DrMj)</span></b>
 
 ```go
 package main
@@ -75,7 +75,7 @@ func main() {
 func Unwrap[T any](p *T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cgeu3g7cjWb)</span></b>
 
 ```go
 package main
@@ -111,7 +111,7 @@ func main() {
 func ExtractPointer(value any) any
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/D7HFjeWU2ZP)</span></b>
 
 ```go
 package main
@@ -136,17 +136,17 @@ func main() {
 }
 ```
 
-### <span id="UnwarpOr">UnwarpOr</span>
+### <span id="UnwrapOr">UnwrapOr</span>
 
 <p>返回指针的值，如果指针为零值，则返回fallback。</p>
 
 <b>函数签名:</b>
 
 ```go
-UnwarpOr[T any](p *T, fallback T) T
+UnwrapOr[T any](p *T, fallback T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mmNaLC38W8C)</span></b>
 
 ```go
 package main
@@ -163,10 +163,10 @@ func main() {
 	var c *int
 	var d *string
 
-	result1 := pointer.UnwarpOr(&a, 456)
-	result2 := pointer.UnwarpOr(&b, "abc")
-	result3 := pointer.UnwarpOr(c, 456)
-	result4 := pointer.UnwarpOr(d, "def")
+	result1 := pointer.UnwrapOr(&a, 456)
+	result2 := pointer.UnwrapOr(&b, "abc")
+	result3 := pointer.UnwrapOr(c, 456)
+	result4 := pointer.UnwrapOr(d, "def")
 
 	fmt.Println(result1)
 	fmt.Println(result2)
@@ -181,17 +181,17 @@ func main() {
 }
 ```
 
-### <span id="UnwarpOrDefault">UnwarpOrDefault</span>
+### <span id="UnwrapOrDefault">UnwrapOrDefault</span>
 
 <p>返回指针的值，如果指针为零值，则返回相应零值。</p>
 
 <b>函数签名:</b>
 
 ```go
-UnwarpOrDefault[T any](p *T) T
+UnwrapOrDefault[T any](p *T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ZnGIHf8_o4E)</span></b>
 
 ```go
 package main
@@ -208,10 +208,10 @@ func main() {
 	var c *int
 	var d *string
 
-	result1 := pointer.UnwarpOrDefault(&a)
-	result2 := pointer.UnwarpOrDefault(&b)
-	result3 := pointer.UnwarpOrDefault(c)
-	result4 := pointer.UnwarpOrDefault(d)
+	result1 := pointer.UnwrapOrDefault(&a)
+	result2 := pointer.UnwrapOrDefault(&b)
+	result3 := pointer.UnwrapOrDefault(c)
+	result4 := pointer.UnwrapOrDefault(d)
 
 	fmt.Println(result1)
 	fmt.Println(result2)

docs/api/packages/random.md

@@ -0,0 +1,551 @@
+# Random
+
+random 随机数生成器包，可以生成随机[]bytes, int, string。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/random/random.go](https://github.com/duke-git/lancet/blob/main/random/random.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/random"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [RandBytes](#RandBytes)
+-   [RandInt](#RandInt)
+-   [RandString](#RandString)
+-   [RandFromGivenSlice](#RandFromGivenSlice)
+-   [RandSliceFromGivenSlice](#RandSliceFromGivenSlice)
+-   [RandUpper](#RandUpper)
+-   [RandLower](#RandLower)
+-   [RandNumeral](#RandNumeral)
+-   [RandNumeralOrLetter](#RandNumeralOrLetter)
+-   [RandSymbolChar](#RandSymbolChar)
+-   [UUIdV4](#UUIdV4)
+-   [RandIntSlice](#RandIntSlice)
+-   [RandUniqueIntSlice](#RandUniqueIntSlice)
+-   [RandFloat](#RandFloat)
+-   [RandFloats](#RandFloats)
+-   [RandStringSlice](#RandStringSlice)
+-   [RandBool](#RandBool)
+-   [RandBoolSlice](#RandBoolSlice)
+-   [RandNumberOfLength](#RandNumberOfLength)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="RandBytes">RandBytes</span>
+
+<p>生成随机字节切片</p>
+
+<b>函数签名:</b>
+
+```go
+func RandBytes(length int) []byte
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EkiLESeXf8d)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    randBytes := random.RandBytes(4)
+    fmt.Println(randBytes)
+}
+```
+
+### <span id="RandInt">RandInt</span>
+
+<p>生成随机int, 范围[min, max)</p>
+
+<b>函数签名:</b>
+
+```go
+func RandInt(min, max int) int
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pXyyAAI5YxD)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    rInt := random.RandInt(1, 10)
+    fmt.Println(rInt)
+}
+```
+
+### <span id="RandString">RandString</span>
+
+<p>生成给定长度的随机字符串，只包含字母(a-zA-Z)</p>
+
+<b>函数签名:</b>
+
+```go
+func RandString(length int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/W2xvRUXA7Mi)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    randStr := random.RandString(6)
+    fmt.Println(randStr) //pGWsze
+}
+```
+
+### <span id="RandFromGivenSlice">RandFromGivenSlice</span>
+
+<p>从给定切片中随机生成元素。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandFromGivenSlice[T any](slice []T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UrkWueF6yYo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    nicknames := []string{"张三", "李四", "王五", "赵六", "钱七"}
+    randElm := random.RandFromGivenSlice(nicknames)
+    fmt.Println(randElm)
+}
+```
+
+### <span id="RandSliceFromGivenSlice">RandSliceFromGivenSlice</span>
+
+<p>从给定切片中生成长度为 num 的随机切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandSliceFromGivenSlice[T any](slice []T, num int, repeatable bool) []T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/68UikN9d6VT)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    goods := []string{"apple", "banana", "cherry", "elderberry", "fig", "grape", "honeydew", "kiwi", "lemon","mango", "nectarine", "orange"}
+	
+    chosen3goods := random.RandSliceFromGivenSlice(goods, 3, false)
+	
+    fmt.Println(chosen3goods)
+}
+```
+
+### <span id="RandUpper">RandUpper</span>
+
+<p>生成给定长度的随机大写字母字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func RandUpper(length int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/29QfOh0DVuh)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    randStr := random.RandString(6)
+    fmt.Println(randStr) //PACWGF
+}
+```
+
+### <span id="RandLower">RandLower</span>
+
+<p>生成给定长度的随机小写字母字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func RandLower(length int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/XJtZ471cmtI)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    randStr := random.RandLower(6)
+    fmt.Println(randStr) //siqbew
+}
+```
+
+### <span id="RandNumeral">RandNumeral</span>
+
+<p>生成给定长度的随机数字字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func RandNumeral(length int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g4JWVpHsJcf)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    randStr := random.RandNumeral(6)
+    fmt.Println(randStr) //035172
+}
+```
+
+### <span id="RandNumeralOrLetter">RandNumeralOrLetter</span>
+
+<p>生成给定长度的随机字符串（数字+字母)</p>
+
+<b>函数签名:</b>
+
+```go
+func RandNumeralOrLetter(length int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/19CEQvpx2jD)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    randStr := random.RandNumeralOrLetter(6)
+    fmt.Println(randStr) //0aW7cQ
+}
+```
+
+### <span id="RandSymbolChar">RandSymbolChar</span>
+
+<p>生成给定长度的随机符号字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandSymbolChar(length int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Im6ZJxAykOm)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    randStr := random.RandSymbolChar(6)
+    fmt.Println(randStr) // 随机特殊字符字符串，例如: @#(_")
+}
+```
+
+### <span id="UUIdV4">UUIdV4</span>
+
+<p>生成UUID v4字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func UUIdV4() (string, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_Z9SFmr28ft)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    uuid, err := random.UUIdV4()
+    if err != nil {
+        return
+    }
+    fmt.Println(uuid)
+}
+```
+
+### <span id="RandIntSlice">RandIntSlice</span>
+
+<p>生成一个特定长度的随机int切片，数值范围[min, max)。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandIntSlice(length, min, max int) []int
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GATTQ5xTEG8)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    result := random.RandIntSlice(5, 0, 10)
+    fmt.Println(result) //[1 2 7 1 5] (random)
+}
+```
+
+### <span id="RandUniqueIntSlice">RandUniqueIntSlice</span>
+
+<p>生成一个特定长度的，数值不重复的随机int切片，数值范围[min, max)。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandUniqueIntSlice(length, min, max int) []int
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uBkRSOz73Ec)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    result := random.RandUniqueIntSlice(5, 0, 10)
+    fmt.Println(result) //[0 4 7 1 5] (random)
+}
+```
+
+### <span id="RandFloat">RandFloat</span>
+
+<p>生成一个随机float64数值，可以指定精度。数值范围[min, max)。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandFloat(min, max float64, precision int) float64
+```
+
+<b>实例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zbD_tuobJtr)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    floatNumber := random.RandFloat(1.0, 5.0, 2)
+    fmt.Println(floatNumber) //2.14 (random number)
+}
+```
+
+### <span id="RandFloats">RandFloats</span>
+
+<p>生成一个特定长度的随机float64切片，可以指定数值精度。数值范围[min, max)。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandFloats(n int, min, max float64, precision int) []float64
+```
+
+<b>实例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/I3yndUQ-rhh)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    floatNumbers := random.RandFloats(5, 1.0, 5.0, 2)
+    fmt.Println(floatNumber) //[3.42 3.99 1.3 2.38 4.23] (random)
+}
+```
+
+### <span id="RandStringSlice">RandStringSlice</span>
+
+<p>生成随机字符串slice. 字符串类型需要是以下几种或者它们的组合: random.Numeral, random.LowwerLetters, random.UpperLetters random.Letters, random.SymbolChars, random.AllChars。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandStringSlice(charset string, sliceLen, strLen int) []string
+```
+
+<b>实例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2_-PiDv3tGn)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    strs := random.RandStringSlice(random.Letters, 4, 6)
+    fmt.Println(strs)
+
+    // output random string slice like below:
+    //[CooSMq RUFjDz FAeMPf heRyGv]
+}
+```
+
+### <span id="RandBool">RandBool</span>
+
+<p>生成随机bool值(true or false)。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandBool() bool
+```
+
+<b>实例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/to6BLc26wBv)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    result := random.RandBool()
+    fmt.Println(result) // true or false (random)
+}
+```
+
+### <span id="RandBoolSlice">RandBoolSlice</span>
+
+<p>生成特定长度的随机bool slice。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandBoolSlice(length int) []bool
+```
+
+<b>实例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/o-VSjPjnILI)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    result := random.RandBoolSlice(2)
+    fmt.Println(result) // [true false] (random)
+}
+```
+### <span id="RandNumberOfLength">RandNumberOfLength</span>
+
+<p>生成指定长度的随机数。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandNumberOfLength(len int) int
+```
+
+<b>实例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/oyZbuV7bu7b)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    i := random.RandNumberOfLength(2)
+    fmt.Println(i) // 21 (random number of length 2)
+}
+```

docs/api/packages/retry.md

@@ -0,0 +1,418 @@
+# Retry
+
+retry 重试执行函数直到函数运行成功或被 context cancel。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/retry/retry.go](https://github.com/duke-git/lancet/blob/main/retry/retry.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/retry"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [Context](#Context)
+-   [Retry](#Retry)
+-   [RetryFunc](#RetryFunc)
+-   [RetryDuration](#RetryDuration)
+-   [RetryTimes](#RetryTimes)
+-   [BackoffStrategy](#BackoffStrategy)
+-   [RetryWithCustomBackoff](#RetryWithCustomBackoff)
+-   [RetryWithLinearBackoff](#RetryWithLinearBackoff)
+-   [RetryWithExponentialWithJitterBackoff](#RetryWithExponentialWithJitterBackoff)
+
+<div STYLE="page-break-after: always;"></div>
+
+
+## 文档
+
+### <span id="Context">Context</span>
+
+<p>设置重试context参数</p>
+
+<b>函数签名:</b>
+
+```go
+func Context(ctx context.Context)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xnAOOXv9GkS)</span></b>
+
+```go
+import (
+    "context"
+    "errors"
+    "fmt"
+    "lancet-demo/retry"
+    "time"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.TODO())
+
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number > 3 {
+            cancel()
+        }
+        return errors.New("error occurs")
+    }
+
+    duration := retry.RetryWithLinearBackoff(time.Microsecond*50)
+
+    retry.Retry(increaseNumber,
+        duration,
+        retry.Context(ctx),
+    )
+
+    fmt.Println(number)
+
+    // Output:
+    // 4
+}
+```
+
+### <span id="RetryFunc">RetryFunc</span>
+
+<p>被重试执行的函数</p>
+
+<b>函数签名:</b>
+
+```go
+type RetryFunc func() error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nk2XRmagfVF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+func main() {
+    number := 0
+    var increaseNumber retry.RetryFunc = func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    duration := retry.RetryWithLinearBackoff(time.Microsecond*50)
+
+    err := retry.Retry(increaseNumber, duration)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```
+
+### <span id="RetryTimes">RetryTimes</span>
+
+<p>设置重试次数，默认5</p>
+
+<b>函数签名:</b>
+
+```go
+func RetryTimes(n uint)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ssfVeU2SwLO)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+func main() {
+    number := 0
+
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    err := retry.Retry(increaseNumber, retry.RetryTimes(2))
+    if err != nil {
+        fmt.Println(err)
+    }
+
+    // Output:
+    // function main.main.func1 run failed after 2 times retry
+}
+```
+
+### <span id="Retry">Retry</span>
+
+<p>重试执行函数retryFunc，直到函数运行成功，或被context停止</p>
+
+<b>函数签名:</b>
+
+```go
+func Retry(retryFunc RetryFunc, opts ...Option) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nk2XRmagfVF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+func main() {
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    duration := retry.RetryWithLinearBackoff(time.Microsecond*50)
+
+    err := retry.Retry(increaseNumber, duration)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```
+
+### <span id="BackoffStrategy">BackoffStrategy</span>
+
+<p>定义计算退避间隔的方法的接口。</p>
+
+<b>函数签名:</b>
+
+```go
+// BackoffStrategy is an interface that defines a method for calculating backoff intervals.
+type BackoffStrategy interface {
+    // CalculateInterval returns the time.Duration after which the next retry attempt should be made.
+    CalculateInterval() time.Duration
+}
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+type ExampleCustomBackoffStrategy struct {
+    interval time.Duration
+}
+
+func (c *ExampleCustomBackoffStrategy) CalculateInterval() time.Duration {
+    return c.interval + 1
+}
+
+func main() {
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    err := retry,Retry(increaseNumber, retry.RetryWithCustomBackoff(&示例CustomBackoffStrategy{interval: time.Microsecond * 50}))
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```
+
+### <span id="RetryWithCustomBackoff">RetryWithCustomBackoff</span>
+
+<p>设置自定义退避策略。</p>
+
+<b>函数签名:</b>
+
+```go
+func RetryWithCustomBackoff(backoffStrategy BackoffStrategy) Option 
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jIm_o2vb5Y4)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+type ExampleCustomBackoffStrategy struct {
+    interval time.Duration
+}
+
+func (c *ExampleCustomBackoffStrategy) CalculateInterval() time.Duration {
+    return c.interval + 1
+}
+
+func main() {
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    err := retry,Retry(increaseNumber, retry.RetryWithCustomBackoff(&示例CustomBackoffStrategy{interval: time.Microsecond * 50}))
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```
+
+
+### <span id="RetryWithLinearBackoff">RetryWithLinearBackoff</span>
+
+<p>设置线性策略退避。</p>
+
+<b>函数签名:</b>
+
+```go
+func RetryWithLinearBackoff(interval time.Duration) Option
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/PDet2ZQZwcB)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+func main() {
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    err := retry.Retry(increaseNumber, retry.RetryWithLinearBackoff(time.Microsecond*50))
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```
+
+
+### <span id="RetryWithExponentialWithJitterBackoff">RetryWithExponentialWithJitterBackoff</span>
+
+<p>设置指数策略退避。</p>
+
+<b>函数签名:</b>
+
+```go
+func RetryWithExponentialWithJitterBackoff(interval time.Duration, base uint64, maxJitter time.Duration) Option
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xp1avQmn16X)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+func main() {
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    err := retry.Retry(increaseNumber, retry.RetryWithExponentialWithJitterBackoff(time.Microsecond*50, 2, time.Microsecond*25))
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```