test: update TestZipFolder

* feat: CopyOnWriteList adds more functions such as ForEach, Sort

* feat: CopyOnWriteList adds more functions such as ForEach, Sort

.gitignore

@@ -6,5 +6,7 @@ fileutil/*.txt
 fileutil/*.zip
 fileutil/*.link
 fileutil/unzip/*
+fileutil/tempdir/*
 slice/testdata/*
-cryptor/*.pem
+cryptor/*.pem
+test

algorithm/lrucache.go

@@ -26,7 +26,7 @@ type LRUCache[K comparable, V any] struct {
 	length   int
 }
 
-// NewLRUCache return a LRUCache pointer
+// NewLRUCache creates a LRUCache pointer instance.
 func NewLRUCache[K comparable, V any](capacity int) *LRUCache[K, V] {
 	return &LRUCache[K, V]{
 		cache:    make(map[K]*lruNode[K, V], capacity),
@@ -37,7 +37,8 @@ func NewLRUCache[K comparable, V any](capacity int) *LRUCache[K, V] {
 	}
 }
 
-// Get value of key from lru cache
+// Get value of key from lru cache.
+// Play: https://go.dev/play/p/iUynEfOP8G0
 func (l *LRUCache[K, V]) Get(key K) (V, bool) {
 	var value V
 
@@ -50,7 +51,8 @@ func (l *LRUCache[K, V]) Get(key K) (V, bool) {
 	return value, false
 }
 
-// Put value of key into lru cache
+// Put value of key into lru cache.
+// Play: https://go.dev/play/p/iUynEfOP8G0
 func (l *LRUCache[K, V]) Put(key K, value V) {
 	node, ok := l.cache[key]
 	if !ok {
@@ -69,6 +71,23 @@ func (l *LRUCache[K, V]) Put(key K, value V) {
 	l.length = len(l.cache)
 }
 
+// Delete item from lru cache.
+func (l *LRUCache[K, V]) Delete(key K) bool {
+	node, ok := l.cache[key]
+	if ok {
+		key := l.deleteNode(node)
+		delete(l.cache, key)
+		return true
+	}
+
+	return false
+}
+
+// Len returns the number of items in the cache.
+func (l *LRUCache[K, V]) Len() int {
+	return l.length
+}
+
 func (l *LRUCache[K, V]) addNode(node *lruNode[K, V]) {
 	if l.tail != nil {
 		l.tail.next = node

algorithm/lrucache_example_test.go

@@ -0,0 +1,79 @@
+package algorithm
+
+import "fmt"
+
+func ExampleLRUCache_Put() {
+	cache := NewLRUCache[int, int](2)
+
+	cache.Put(1, 1)
+	cache.Put(2, 2)
+
+	result1, ok1 := cache.Get(1)
+	result2, ok2 := cache.Get(2)
+	result3, ok3 := cache.Get(3)
+
+	fmt.Println(result1, ok1)
+	fmt.Println(result2, ok2)
+	fmt.Println(result3, ok3)
+
+	// Output:
+	// 1 true
+	// 2 true
+	// 0 false
+}
+
+func ExampleLRUCache_Get() {
+	cache := NewLRUCache[int, int](2)
+
+	cache.Put(1, 1)
+	cache.Put(2, 2)
+
+	result1, ok1 := cache.Get(1)
+	result2, ok2 := cache.Get(2)
+	result3, ok3 := cache.Get(3)
+
+	fmt.Println(result1, ok1)
+	fmt.Println(result2, ok2)
+	fmt.Println(result3, ok3)
+
+	// Output:
+	// 1 true
+	// 2 true
+	// 0 false
+}
+
+func ExampleLRUCache_Delete() {
+	cache := NewLRUCache[int, int](2)
+
+	cache.Put(1, 1)
+	cache.Put(2, 2)
+
+	result1, ok1 := cache.Get(1)
+
+	ok2 := cache.Delete(2)
+
+	_, ok3 := cache.Get(2)
+
+	fmt.Println(result1, ok1)
+	fmt.Println(ok2)
+	fmt.Println(ok3)
+
+	// Output:
+	// 1 true
+	// true
+	// false
+}
+
+func ExampleLRUCache_Len() {
+	cache := NewLRUCache[int, int](2)
+
+	cache.Put(1, 1)
+	cache.Put(2, 2)
+
+	result := cache.Len()
+
+	fmt.Println(result)
+
+	// Output:
+	// 2
+}

algorithm/lrucache_test.go

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

algorithm/search.go

@@ -1,26 +1,28 @@
 // Copyright 2021 dudaodong@gmail.com. All rights reserved.
 // Use of this source code is governed by MIT license
 
-// Package algorithm contain some basic algorithm functions. eg. sort, search, list, linklist, stack, queue, tree, graph. TODO
+// 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"
 
 // Search algorithms see https://github.com/TheAlgorithms/Go/tree/master/search
 
-// LinearSearch Simple linear search algorithm that iterates over all elements of an slice
-// If a target is found, the index of the target is returned. Else the function return -1
-func LinearSearch[T any](slice []T, target T, comparator lancetconstraints.Comparator) int {
+// LinearSearch return the index of target in slice base on equal function.
+// If not found return -1
+// Play: https://go.dev/play/p/IsS7rgn5s3x
+func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int {
 	for i, v := range slice {
-		if comparator.Compare(v, target) == 0 {
+		if equal(v, target) {
 			return i
 		}
 	}
 	return -1
 }
 
-// BinarySearch search for target within a sorted slice, recursive call itself.
-// If a target is found, the index of the target is returned. Else the function return -1
+// 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 {
 	if highIndex < lowIndex || len(sortedSlice) == 0 {
 		return -1
@@ -39,8 +41,9 @@ func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, com
 	return midIndex
 }
 
-// BinaryIterativeSearch search for target within a sorted slice.
-// If a target is found, the index of the target is returned. Else the function return -1
+// 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 {
 	startIndex := lowIndex
 	endIndex := highIndex

algorithm/search_example_test.go

@@ -0,0 +1,51 @@
+package algorithm
+
+import "fmt"
+
+func ExampleLinearSearch() {
+	numbers := []int{3, 4, 5, 3, 2, 1}
+
+	equalFunc := func(a, b int) bool {
+		return a == b
+	}
+
+	result1 := LinearSearch(numbers, 3, equalFunc)
+	result2 := LinearSearch(numbers, 6, equalFunc)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// 0
+	// -1
+}
+
+func ExampleBinarySearch() {
+	numbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
+	comparator := &intComparator{}
+
+	result1 := BinarySearch(numbers, 5, 0, len(numbers)-1, comparator)
+	result2 := BinarySearch(numbers, 9, 0, len(numbers)-1, comparator)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// 4
+	// -1
+}
+
+func ExampleBinaryIterativeSearch() {
+	numbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
+	comparator := &intComparator{}
+
+	result1 := BinaryIterativeSearch(numbers, 5, 0, len(numbers)-1, comparator)
+	result2 := BinaryIterativeSearch(numbers, 9, 0, len(numbers)-1, comparator)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// 4
+	// -1
+}

algorithm/search_test.go

@@ -6,20 +6,26 @@ import (
 	"github.com/duke-git/lancet/v2/internal"
 )
 
-var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
-
 func TestLinearSearch(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestLinearSearch")
 
-	comparator := &intComparator{}
-	asssert.Equal(4, LinearSearch(sortedNumbers, 5, comparator))
-	asssert.Equal(-1, LinearSearch(sortedNumbers, 9, comparator))
+	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))
 }
 
 func TestBinarySearch(t *testing.T) {
+	t.Parallel()
 	asssert := 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))
 }
@@ -27,7 +33,9 @@ func TestBinarySearch(t *testing.T) {
 func TestBinaryIterativeSearch(t *testing.T) {
 	asssert := 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))
 }

algorithm/sort.go

@@ -1,12 +1,12 @@
 // Copyright 2021 dudaodong@gmail.com. All rights reserved.
 // Use of this source code is governed by MIT license
 
-// Package algorithm contain some basic algorithm functions. eg. sort, search
 package algorithm
 
 import "github.com/duke-git/lancet/v2/lancetconstraints"
 
-// BubbleSort use bubble to sort slice.
+// 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) {
 	for i := 0; i < len(slice); i++ {
 		for j := 0; j < len(slice)-1-i; j++ {
@@ -18,7 +18,8 @@ func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 	}
 }
 
-// InsertionSort use insertion to sort slice.
+// 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) {
 	for i := 0; i < len(slice); i++ {
 		for j := i; j > 0; j-- {
@@ -32,7 +33,8 @@ func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 	}
 }
 
-// SelectionSort use selection to sort slice.
+// 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) {
 	for i := 0; i < len(slice); i++ {
 		min := i
@@ -45,7 +47,8 @@ func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 	}
 }
 
-// ShellSort shell sort slice.
+// 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) {
 	size := len(slice)
 
@@ -64,7 +67,8 @@ func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 	}
 }
 
-// QuickSort quick sorting for slice, lowIndex is 0 and highIndex is len(slice)-1
+// 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) {
 	quickSort(slice, 0, len(slice)-1, comparator)
 }
@@ -93,7 +97,8 @@ func partition[T any](slice []T, lowIndex, highIndex int, comparator lancetconst
 	return i
 }
 
-// HeapSort use heap to sort slice
+// 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) {
 	size := len(slice)
 
@@ -126,7 +131,8 @@ func sift[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraint
 	slice[i] = temp
 }
 
-// MergeSort merge sorting for slice
+// 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) {
 	mergeSort(slice, 0, len(slice)-1, comparator)
 }
@@ -167,7 +173,8 @@ func merge[T any](slice []T, lowIndex, midIndex, highIndex int, comparator lance
 	}
 }
 
-// CountSort use count sorting for slice
+// 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 {
 	size := len(slice)
 	out := make([]T, size)

algorithm/sort_example_test.go

@@ -0,0 +1,93 @@
+package algorithm
+
+import "fmt"
+
+func ExampleBubbleSort() {
+	numbers := []int{2, 1, 5, 3, 6, 4}
+	comparator := &intComparator{}
+
+	BubbleSort(numbers, comparator)
+
+	fmt.Println(numbers)
+	// Output:
+	// [1 2 3 4 5 6]
+}
+
+func ExampleCountSort() {
+	numbers := []int{2, 1, 5, 3, 6, 4}
+	comparator := &intComparator{}
+
+	sortedNumber := CountSort(numbers, comparator)
+
+	fmt.Println(numbers)
+	fmt.Println(sortedNumber)
+	// Output:
+	// [2 1 5 3 6 4]
+	// [1 2 3 4 5 6]
+}
+
+func ExampleHeapSort() {
+	numbers := []int{2, 1, 5, 3, 6, 4}
+	comparator := &intComparator{}
+
+	HeapSort(numbers, comparator)
+
+	fmt.Println(numbers)
+	// Output:
+	// [1 2 3 4 5 6]
+}
+
+func ExampleMergeSort() {
+	numbers := []int{2, 1, 5, 3, 6, 4}
+	comparator := &intComparator{}
+
+	MergeSort(numbers, comparator)
+
+	fmt.Println(numbers)
+	// Output:
+	// [1 2 3 4 5 6]
+}
+
+func ExampleInsertionSort() {
+	numbers := []int{2, 1, 5, 3, 6, 4}
+	comparator := &intComparator{}
+
+	InsertionSort(numbers, comparator)
+
+	fmt.Println(numbers)
+	// Output:
+	// [1 2 3 4 5 6]
+}
+
+func ExampleSelectionSort() {
+	numbers := []int{2, 1, 5, 3, 6, 4}
+	comparator := &intComparator{}
+
+	SelectionSort(numbers, comparator)
+
+	fmt.Println(numbers)
+	// Output:
+	// [1 2 3 4 5 6]
+}
+
+func ExampleShellSort() {
+	numbers := []int{2, 1, 5, 3, 6, 4}
+	comparator := &intComparator{}
+
+	ShellSort(numbers, comparator)
+
+	fmt.Println(numbers)
+	// Output:
+	// [1 2 3 4 5 6]
+}
+
+func ExampleQuickSort() {
+	numbers := []int{2, 1, 5, 3, 6, 4}
+	comparator := &intComparator{}
+
+	QuickSort(numbers, comparator)
+
+	fmt.Println(numbers)
+	// Output:
+	// [1 2 3 4 5 6]
+}

algorithm/sort_test.go

@@ -46,6 +46,7 @@ func (c *intComparator) Compare(v1 any, v2 any) int {
 }
 
 func TestBubbleSortForStructSlice(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestBubbleSortForStructSlice")
 
 	peoples := []people{
@@ -65,7 +66,9 @@ func TestBubbleSortForStructSlice(t *testing.T) {
 }
 
 func TestBubbleSortForIntSlice(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestBubbleSortForIntSlice")
+
 	numbers := []int{2, 1, 5, 3, 6, 4}
 	comparator := &intComparator{}
 	BubbleSort(numbers, comparator)
@@ -74,6 +77,7 @@ func TestBubbleSortForIntSlice(t *testing.T) {
 }
 
 func TestInsertionSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestInsertionSort")
 
 	peoples := []people{
@@ -93,6 +97,7 @@ func TestInsertionSort(t *testing.T) {
 }
 
 func TestSelectionSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestSelectionSort")
 
 	peoples := []people{
@@ -112,6 +117,7 @@ func TestSelectionSort(t *testing.T) {
 }
 
 func TestShellSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestShellSort")
 
 	peoples := []people{
@@ -131,6 +137,7 @@ func TestShellSort(t *testing.T) {
 }
 
 func TestQuickSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestQuickSort")
 
 	peoples := []people{
@@ -150,6 +157,7 @@ func TestQuickSort(t *testing.T) {
 }
 
 func TestHeapSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestHeapSort")
 
 	peoples := []people{
@@ -169,6 +177,7 @@ func TestHeapSort(t *testing.T) {
 }
 
 func TestMergeSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestMergeSort")
 
 	peoples := []people{
@@ -188,6 +197,7 @@ func TestMergeSort(t *testing.T) {
 }
 
 func TestCountSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestCountSort")
 
 	peoples := []people{
@@ -199,7 +209,6 @@ func TestCountSort(t *testing.T) {
 	}
 	comparator := &peopleAgeComparator{}
 	sortedPeopleByAge := CountSort(peoples, comparator)
-	t.Log(sortedPeopleByAge)
 
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", sortedPeopleByAge)

compare/compare.go

@@ -0,0 +1,71 @@
+// Copyright 2023 dudaodong@gmail.com. All rights resulterved.
+// Use of this source code is governed by MIT license
+
+// Package compare provides a lightweight comparison function on any type.
+// reference: https://github.com/stretchr/testify
+package compare
+
+import (
+	"reflect"
+	"time"
+
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/mathutil"
+	"golang.org/x/exp/constraints"
+)
+
+// operator type
+const (
+	equal          = "eq"
+	lessThan       = "lt"
+	greaterThan    = "gt"
+	lessOrEqual    = "le"
+	greaterOrEqual = "ge"
+)
+
+var (
+	timeType  = reflect.TypeOf(time.Time{})
+	bytesType = reflect.TypeOf([]byte{})
+)
+
+// Equal checks if two values are equal or not. (check both type and value)
+// Play: https://go.dev/play/p/wmVxR-to4lz
+func Equal(left, right any) bool {
+	return compareValue(equal, left, right)
+}
+
+// EqualValue checks if two values are equal or not. (check value only)
+// Play: https://go.dev/play/p/fxnna_LLD9u
+func EqualValue(left, right any) bool {
+	ls, rs := convertor.ToString(left), convertor.ToString(right)
+	return ls == rs
+}
+
+// LessThan checks if value `left` less than value `right`.
+// Play: https://go.dev/play/p/cYh7FQQj0ne
+func LessThan(left, right any) bool {
+	return compareValue(lessThan, left, right)
+}
+
+// GreaterThan checks if value `left` greater than value `right`.
+// Play: https://go.dev/play/p/9-NYDFZmIMp
+func GreaterThan(left, right any) bool {
+	return compareValue(greaterThan, left, right)
+}
+
+// LessOrEqual checks if value `left` less than or equal to value `right`.
+// Play: https://go.dev/play/p/e4T_scwoQzp
+func LessOrEqual(left, right any) bool {
+	return compareValue(lessOrEqual, left, right)
+}
+
+// GreaterOrEqual checks if value `left` greater than or equal to value `right`.
+// Play: https://go.dev/play/p/vx8mP0U8DFk
+func GreaterOrEqual(left, right any) bool {
+	return compareValue(greaterOrEqual, left, right)
+}
+
+// InDelta checks if two values are equal or not within a delta.
+func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool {
+	return float64(mathutil.Abs(left-right)) <= delta
+}

compare/compare_example_test.go

@@ -0,0 +1,196 @@
+package compare
+
+import (
+	"fmt"
+	"time"
+)
+
+func ExampleEqual() {
+	result1 := Equal(1, 1)
+	result2 := Equal("1", "1")
+	result3 := Equal([]int{1, 2, 3}, []int{1, 2, 3})
+	result4 := Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"})
+
+	result5 := Equal(1, "1")
+	result6 := Equal(1, int64(1))
+	result7 := Equal([]int{1, 2}, []int{1, 2, 3})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+	fmt.Println(result7)
+
+	// Output:
+	// true
+	// true
+	// true
+	// true
+	// false
+	// false
+	// false
+}
+
+func ExampleEqualValue() {
+	result1 := EqualValue(1, 1)
+	result2 := EqualValue(int(1), int64(1))
+	result3 := EqualValue(1, "1")
+	result4 := EqualValue(1, "2")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// true
+	// true
+	// true
+	// false
+}
+
+func ExampleLessThan() {
+	result1 := LessThan(1, 2)
+	result2 := LessThan(1.1, 2.2)
+	result3 := LessThan("a", "b")
+
+	time1 := time.Now()
+	time2 := time1.Add(time.Second)
+	result4 := LessThan(time1, time2)
+
+	result5 := LessThan(2, 1)
+	result6 := LessThan(1, int64(2))
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+
+	// Output:
+	// true
+	// true
+	// true
+	// true
+	// false
+	// false
+}
+
+func ExampleGreaterThan() {
+	result1 := GreaterThan(2, 1)
+	result2 := GreaterThan(2.2, 1.1)
+	result3 := GreaterThan("b", "a")
+
+	time1 := time.Now()
+	time2 := time1.Add(time.Second)
+	result4 := GreaterThan(time2, time1)
+
+	result5 := GreaterThan(1, 2)
+	result6 := GreaterThan(int64(2), 1)
+	result7 := GreaterThan("b", "c")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+	fmt.Println(result7)
+
+	// Output:
+	// true
+	// true
+	// true
+	// true
+	// false
+	// false
+	// false
+}
+
+func ExampleLessOrEqual() {
+	result1 := LessOrEqual(1, 1)
+	result2 := LessOrEqual(1.1, 2.2)
+	result3 := LessOrEqual("a", "b")
+
+	time1 := time.Now()
+	time2 := time1.Add(time.Second)
+	result4 := LessOrEqual(time1, time2)
+
+	result5 := LessOrEqual(2, 1)
+	result6 := LessOrEqual(1, int64(2))
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+
+	// Output:
+	// true
+	// true
+	// true
+	// true
+	// false
+	// false
+}
+
+func ExampleGreaterOrEqual() {
+	result1 := GreaterOrEqual(1, 1)
+	result2 := GreaterOrEqual(2.2, 1.1)
+	result3 := GreaterOrEqual("b", "b")
+
+	time1 := time.Now()
+	time2 := time1.Add(time.Second)
+	result4 := GreaterOrEqual(time2, time1)
+
+	result5 := GreaterOrEqual(1, 2)
+	result6 := GreaterOrEqual(int64(2), 1)
+	result7 := GreaterOrEqual("b", "c")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+	fmt.Println(result7)
+
+	// Output:
+	// true
+	// true
+	// true
+	// true
+	// false
+	// false
+	// false
+}
+
+func ExampleInDelta() {
+	result1 := InDelta(1, 1, 0)
+	result2 := InDelta(1, 2, 0)
+
+	result3 := InDelta(2.0/3.0, 0.66667, 0.001)
+	result4 := InDelta(2.0/3.0, 0.0, 0.001)
+
+	result5 := InDelta(float64(74.96)-float64(20.48), 54.48, 0)
+	result6 := InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+
+	// Output:
+	// true
+	// false
+	// true
+	// false
+	// false
+	// true
+}

compare/compare_internal.go

@@ -0,0 +1,323 @@
+package compare
+
+import (
+	"bytes"
+	"encoding/json"
+	"reflect"
+	"time"
+
+	"github.com/duke-git/lancet/v2/convertor"
+)
+
+func compareValue(operator string, left, right any) bool {
+	leftType, rightType := reflect.TypeOf(left), reflect.TypeOf(right)
+
+	if leftType.Kind() != rightType.Kind() {
+		return false
+	}
+
+	switch leftType.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+		reflect.Float32, reflect.Float64, reflect.Bool, reflect.String:
+		return compareBasicValue(operator, left, right)
+
+	case reflect.Struct, reflect.Slice, reflect.Map:
+		return compareRefValue(operator, left, right, leftType.Kind())
+	}
+
+	return false
+}
+
+func compareRefValue(operator string, leftObj, rightObj any, kind reflect.Kind) bool {
+	leftVal, rightVal := reflect.ValueOf(leftObj), reflect.ValueOf(rightObj)
+
+	switch kind {
+	case reflect.Struct:
+
+		// compare time
+		if leftVal.CanConvert(timeType) {
+			timeObj1, ok := leftObj.(time.Time)
+			if !ok {
+				timeObj1 = leftVal.Convert(timeType).Interface().(time.Time)
+			}
+
+			timeObj2, ok := rightObj.(time.Time)
+			if !ok {
+				timeObj2 = rightVal.Convert(timeType).Interface().(time.Time)
+			}
+
+			return compareBasicValue(operator, timeObj1.UnixNano(), timeObj2.UnixNano())
+		}
+
+		// for other struct type, only process equal operator
+		switch operator {
+		case equal:
+			return objectsAreEqualValues(leftObj, rightObj)
+		}
+
+	case reflect.Slice:
+		// compare []byte
+		if leftVal.CanConvert(bytesType) {
+			bytesObj1, ok := leftObj.([]byte)
+			if !ok {
+				bytesObj1 = leftVal.Convert(bytesType).Interface().([]byte)
+			}
+			bytesObj2, ok := rightObj.([]byte)
+			if !ok {
+				bytesObj2 = rightVal.Convert(bytesType).Interface().([]byte)
+			}
+
+			switch operator {
+			case equal:
+				if bytes.Compare(bytesObj1, bytesObj2) == 0 {
+					return true
+				}
+			case lessThan:
+				if bytes.Compare(bytesObj1, bytesObj2) == -1 {
+					return true
+				}
+			case greaterThan:
+				if bytes.Compare(bytesObj1, bytesObj2) == 1 {
+					return true
+				}
+			case lessOrEqual:
+				if bytes.Compare(bytesObj1, bytesObj2) <= 0 {
+					return true
+				}
+			case greaterOrEqual:
+				if bytes.Compare(bytesObj1, bytesObj2) >= 0 {
+					return true
+				}
+			}
+
+		}
+
+		// for other type slice, only process equal operator
+		switch operator {
+		case equal:
+			return reflect.DeepEqual(leftObj, rightObj)
+		}
+
+	case reflect.Map:
+		// only process equal operator
+		switch operator {
+		case equal:
+			return reflect.DeepEqual(leftObj, rightObj)
+		}
+	}
+
+	return false
+}
+
+func objectsAreEqualValues(expected, actual interface{}) bool {
+	if objectsAreEqual(expected, actual) {
+		return true
+	}
+
+	actualType := reflect.TypeOf(actual)
+	if actualType == nil {
+		return false
+	}
+	expectedValue := reflect.ValueOf(expected)
+	if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) {
+		// Attempt comparison after type conversion
+		return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual)
+	}
+
+	return false
+}
+
+func objectsAreEqual(expected, actual interface{}) bool {
+	if expected == nil || actual == nil {
+		return expected == actual
+	}
+
+	exp, ok := expected.([]byte)
+	if !ok {
+		return reflect.DeepEqual(expected, actual)
+	}
+
+	act, ok := actual.([]byte)
+	if !ok {
+		return false
+	}
+	if exp == nil || act == nil {
+		return exp == nil && act == nil
+	}
+	return bytes.Equal(exp, act)
+}
+
+// compareBasic compare basic value: integer, float, string, bool
+func compareBasicValue(operator string, leftValue, rightValue any) bool {
+	if leftValue == nil && rightValue == nil && operator == equal {
+		return true
+	}
+
+	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 float32, float64, int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
+		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
+				}
+			}
+		}
+
+	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
+				}
+			}
+		}
+
+	case bool:
+		left := leftVal
+		switch right := rightValue.(type) {
+		case bool:
+			switch operator {
+			case equal:
+				if left == right {
+					return true
+				}
+			}
+		}
+
+	}
+
+	return false
+}

compare/compare_test.go

@@ -0,0 +1,156 @@
+package compare
+
+import (
+	"testing"
+	"time"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+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
+	}{
+		A: "a",
+		B: "b",
+	}
+
+	st2 := struct {
+		A string
+		B string
+	}{
+		A: "a",
+		B: "b",
+	}
+
+	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"))
+
+	assert.Equal(false, EqualValue(1, "2"))
+}
+
+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"))
+
+	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)))
+}
+
+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"))
+
+	time1 := time.Now()
+	time2 := time1.Add(time.Second)
+	assert.Equal(true, GreaterThan(time2, time1))
+
+	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"))
+
+	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)))
+}
+
+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"))
+
+	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"))
+}
+
+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))
+
+	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))
+}

concurrency/channel.go

@@ -1,7 +1,7 @@
 // Copyright 2021 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, async.
+// Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel.
 package concurrency
 
 import (
@@ -11,17 +11,18 @@ import (
 
 // Channel is a logic object which can generate or manipulate go channel
 // all methods of Channel are in the book tilted《Concurrency in Go》
-type Channel struct {
+type Channel[T any] struct {
 }
 
 // NewChannel return a Channel instance
-func NewChannel() *Channel {
-	return &Channel{}
+func NewChannel[T any]() *Channel[T] {
+	return &Channel[T]{}
 }
 
-// Generate a data of type any chan, put param `values` into the chan
-func (c *Channel) Generate(ctx context.Context, values ...any) <-chan any {
-	dataStream := make(chan any)
+// Generate creates channel, then put values into the channel.
+// Play: https://go.dev/play/p/7aB4KyMMp9A
+func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T {
+	dataStream := make(chan T)
 
 	go func() {
 		defer close(dataStream)
@@ -38,9 +39,10 @@ func (c *Channel) Generate(ctx context.Context, values ...any) <-chan any {
 	return dataStream
 }
 
-// Repeat return a data of type any chan, put param `values` into the chan repeatly until cancel the context.
-func (c *Channel) Repeat(ctx context.Context, values ...any) <-chan any {
-	dataStream := make(chan any)
+// Repeat create channel, put values into the channel repeatly until cancel the context.
+// Play: https://go.dev/play/p/k5N_ALVmYjE
+func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T {
+	dataStream := make(chan T)
 
 	go func() {
 		defer close(dataStream)
@@ -57,10 +59,11 @@ func (c *Channel) Repeat(ctx context.Context, values ...any) <-chan any {
 	return dataStream
 }
 
-// RepeatFn return a chan, excutes fn repeatly, and put the result into retruned chan
-// until close the `done` channel
-func (c *Channel) RepeatFn(ctx context.Context, fn func() any) <-chan any {
-	dataStream := make(chan any)
+// RepeatFn create a channel, excutes fn repeatly, and put the result into the channel
+// until close context.
+// Play: https://go.dev/play/p/4J1zAWttP85
+func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T {
+	dataStream := make(chan T)
 
 	go func() {
 		defer close(dataStream)
@@ -75,9 +78,10 @@ func (c *Channel) RepeatFn(ctx context.Context, fn func() any) <-chan any {
 	return dataStream
 }
 
-// Take return a chan whose values are tahken from another chan
-func (c *Channel) Take(ctx context.Context, valueStream <-chan any, number int) <-chan any {
-	takeStream := make(chan any)
+// Take create a channel whose values are taken from another channel with limit number.
+// Play: https://go.dev/play/p/9Utt-1pDr2J
+func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T {
+	takeStream := make(chan T)
 
 	go func() {
 		defer close(takeStream)
@@ -94,16 +98,17 @@ func (c *Channel) Take(ctx context.Context, valueStream <-chan any, number int)
 	return takeStream
 }
 
-// FanIn merge multiple channels into one channel
-func (c *Channel) FanIn(ctx context.Context, channels ...<-chan any) <-chan any {
-	out := make(chan any)
+// FanIn merge multiple channels into one channel.
+// Play: https://go.dev/play/p/2VYFMexEvTm
+func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T {
+	out := make(chan T)
 
 	go func() {
 		var wg sync.WaitGroup
 		wg.Add(len(channels))
 
 		for _, c := range channels {
-			go func(c <-chan any) {
+			go func(c <-chan T) {
 				defer wg.Done()
 				for v := range c {
 					select {
@@ -121,10 +126,11 @@ func (c *Channel) FanIn(ctx context.Context, channels ...<-chan any) <-chan any
 	return out
 }
 
-// Tee split one chanel into two channels
-func (c *Channel) Tee(ctx context.Context, in <-chan any) (<-chan any, <-chan any) {
-	out1 := make(chan any)
-	out2 := make(chan any)
+// Tee split one chanel into two channels, until cancel the context.
+// Play: https://go.dev/play/p/3TQPKnCirrP
+func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T) {
+	out1 := make(chan T)
+	out2 := make(chan T)
 
 	go func() {
 		defer close(out1)
@@ -147,18 +153,19 @@ func (c *Channel) Tee(ctx context.Context, in <-chan any) (<-chan any, <-chan an
 	return out1, out2
 }
 
-// Bridge link multiply channels into one channel
-func (c *Channel) Bridge(ctx context.Context, chanStream <-chan <-chan any) <-chan any {
-	valStream := make(chan any)
+// Bridge link multiply channels into one channel.
+// 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)
 
 		for {
-			var stream <-chan any
+			var stream <-chan T
 			select {
 			case maybeStream, ok := <-chanStream:
-				if ok == false {
+				if !ok {
 					return
 				}
 				stream = maybeStream
@@ -178,8 +185,9 @@ func (c *Channel) Bridge(ctx context.Context, chanStream <-chan <-chan any) <-ch
 	return valStream
 }
 
-// Or read one or more channels into one channel, will close when any readin channel is closed
-func (c *Channel) Or(channels ...<-chan any) <-chan any {
+// Or read one or more channels into one channel, will close when any readin channel is closed.
+// Play: https://go.dev/play/p/Wqz9rwioPww
+func (c *Channel[T]) Or(channels ...<-chan T) <-chan T {
 	switch len(channels) {
 	case 0:
 		return nil
@@ -187,7 +195,7 @@ func (c *Channel) Or(channels ...<-chan any) <-chan any {
 		return channels[0]
 	}
 
-	orDone := make(chan any)
+	orDone := make(chan T)
 
 	go func() {
 		defer close(orDone)
@@ -199,17 +207,12 @@ func (c *Channel) Or(channels ...<-chan any) <-chan any {
 			case <-channels[1]:
 			}
 		default:
-			m := len(channels) / 2
 			select {
-			case <-c.Or(channels[:m]...):
-			case <-c.Or(channels[m:]...):
+			case <-channels[0]:
+			case <-channels[1]:
+			case <-channels[2]:
+			case <-c.Or(append(channels[3:], orDone)...):
 			}
-			// select {
-			// case <-channels[0]:
-			// case <-channels[1]:
-			// case <-channels[2]:
-			// case <-c.Or(append(channels[3:], orDone)...):
-			// }
 		}
 	}()
 
@@ -217,8 +220,9 @@ func (c *Channel) Or(channels ...<-chan any) <-chan any {
 }
 
 // OrDone read a channel into another channel, will close until cancel context.
-func (c *Channel) OrDone(ctx context.Context, channel <-chan any) <-chan any {
-	valStream := make(chan any)
+// Play: https://go.dev/play/p/lm_GoS6aDjo
+func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T {
+	valStream := make(chan T)
 
 	go func() {
 		defer close(valStream)

concurrency/channel_example_test.go

@@ -0,0 +1,196 @@
+package concurrency
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+func ExampleChannel_Generate() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := NewChannel[int]()
+	intStream := c.Generate(ctx, 1, 2, 3)
+
+	fmt.Println(<-intStream)
+	fmt.Println(<-intStream)
+	fmt.Println(<-intStream)
+
+	// Output:
+	// 1
+	// 2
+	// 3
+}
+
+func ExampleChannel_Repeat() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := NewChannel[int]()
+	intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
+
+	for v := range intStream {
+		fmt.Println(v)
+	}
+	// Output:
+	// 1
+	// 2
+	// 1
+	// 2
+}
+
+func ExampleChannel_RepeatFn() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	fn := func() string {
+		return "hello"
+	}
+
+	c := NewChannel[string]()
+	intStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
+
+	for v := range intStream {
+		fmt.Println(v)
+	}
+	// Output:
+	// hello
+	// hello
+	// hello
+}
+
+func ExampleChannel_Take() {
+	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 := NewChannel[int]()
+	intStream := c.Take(ctx, numbers, 3)
+
+	for v := range intStream {
+		fmt.Println(v)
+	}
+	// Output:
+	// 1
+	// 2
+	// 3
+}
+
+func ExampleChannel_FanIn() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := 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
+	}
+
+}
+
+func ExampleChannel_Or() {
+	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 := NewChannel[any]()
+	<-c.Or(
+		sig(1*time.Second),
+		sig(2*time.Second),
+		sig(3*time.Second),
+	)
+
+	if time.Since(start).Seconds() < 2 {
+		fmt.Println("ok")
+	}
+	// Output:
+	// ok
+}
+
+func ExampleChannel_OrDone() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := 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
+}
+
+func ExampleChannel_Tee() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := 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
+}
+
+func ExampleChannel_Bridge() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := 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
+}

concurrency/channel_test.go

@@ -9,34 +9,30 @@ import (
 )
 
 func TestGenerate(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestGenerate")
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	c := NewChannel()
+	c := NewChannel[int]()
 	intStream := c.Generate(ctx, 1, 2, 3)
 
-	// for v := range intStream {
-	// 	t.Log(v) //1, 2, 3
-	// }
 	assert.Equal(1, <-intStream)
 	assert.Equal(2, <-intStream)
 	assert.Equal(3, <-intStream)
 }
 
 func TestRepeat(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestRepeat")
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	c := NewChannel()
+	c := NewChannel[int]()
 	intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 5)
 
-	// for v := range intStream {
-	// 	t.Log(v) //1, 2, 1, 2, 1
-	// }
 	assert.Equal(1, <-intStream)
 	assert.Equal(2, <-intStream)
 	assert.Equal(1, <-intStream)
@@ -45,34 +41,32 @@ func TestRepeat(t *testing.T) {
 }
 
 func TestRepeatFn(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestRepeatFn")
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	fn := func() any {
+	fn := func() string {
 		s := "a"
 		return s
 	}
-	c := NewChannel()
+	c := NewChannel[string]()
 	dataStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
 
-	// for v := range dataStream {
-	// 	t.Log(v) //a, a, a
-	// }
-
 	assert.Equal("a", <-dataStream)
 	assert.Equal("a", <-dataStream)
 	assert.Equal("a", <-dataStream)
 }
 
 func TestTake(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestTake")
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	numbers := make(chan any, 5)
+	numbers := make(chan int, 5)
 	numbers <- 1
 	numbers <- 2
 	numbers <- 3
@@ -80,7 +74,7 @@ func TestTake(t *testing.T) {
 	numbers <- 5
 	defer close(numbers)
 
-	c := NewChannel()
+	c := NewChannel[int]()
 	intStream := c.Take(ctx, numbers, 3)
 
 	assert.Equal(1, <-intStream)
@@ -89,13 +83,14 @@ func TestTake(t *testing.T) {
 }
 
 func TestFanIn(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestFanIn")
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	c := NewChannel()
-	channels := make([]<-chan any, 3)
+	c := NewChannel[int]()
+	channels := make([]<-chan int, 3)
 
 	for i := 0; i < 3; i++ {
 		channels[i] = c.Take(ctx, c.Repeat(ctx, i), 3)
@@ -111,6 +106,7 @@ func TestFanIn(t *testing.T) {
 }
 
 func TestOr(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestOr")
 
 	sig := func(after time.Duration) <-chan any {
@@ -124,7 +120,7 @@ func TestOr(t *testing.T) {
 
 	start := time.Now()
 
-	c := NewChannel()
+	c := NewChannel[any]()
 	<-c.Or(
 		sig(1*time.Second),
 		sig(2*time.Second),
@@ -133,62 +129,57 @@ func TestOr(t *testing.T) {
 		sig(5*time.Second),
 	)
 
-	t.Logf("done after %v", time.Since(start))
-
-	assert.Equal(1, 1)
+	assert.Equal(true, time.Since(start).Seconds() < 2)
 }
 
 func TestOrDone(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestOrDone")
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	c := NewChannel()
+	c := NewChannel[int]()
 	intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
 
-	var res any
 	for val := range c.OrDone(ctx, intStream) {
-		t.Logf("%v", val)
-		res = val
+		assert.Equal(1, val)
 	}
-
-	assert.Equal(1, res)
 }
 
 func TestTee(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestTee")
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	c := NewChannel()
+	c := NewChannel[int]()
 	inStream := c.Take(ctx, c.Repeat(ctx, 1), 4)
 
 	out1, out2 := c.Tee(ctx, inStream)
 	for val := range out1 {
 		val1 := val
 		val2 := <-out2
-		// t.Log("val1 is", val1)
-		// t.Log("val2 is", val2)
 		assert.Equal(1, val1)
 		assert.Equal(1, val2)
 	}
 }
 
 func TestBridge(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestBridge")
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	c := NewChannel()
-	genVals := func() <-chan <-chan any {
-		chanStream := make(chan (<-chan any))
+	c := NewChannel[int]()
+	genVals := func() <-chan <-chan int {
+		chanStream := make(chan (<-chan int))
 		go func() {
 			defer close(chanStream)
 			for i := 0; i < 10; i++ {
-				stream := make(chan any, 1)
+				stream := make(chan int, 1)
 				stream <- i
 				close(stream)
 				chanStream <- stream
@@ -199,7 +190,6 @@ func TestBridge(t *testing.T) {
 
 	index := 0
 	for val := range c.Bridge(ctx, genVals()) {
-		// t.Logf("%v ", val) //0 1 2 3 4 5 6 7 8 9
 		assert.Equal(index, val)
 		index++
 	}

condition/condition.go

@@ -13,6 +13,7 @@ import "reflect"
 // If the type has an IsZero() bool method, the opposite value is returned.
 // Slices and maps are truthy if they have a length greater than zero.
 // All other types are truthy if they are not their zero value.
+// Play: https://go.dev/play/p/ETzeDJRSvhm
 func Bool[T any](value T) bool {
 	switch m := any(value).(type) {
 	case interface{ Bool() bool }:
@@ -34,40 +35,47 @@ func reflectValue(vp any) bool {
 }
 
 // And returns true if both a and b are truthy.
+// Play: https://go.dev/play/p/W1SSUmt6pvr
 func And[T, U any](a T, b U) bool {
 	return Bool(a) && Bool(b)
 }
 
-// Or returns false iff neither a nor b is truthy.
+// Or returns false if neither a nor b is truthy.
+// Play: https://go.dev/play/p/UlQTxHaeEkq
 func Or[T, U any](a T, b U) bool {
 	return Bool(a) || Bool(b)
 }
 
-// Xor returns true iff a or b but not both is truthy.
+// 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
 }
 
-// Nor returns true iff neither a nor b is truthy.
+// Nor returns true if neither a nor b is truthy.
+// Play: https://go.dev/play/p/g2j08F_zZky
 func Nor[T, U any](a T, b U) bool {
 	return !(Bool(a) || Bool(b))
 }
 
-// Xnor returns true iff both a and b or neither a nor b are truthy.
+// 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)
 }
 
-// Nand returns false iff both a and b are truthy.
+// Nand returns false if both a and b are truthy.
+// Play: https://go.dev/play/p/vSRMLxLIbq8
 func Nand[T, U any](a T, b U) bool {
 	return !Bool(a) || !Bool(b)
 }
 
-// TernaryOperator checks the value of param `isTrue`, if true 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
 func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U {
 	if Bool(isTrue) {
 		return ifValue

condition/condition_example_test.go

@@ -0,0 +1,163 @@
+package condition
+
+import "fmt"
+
+func ExampleBool() {
+	// bool
+	result1 := Bool(false)
+	result2 := Bool(true)
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// integer
+	result3 := Bool(0)
+	result4 := Bool(1)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// string
+	result5 := Bool("")
+	result6 := Bool(" ")
+	fmt.Println(result5)
+	fmt.Println(result6)
+
+	// slice
+	var nums = []int{}
+	result7 := Bool(nums)
+	nums = append(nums, 1, 2)
+	result8 := Bool(nums)
+	fmt.Println(result7)
+	fmt.Println(result8)
+
+	// Output:
+	// false
+	// true
+	// false
+	// true
+	// false
+	// true
+	// false
+	// true
+}
+
+func ExampleAnd() {
+	result1 := And(0, 1)
+	result2 := And(0, "")
+	result3 := And(0, "0")
+	result4 := And(1, "0")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// false
+	// false
+	// false
+	// true
+}
+
+func ExampleOr() {
+	result1 := Or(0, "")
+	result2 := Or(0, 1)
+	result3 := Or(0, "0")
+	result4 := Or(1, "0")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// false
+	// true
+	// true
+	// true
+}
+
+func ExampleXor() {
+	result1 := Xor(0, 0)
+	result2 := Xor(1, 1)
+	result3 := Xor(0, 1)
+	result4 := Xor(1, 0)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// false
+	// false
+	// true
+	// true
+}
+
+func ExampleNor() {
+	result1 := Nor(0, 0)
+	result2 := Nor(1, 1)
+	result3 := Nor(0, 1)
+	result4 := Nor(1, 0)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// true
+	// false
+	// false
+	// false
+}
+
+func ExampleXnor() {
+	result1 := Xnor(0, 0)
+	result2 := Xnor(1, 1)
+	result3 := Xnor(0, 1)
+	result4 := Xnor(1, 0)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// true
+	// true
+	// false
+	// false
+}
+
+func ExampleNand() {
+	result1 := Nand(0, 0)
+	result2 := Nand(1, 0)
+	result3 := Nand(0, 1)
+	result4 := Nand(1, 1)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// true
+	// true
+	// true
+	// false
+}
+
+func ExampleTernaryOperator() {
+	conditionTrue := 2 > 1
+	result1 := TernaryOperator(conditionTrue, 0, 1)
+	fmt.Println(result1)
+
+	conditionFalse := 2 > 3
+	result2 := TernaryOperator(conditionFalse, 0, 1)
+	fmt.Println(result2)
+
+	// Output:
+	// 0
+	// 1
+}

condition/condition_test.go

@@ -11,6 +11,8 @@ import (
 type TestStruct struct{}
 
 func TestBool(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBool")
 
 	// bool
@@ -63,6 +65,8 @@ func TestBool(t *testing.T) {
 }
 
 func TestAnd(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestAnd")
 	assert.Equal(false, And(0, 1))
 	assert.Equal(false, And(0, ""))
@@ -71,6 +75,8 @@ func TestAnd(t *testing.T) {
 }
 
 func TestOr(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestOr")
 	assert.Equal(false, Or(0, ""))
 	assert.Equal(true, Or(0, 1))
@@ -79,6 +85,8 @@ func TestOr(t *testing.T) {
 }
 
 func TestXor(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestOr")
 	assert.Equal(false, Xor(0, 0))
 	assert.Equal(true, Xor(0, 1))
@@ -87,6 +95,8 @@ func TestXor(t *testing.T) {
 }
 
 func TestNor(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestNor")
 	assert.Equal(true, Nor(0, 0))
 	assert.Equal(false, Nor(0, 1))
@@ -95,6 +105,8 @@ func TestNor(t *testing.T) {
 }
 
 func TestXnor(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestXnor")
 	assert.Equal(true, Xnor(0, 0))
 	assert.Equal(false, Xnor(0, 1))
@@ -103,6 +115,8 @@ func TestXnor(t *testing.T) {
 }
 
 func TestNand(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestNand")
 	assert.Equal(true, Nand(0, 0))
 	assert.Equal(true, Nand(0, 1))
@@ -111,7 +125,10 @@ func TestNand(t *testing.T) {
 }
 
 func TestTernaryOperator(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TernaryOperator")
+
 	trueValue := "1"
 	falseValue := "0"
 

convertor/convertor.go

@@ -9,20 +9,27 @@ import (
 	"encoding/binary"
 	"encoding/gob"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"io"
 	"math"
 	"reflect"
-	"regexp"
 	"strconv"
 	"strings"
+
+	"github.com/duke-git/lancet/v2/structs"
+	"golang.org/x/text/encoding/simplifiedchinese"
+	"golang.org/x/text/transform"
 )
 
-// ToBool convert string to a boolean
+// ToBool convert string to boolean.
+// Play: https://go.dev/play/p/ARht2WnGdIN
 func ToBool(s string) (bool, error) {
 	return strconv.ParseBool(s)
 }
 
-// ToBytes convert interface to bytes
+// ToBytes convert value to byte slice.
+// Play: https://go.dev/play/p/fAMXYFDvOvr
 func ToBytes(value any) ([]byte, error) {
 	v := reflect.ValueOf(value)
 
@@ -63,7 +70,8 @@ func ToBytes(value any) ([]byte, error) {
 	}
 }
 
-// ToChar convert string to char slice
+// ToChar convert string to char slice.
+// Play: https://go.dev/play/p/JJ1SvbFkVdM
 func ToChar(s string) []string {
 	c := make([]string, 0)
 	if len(s) == 0 {
@@ -75,7 +83,8 @@ func ToChar(s string) []string {
 	return c
 }
 
-// ToChannel convert a array of elements to a read-only channels
+// ToChannel convert a slice of elements to a read-only channel.
+// Play: https://go.dev/play/p/hOx_oYZbAnL
 func ToChannel[T any](array []T) <-chan T {
 	ch := make(chan T)
 
@@ -90,38 +99,59 @@ func ToChannel[T any](array []T) <-chan T {
 }
 
 // ToString convert value to string
+// for number, string, []byte, will convert to string
+// for other type (slice, map, array, struct) will call json.Marshal.
+// Play: https://go.dev/play/p/nF1zOOslpQq
 func ToString(value any) string {
-	result := ""
 	if value == nil {
-		return result
+		return ""
 	}
 
-	v := reflect.ValueOf(value)
-
-	switch value.(type) {
-	case float32, float64:
-		result = strconv.FormatFloat(v.Float(), 'f', -1, 64)
-		return result
-	case int, int8, int16, int32, int64:
-		result = strconv.FormatInt(v.Int(), 10)
-		return result
-	case uint, uint8, uint16, uint32, uint64:
-		result = strconv.FormatUint(v.Uint(), 10)
-		return result
+	switch val := value.(type) {
+	case float32:
+		return strconv.FormatFloat(float64(val), 'f', -1, 32)
+	case float64:
+		return strconv.FormatFloat(val, 'f', -1, 64)
+	case int:
+		return strconv.FormatInt(int64(val), 10)
+	case int8:
+		return strconv.FormatInt(int64(val), 10)
+	case int16:
+		return strconv.FormatInt(int64(val), 10)
+	case int32:
+		return strconv.FormatInt(int64(val), 10)
+	case int64:
+		return strconv.FormatInt(val, 10)
+	case uint:
+		return strconv.FormatUint(uint64(val), 10)
+	case uint8:
+		return strconv.FormatUint(uint64(val), 10)
+	case uint16:
+		return strconv.FormatUint(uint64(val), 10)
+	case uint32:
+		return strconv.FormatUint(uint64(val), 10)
+	case uint64:
+		return strconv.FormatUint(val, 10)
 	case string:
-		result = v.String()
-		return result
+		return val
 	case []byte:
-		result = string(v.Bytes())
-		return result
+		return string(val)
 	default:
-		newValue, _ := json.Marshal(value)
-		result = string(newValue)
-		return result
+		b, err := json.Marshal(val)
+		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 ""
 	}
 }
 
-// ToJson convert value to a valid json string
+// ToJson convert value to a json string.
+// Play: https://go.dev/play/p/2rLIkMmXWvR
 func ToJson(value any) (string, error) {
 	result, err := json.Marshal(value)
 	if err != nil {
@@ -131,7 +161,8 @@ func ToJson(value any) (string, error) {
 	return string(result), nil
 }
 
-// ToFloat convert value to a float64, if input is not a float return 0.0 and error
+// ToFloat convert value to float64, if input is not a float return 0.0 and error.
+// Play: https://go.dev/play/p/4YTmPCibqHJ
 func ToFloat(value any) (float64, error) {
 	v := reflect.ValueOf(value)
 
@@ -158,12 +189,13 @@ func ToFloat(value any) (float64, error) {
 	}
 }
 
-// ToInt convert value to a int64, if input is not a numeric format return 0 and error
+// ToInt convert value to int64 value, if input is not numerical, return 0 and error.
+// Play: https://go.dev/play/p/9_h9vIt-QZ_b
 func ToInt(value any) (int64, error) {
 	v := reflect.ValueOf(value)
 
 	var result int64
-	err := fmt.Errorf("ToInt: invalid interface type %T", value)
+	err := fmt.Errorf("ToInt: invalid value type %T", value)
 	switch value.(type) {
 	case int, int8, int16, int32, int64:
 		result = v.Int()
@@ -185,12 +217,14 @@ func ToInt(value any) (int64, error) {
 	}
 }
 
-// ToPointer returns a pointer to this value
+// ToPointer returns a pointer to passed value.
+// Play: https://go.dev/play/p/ASf_etHNlw1
 func ToPointer[T any](value T) *T {
 	return &value
 }
 
-// ToMap convert a slice or an array of structs to a map based on iteratee function
+// 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 {
 	result := make(map[K]V, len(array))
 	for _, item := range array {
@@ -202,36 +236,14 @@ func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K
 }
 
 // StructToMap convert struct to map, only convert exported struct field
-// map key is specified same as struct field tag `json` value
+// map key is specified same as struct field tag `json` value.
+// Play: https://go.dev/play/p/KYGYJqNUBOI
 func StructToMap(value any) (map[string]any, error) {
-	v := reflect.ValueOf(value)
-	t := reflect.TypeOf(value)
-
-	if t.Kind() == reflect.Ptr {
-		t = t.Elem()
-	}
-	if t.Kind() != reflect.Struct {
-		return nil, fmt.Errorf("data type %T not support, shuld be struct or pointer to struct", value)
-	}
-
-	result := make(map[string]any)
-
-	fieldNum := t.NumField()
-	pattern := `^[A-Z]`
-	regex := regexp.MustCompile(pattern)
-	for i := 0; i < fieldNum; i++ {
-		name := t.Field(i).Name
-		tag := t.Field(i).Tag.Get("json")
-		if regex.MatchString(name) && tag != "" {
-			//result[name] = v.Field(i).Interface()
-			result[tag] = v.Field(i).Interface()
-		}
-	}
-
-	return result, nil
+	return structs.ToMap(value)
 }
 
-// MapToSlice convert a map to a slice based on iteratee function
+// MapToSlice convert map to slice based on iteratee function.
+// Play: https://go.dev/play/p/dmX4Ix5V6Wl
 func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T {
 	result := make([]T, 0, len(aMap))
 
@@ -242,7 +254,8 @@ func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T)
 	return result
 }
 
-// ColorHexToRGB convert hex color to rgb color
+// ColorHexToRGB convert hex color to rgb color.
+// Play: https://go.dev/play/p/o7_ft-JCJBV
 func ColorHexToRGB(colorHex string) (red, green, blue int) {
 	colorHex = strings.TrimPrefix(colorHex, "#")
 	color64, err := strconv.ParseInt(colorHex, 16, 32)
@@ -253,7 +266,8 @@ func ColorHexToRGB(colorHex string) (red, green, blue int) {
 	return color >> 16, (color & 0x00FF00) >> 8, color & 0x0000FF
 }
 
-// ColorRGBToHex convert rgb color to hex color
+// ColorRGBToHex convert rgb color to hex color.
+// Play: https://go.dev/play/p/nzKS2Ro87J1
 func ColorRGBToHex(red, green, blue int) string {
 	r := strconv.FormatInt(int64(red), 16)
 	g := strconv.FormatInt(int64(green), 16)
@@ -272,7 +286,8 @@ func ColorRGBToHex(red, green, blue int) string {
 	return "#" + r + g + b
 }
 
-// EncodeByte encode data to byte
+// EncodeByte encode data to byte slice.
+// Play: https://go.dev/play/p/DVmM1G5JfuP
 func EncodeByte(data any) ([]byte, error) {
 	buffer := bytes.NewBuffer(nil)
 	encoder := gob.NewEncoder(buffer)
@@ -283,9 +298,99 @@ func EncodeByte(data any) ([]byte, error) {
 	return buffer.Bytes(), nil
 }
 
-// DecodeByte decode byte data to target object
+// DecodeByte decode byte slice data to target object.
+// Play: https://go.dev/play/p/zI6xsmuQRbn
 func DecodeByte(data []byte, target any) error {
 	buffer := bytes.NewBuffer(data)
 	decoder := gob.NewDecoder(buffer)
 	return decoder.Decode(target)
 }
+
+// DeepClone creates a deep copy of passed item.
+// can't clone unexported field of struct
+// Play: https://go.dev/play/p/j4DP5dquxnk
+func DeepClone[T any](src T) T {
+	c := cloner{
+		ptrs: map[reflect.Type]map[uintptr]reflect.Value{},
+	}
+	result := c.clone(reflect.ValueOf(src))
+	if result.Kind() == reflect.Invalid {
+		var zeroValue T
+		return zeroValue
+	}
+
+	return result.Interface().(T)
+}
+
+// CopyProperties copies each field from the source into the destination. It recursively copies struct pointers and interfaces that contain struct pointers.
+// use json.Marshal/Unmarshal, so json tag should be set for fields of dst and src struct.
+// Play: https://go.dev/play/p/oZujoB5Sgg5
+func CopyProperties[T, U any](dst T, src U) error {
+	dstType, srcType := reflect.TypeOf(dst), reflect.TypeOf(src)
+
+	if dstType.Kind() != reflect.Ptr || dstType.Elem().Kind() != reflect.Struct {
+		return errors.New("CopyProperties: parameter dst should be struct pointer")
+	}
+
+	if srcType.Kind() == reflect.Ptr {
+		srcType = srcType.Elem()
+	}
+	if srcType.Kind() != reflect.Struct {
+		return errors.New("CopyProperties: parameter src should be a struct or struct pointer")
+	}
+
+	bytes, err := json.Marshal(src)
+	if err != nil {
+		return fmt.Errorf("CopyProperties: unable to marshal src: %s", err)
+	}
+	err = json.Unmarshal(bytes, dst)
+	if err != nil {
+		return fmt.Errorf("CopyProperties: unable to unmarshal into dst: %s", err)
+	}
+
+	return nil
+}
+
+// ToInterface converts reflect value to its interface type.
+// Play: https://go.dev/play/p/syqw0-WG7Xd
+func ToInterface(v reflect.Value) (value interface{}, ok bool) {
+	if v.IsValid() && v.CanInterface() {
+		return v.Interface(), true
+	}
+	switch v.Kind() {
+	case reflect.Bool:
+		return v.Bool(), true
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int(), true
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint(), true
+	case reflect.Float32, reflect.Float64:
+		return v.Float(), true
+	case reflect.Complex64, reflect.Complex128:
+		return v.Complex(), true
+	case reflect.String:
+		return v.String(), true
+	case reflect.Ptr:
+		return ToInterface(v.Elem())
+	case reflect.Interface:
+		return ToInterface(v.Elem())
+	default:
+		return nil, false
+	}
+}
+
+// Utf8ToGbk convert utf8 encoding data to GBK encoding data.
+// Play: https://go.dev/play/p/9FlIaFLArIL
+func Utf8ToGbk(bs []byte) ([]byte, error) {
+	r := transform.NewReader(bytes.NewReader(bs), simplifiedchinese.GBK.NewEncoder())
+	b, err := io.ReadAll(r)
+	return b, err
+}
+
+// GbkToUtf8 convert GBK encoding data to utf8 encoding data.
+// Play: https://go.dev/play/p/OphmHCN_9u8
+func GbkToUtf8(bs []byte) ([]byte, error) {
+	r := transform.NewReader(bytes.NewReader(bs), simplifiedchinese.GBK.NewDecoder())
+	b, err := io.ReadAll(r)
+	return b, err
+}

convertor/convertor_example_test.go

@@ -0,0 +1,393 @@
+package convertor
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"unicode/utf8"
+
+	"github.com/duke-git/lancet/v2/validator"
+)
+
+func ExampleToBool() {
+	cases := []string{"1", "true", "True", "false", "False", "0", "123", "0.0", "abc"}
+
+	for i := 0; i < len(cases); i++ {
+		result, _ := ToBool(cases[i])
+		fmt.Println(result)
+	}
+
+	// Output:
+	// true
+	// true
+	// true
+	// false
+	// false
+	// false
+	// false
+	// false
+	// false
+}
+
+func ExampleToBytes() {
+	result1, _ := ToBytes(1)
+	result2, _ := ToBytes("abc")
+	result3, _ := ToBytes(true)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// [0 0 0 0 0 0 0 1]
+	// [97 98 99]
+	// [116 114 117 101]
+}
+
+func ExampleToChar() {
+	result1 := ToChar("")
+	result2 := ToChar("abc")
+	result3 := ToChar("1 2#3")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// []
+	// [a b c]
+	// [1   2 # 3]
+}
+
+func ExampleToChannel() {
+	ch := ToChannel([]int{1, 2, 3})
+	result1 := <-ch
+	result2 := <-ch
+	result3 := <-ch
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// 1
+	// 2
+	// 3
+}
+
+func ExampleToString() {
+	result1 := ToString("")
+	result2 := ToString(nil)
+	result3 := ToString(0)
+	result4 := ToString(1.23)
+	result5 := ToString(true)
+	result6 := ToString(false)
+	result7 := ToString([]int{1, 2, 3})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+	fmt.Println(result7)
+
+	// Output:
+	//
+	//
+	// 0
+	// 1.23
+	// true
+	// false
+	// [1,2,3]
+}
+
+func ExampleToJson() {
+
+	aMap := map[string]int{"a": 1, "b": 2, "c": 3}
+	result1, err := ToJson(aMap)
+	if err != nil {
+		fmt.Printf("%v", err)
+	}
+	fmt.Println(result1)
+
+	// Output:
+	// {"a":1,"b":2,"c":3}
+}
+
+func ExampleToFloat() {
+	result1, _ := ToFloat("")
+	result2, _ := ToFloat("abc")
+	result3, _ := ToFloat("-1")
+	result4, _ := ToFloat("-.11")
+	result5, _ := ToFloat("1.23e3")
+	result6, _ := ToFloat(true)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+
+	// Output:
+	// 0
+	// 0
+	// -1
+	// -0.11
+	// 1230
+	// 0
+}
+
+func ExampleToInt() {
+	result1, _ := ToInt("123")
+	result2, _ := ToInt("-123")
+	result3, _ := ToInt(float64(12.3))
+	result4, _ := ToInt("abc")
+	result5, _ := ToInt(true)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+
+	// Output:
+	// 123
+	// -123
+	// 12
+	// 0
+	// 0
+}
+
+func ExampleToPointer() {
+	result := ToPointer(123)
+	fmt.Println(*result)
+
+	// Output:
+	// 123
+}
+
+func ExampleToMap() {
+	type Message struct {
+		name string
+		code int
+	}
+	messages := []Message{
+		{name: "Hello", code: 100},
+		{name: "Hi", code: 101},
+	}
+	result := ToMap(messages, func(msg Message) (int, string) {
+		return msg.code, msg.name
+	})
+
+	fmt.Println(result)
+
+	// Output:
+	// map[100:Hello 101:Hi]
+}
+
+func ExampleStructToMap() {
+	type People struct {
+		Name string `json:"name"`
+		age  int
+	}
+	p := People{
+		"test",
+		100,
+	}
+	pm, _ := StructToMap(p)
+
+	fmt.Println(pm)
+
+	// Output:
+	// map[name:test]
+}
+
+func ExampleMapToSlice() {
+	aMap := map[string]int{"a": 1, "b": 2, "c": 3}
+	result := MapToSlice(aMap, func(key string, value int) string {
+		return key + ":" + strconv.Itoa(value)
+	})
+
+	fmt.Println(result) //[]string{"a:1", "c:3", "b:2"} (random order)
+}
+
+func ExampleColorHexToRGB() {
+	colorHex := "#003366"
+	r, g, b := ColorHexToRGB(colorHex)
+
+	fmt.Println(r, g, b)
+
+	// Output:
+	// 0 51 102
+}
+
+func ExampleColorRGBToHex() {
+	r := 0
+	g := 51
+	b := 102
+	colorHex := ColorRGBToHex(r, g, b)
+
+	fmt.Println(colorHex)
+
+	// Output:
+	// #003366
+}
+
+func ExampleEncodeByte() {
+	byteData, _ := EncodeByte("abc")
+	fmt.Println(byteData)
+
+	// Output:
+	// [6 12 0 3 97 98 99]
+}
+
+func ExampleDecodeByte() {
+	var obj string
+	byteData := []byte{6, 12, 0, 3, 97, 98, 99}
+	err := DecodeByte(byteData, &obj)
+	if err != nil {
+		return
+	}
+
+	fmt.Println(obj)
+
+	// Output:
+	// abc
+}
+
+func ExampleDeepClone() {
+	type Struct struct {
+		Str   string
+		Int   int
+		Float float64
+		Bool  bool
+		Nil   interface{}
+		// unexported string
+	}
+
+	cases := []interface{}{
+		true,
+		1,
+		0.1,
+		map[string]int{
+			"a": 1,
+			"b": 2,
+		},
+		&Struct{
+			Str:   "test",
+			Int:   1,
+			Float: 0.1,
+			Bool:  true,
+			Nil:   nil,
+			// unexported: "can't be cloned",
+		},
+	}
+
+	for _, item := range cases {
+		cloned := DeepClone(item)
+
+		isPointerEqual := &cloned == &item
+		fmt.Println(cloned, isPointerEqual)
+	}
+
+	// Output:
+	// true false
+	// 1 false
+	// 0.1 false
+	// map[a:1 b:2] false
+	// &{test 1 0.1 true <nil>} false
+}
+
+func ExampleCopyProperties() {
+	type Disk struct {
+		Name    string  `json:"name"`
+		Total   string  `json:"total"`
+		Used    string  `json:"used"`
+		Percent float64 `json:"percent"`
+	}
+
+	type DiskVO struct {
+		Name    string  `json:"name"`
+		Total   string  `json:"total"`
+		Used    string  `json:"used"`
+		Percent float64 `json:"percent"`
+	}
+
+	type Indicator struct {
+		Id      string    `json:"id"`
+		Ip      string    `json:"ip"`
+		UpTime  string    `json:"upTime"`
+		LoadAvg string    `json:"loadAvg"`
+		Cpu     int       `json:"cpu"`
+		Disk    []Disk    `json:"disk"`
+		Stop    chan bool `json:"-"`
+	}
+
+	type IndicatorVO struct {
+		Id      string   `json:"id"`
+		Ip      string   `json:"ip"`
+		UpTime  string   `json:"upTime"`
+		LoadAvg string   `json:"loadAvg"`
+		Cpu     int64    `json:"cpu"`
+		Disk    []DiskVO `json:"disk"`
+	}
+
+	indicator := &Indicator{Id: "001", Ip: "127.0.0.1", Cpu: 1, Disk: []Disk{
+		{Name: "disk-001", Total: "100", Used: "1", Percent: 10},
+		{Name: "disk-002", Total: "200", Used: "1", Percent: 20},
+		{Name: "disk-003", Total: "300", Used: "1", Percent: 30},
+	}}
+
+	indicatorVO := IndicatorVO{}
+
+	CopyProperties(&indicatorVO, indicator)
+
+	fmt.Println(indicatorVO.Id)
+	fmt.Println(indicatorVO.Ip)
+	fmt.Println(len(indicatorVO.Disk))
+
+	// Output:
+	// 001
+	// 127.0.0.1
+	// 3
+}
+
+func ExampleToInterface() {
+	val := reflect.ValueOf("abc")
+	iVal, ok := ToInterface(val)
+
+	fmt.Printf("%T\n", iVal)
+	fmt.Printf("%v\n", iVal)
+	fmt.Println(ok)
+
+	// Output:
+	// string
+	// abc
+	// true
+}
+
+func ExampleUtf8ToGbk() {
+	utf8Data := []byte("hello")
+	gbkData, _ := Utf8ToGbk(utf8Data)
+
+	fmt.Println(utf8.Valid(utf8Data))
+	fmt.Println(validator.IsGBK(gbkData))
+
+	// Output:
+	// true
+	// true
+}
+
+func ExampleGbkToUtf8() {
+	gbkData, _ := Utf8ToGbk([]byte("hello"))
+	utf8Data, _ := GbkToUtf8(gbkData)
+
+	fmt.Println(utf8.Valid(utf8Data))
+	fmt.Println(string(utf8Data))
+
+	// Output:
+	// true
+	// hello
+}

convertor/convertor_internal.go

@@ -0,0 +1,216 @@
+// Copyright 2023 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package convertor implements some functions to convert data.
+package convertor
+
+import "reflect"
+
+type cloner struct {
+	ptrs map[reflect.Type]map[uintptr]reflect.Value
+}
+
+// clone return a duplicate of passed item.
+func (c *cloner) clone(v reflect.Value) reflect.Value {
+	switch v.Kind() {
+	case reflect.Invalid:
+		return reflect.ValueOf(nil)
+
+	// bool
+	case reflect.Bool:
+		return reflect.ValueOf(v.Bool())
+
+	//int
+	case reflect.Int:
+		return reflect.ValueOf(int(v.Int()))
+	case reflect.Int8:
+		return reflect.ValueOf(int8(v.Int()))
+	case reflect.Int16:
+		return reflect.ValueOf(int16(v.Int()))
+	case reflect.Int32:
+		return reflect.ValueOf(int32(v.Int()))
+	case reflect.Int64:
+		return reflect.ValueOf(v.Int())
+
+	// uint
+	case reflect.Uint:
+		return reflect.ValueOf(uint(v.Uint()))
+	case reflect.Uint8:
+		return reflect.ValueOf(uint8(v.Uint()))
+	case reflect.Uint16:
+		return reflect.ValueOf(uint16(v.Uint()))
+	case reflect.Uint32:
+		return reflect.ValueOf(uint32(v.Uint()))
+	case reflect.Uint64:
+		return reflect.ValueOf(v.Uint())
+
+	// float
+	case reflect.Float32:
+		return reflect.ValueOf(float32(v.Float()))
+	case reflect.Float64:
+		return reflect.ValueOf(v.Float())
+
+	// complex
+	case reflect.Complex64:
+		return reflect.ValueOf(complex64(v.Complex()))
+	case reflect.Complex128:
+		return reflect.ValueOf(v.Complex())
+
+	// string
+	case reflect.String:
+		return reflect.ValueOf(v.String())
+
+	// array
+	case reflect.Array, reflect.Slice:
+		return c.cloneArray(v)
+
+	// map
+	case reflect.Map:
+		return c.cloneMap(v)
+
+	// Ptr
+	case reflect.Ptr:
+		return c.clonePtr(v)
+
+	// struct
+	case reflect.Struct:
+		return c.cloneStruct(v)
+
+	// func
+	case reflect.Func:
+		return v
+
+	// interface
+	case reflect.Interface:
+		return c.clone(v.Elem())
+
+	}
+
+	return reflect.Zero(v.Type())
+}
+
+func (c *cloner) cloneArray(v reflect.Value) reflect.Value {
+	if v.IsNil() {
+		return reflect.Zero(v.Type())
+	}
+
+	arr := reflect.MakeSlice(v.Type(), v.Len(), v.Len())
+
+	for i := 0; i < v.Len(); i++ {
+		val := c.clone(v.Index(i))
+
+		if val.IsValid() {
+			continue
+		}
+
+		item := arr.Index(i)
+		if !item.CanSet() {
+			continue
+		}
+
+		item.Set(val.Convert(item.Type()))
+	}
+
+	return arr
+}
+
+func (c *cloner) cloneMap(v reflect.Value) reflect.Value {
+	if v.IsNil() {
+		return reflect.Zero(v.Type())
+	}
+
+	clonedMap := reflect.MakeMap(v.Type())
+
+	for _, key := range v.MapKeys() {
+		value := v.MapIndex(key)
+		clonedKey := c.clone(key)
+		clonedValue := c.clone(value)
+
+		if !isNillable(clonedKey) || !clonedKey.IsNil() {
+			clonedKey = clonedKey.Convert(key.Type())
+		}
+
+		if (!isNillable(clonedValue) || !clonedValue.IsNil()) && clonedValue.IsValid() {
+			clonedValue = clonedValue.Convert(value.Type())
+		}
+
+		if !clonedValue.IsValid() {
+			clonedValue = reflect.Zero(clonedMap.Type().Elem())
+		}
+
+		clonedMap.SetMapIndex(clonedKey, clonedValue)
+	}
+
+	return clonedMap
+}
+
+func isNillable(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Chan, reflect.Interface, reflect.Ptr, reflect.Func:
+		return true
+	}
+	return false
+}
+
+func (c *cloner) clonePtr(v reflect.Value) reflect.Value {
+	if v.IsNil() {
+		return reflect.Zero(v.Type())
+	}
+
+	var newVal reflect.Value
+
+	if v.Elem().CanAddr() {
+		ptrs, exists := c.ptrs[v.Type()]
+		if exists {
+			if newVal, exists := ptrs[v.Elem().UnsafeAddr()]; exists {
+				return newVal
+			}
+		}
+	}
+
+	newVal = c.clone(v.Elem())
+
+	if v.Elem().CanAddr() {
+		ptrs, exists := c.ptrs[v.Type()]
+		if exists {
+			if newVal, exists := ptrs[v.Elem().UnsafeAddr()]; exists {
+				return newVal
+			}
+		}
+	}
+
+	clonedPtr := reflect.New(newVal.Type())
+	clonedPtr.Elem().Set(newVal)
+
+	return clonedPtr
+}
+
+func (c *cloner) cloneStruct(v reflect.Value) reflect.Value {
+	clonedStructPtr := reflect.New(v.Type())
+	clonedStruct := clonedStructPtr.Elem()
+
+	if v.CanAddr() {
+		ptrs := c.ptrs[clonedStructPtr.Type()]
+		if ptrs == nil {
+			ptrs = make(map[uintptr]reflect.Value)
+			c.ptrs[clonedStructPtr.Type()] = ptrs
+		}
+		ptrs[v.UnsafeAddr()] = clonedStructPtr
+	}
+
+	for i := 0; i < v.NumField(); i++ {
+		newStructValue := clonedStruct.Field(i)
+		if !newStructValue.CanSet() {
+			continue
+		}
+
+		clonedVal := c.clone(v.Field(i))
+		if !clonedVal.IsValid() {
+			continue
+		}
+
+		newStructValue.Set(clonedVal.Convert(newStructValue.Type()))
+	}
+
+	return clonedStruct
+}

convertor/convertor_test.go

@@ -2,14 +2,19 @@ package convertor
 
 import (
 	"fmt"
+	"reflect"
 	"strconv"
 	"testing"
+	"unicode/utf8"
 
 	"github.com/duke-git/lancet/v2/internal"
 	"github.com/duke-git/lancet/v2/slice"
+	"github.com/duke-git/lancet/v2/validator"
 )
 
 func TestToChar(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToChar")
 
 	cases := []string{"", "abc", "1 2#3"}
@@ -24,23 +29,22 @@ func TestToChar(t *testing.T) {
 }
 
 func TestToChannel(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToChannel")
 
 	ch := ToChannel([]int{1, 2, 3})
-	val1, _ := <-ch
-	assert.Equal(1, val1)
-
-	val2, _ := <-ch
-	assert.Equal(2, val2)
-
-	val3, _ := <-ch
-	assert.Equal(3, val3)
+	assert.Equal(1, <-ch)
+	assert.Equal(2, <-ch)
+	assert.Equal(3, <-ch)
 
 	_, ok := <-ch
 	assert.Equal(false, ok)
 }
 
 func TestToBool(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToBool")
 
 	cases := []string{"1", "true", "True", "false", "False", "0", "123", "0.0", "abc"}
@@ -53,6 +57,8 @@ func TestToBool(t *testing.T) {
 }
 
 func TestToBytes(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToBytes")
 
 	cases := []any{
@@ -79,6 +85,8 @@ func TestToBytes(t *testing.T) {
 }
 
 func TestToInt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToInt")
 
 	cases := []any{"123", "-123", 123,
@@ -95,6 +103,8 @@ func TestToInt(t *testing.T) {
 }
 
 func TestToFloat(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToFloat")
 
 	cases := []any{
@@ -113,6 +123,8 @@ func TestToFloat(t *testing.T) {
 }
 
 func TestToString(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToString")
 
 	aMap := make(map[string]int)
@@ -137,9 +149,10 @@ func TestToString(t *testing.T) {
 		"", "",
 		"0", "1", "-1",
 		"123", "123", "123", "123", "123", "123", "123",
-		"12.3", "12.300000190734863",
+		"12.3", "12.3",
 		"true", "false",
-		"[1,2,3]", "{\"a\":1,\"b\":2,\"c\":3}", "{\"Name\":\"TestStruct\"}", "hello"}
+		"[1,2,3]", "{\"a\":1,\"b\":2,\"c\":3}", "{\"Name\":\"TestStruct\"}", "hello",
+	}
 
 	for i := 0; i < len(cases); i++ {
 		actual := ToString(cases[i])
@@ -147,6 +160,8 @@ func TestToString(t *testing.T) {
 	}
 }
 func TestToJson(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToJson")
 
 	var aMap = map[string]int{"a": 1, "b": 2, "c": 3}
@@ -162,6 +177,8 @@ func TestToJson(t *testing.T) {
 }
 
 func TestToMap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToMap")
 
 	type Message struct {
@@ -181,23 +198,45 @@ func TestToMap(t *testing.T) {
 }
 
 func TestStructToMap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestStructToMap")
 
-	type People struct {
-		Name string `json:"name"`
-		age  int
-	}
-	p := People{
-		"test",
-		100,
-	}
-	pm, _ := StructToMap(p)
+	t.Run("StructToMap", func(_ *testing.T) {
+		type People struct {
+			Name string `json:"name"`
+			age  int
+		}
+		p := People{
+			"test",
+			100,
+		}
+		pm, _ := StructToMap(p)
+		var expected = map[string]any{"name": "test"}
+		assert.Equal(expected, pm)
+	})
 
-	expected := map[string]any{"name": "test"}
-	assert.Equal(expected, pm)
+	t.Run("StructToMapWithJsonAttr", func(_ *testing.T) {
+		type People struct {
+			Name  string `json:"name,omitempty"` // json tag with attribute
+			Phone string `json:"phone"`          // json tag without attribute
+			Sex   string `json:"-"`              // ignore
+			age   int    // no tag
+		}
+		p := People{
+			Phone: "1111",
+			Sex:   "male",
+			age:   100,
+		}
+		pm, _ := StructToMap(p)
+		var expected = map[string]any{"phone": "1111"}
+		assert.Equal(expected, pm)
+	})
 }
 
 func TestMapToSlice(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMapToSlice")
 
 	aMap := map[string]int{"a": 1, "b": 2, "c": 3}
@@ -212,6 +251,8 @@ func TestMapToSlice(t *testing.T) {
 }
 
 func TestColorHexToRGB(t *testing.T) {
+	t.Parallel()
+
 	colorHex := "#003366"
 	r, g, b := ColorHexToRGB(colorHex)
 	colorRGB := fmt.Sprintf("%d,%d,%d", r, g, b)
@@ -222,6 +263,8 @@ func TestColorHexToRGB(t *testing.T) {
 }
 
 func TestColorRGBToHex(t *testing.T) {
+	t.Parallel()
+
 	r := 0
 	g := 51
 	b := 102
@@ -233,6 +276,8 @@ func TestColorRGBToHex(t *testing.T) {
 }
 
 func TestToPointer(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToPointer")
 	result := ToPointer(123)
 
@@ -240,6 +285,8 @@ func TestToPointer(t *testing.T) {
 }
 
 func TestEncodeByte(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEncodeByte")
 
 	byteData, _ := EncodeByte("abc")
@@ -249,10 +296,167 @@ func TestEncodeByte(t *testing.T) {
 }
 
 func TestDecodeByte(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDecodeByte")
 
 	var obj string
 	byteData := []byte{6, 12, 0, 3, 97, 98, 99}
-	DecodeByte(byteData, &obj)
+	err := DecodeByte(byteData, &obj)
+	assert.IsNil(err)
 	assert.Equal("abc", obj)
 }
+
+func TestDeepClone(t *testing.T) {
+	t.Parallel()
+
+	// assert := internal.NewAssert(t, "TestDeepClone")
+
+	type Struct struct {
+		Str   string
+		Int   int
+		Float float64
+		Bool  bool
+		Nil   interface{}
+		// unexported string
+	}
+
+	cases := []interface{}{
+		true,
+		1,
+		0.1,
+		map[string]int{
+			"a": 1,
+			"b": 2,
+		},
+		&Struct{
+			Str:   "test",
+			Int:   1,
+			Float: 0.1,
+			Bool:  true,
+			Nil:   nil,
+			// unexported: "can't be cloned",
+		},
+	}
+
+	for i, item := range cases {
+		cloned := DeepClone(item)
+
+		if &cloned == &item {
+			t.Fatalf("[TestDeepClone case #%d failed]: equal pointer", i)
+		}
+
+		if !reflect.DeepEqual(item, cloned) {
+			t.Fatalf("[TestDeepClone case #%d failed] unequal objects", i)
+		}
+	}
+}
+
+func TestCopyProperties(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestCopyProperties")
+
+	type Disk struct {
+		Name    string  `json:"name"`
+		Total   string  `json:"total"`
+		Used    string  `json:"used"`
+		Percent float64 `json:"percent"`
+	}
+
+	type DiskVO struct {
+		Name    string  `json:"name"`
+		Total   string  `json:"total"`
+		Used    string  `json:"used"`
+		Percent float64 `json:"percent"`
+	}
+
+	type Indicator struct {
+		Id      string    `json:"id"`
+		Ip      string    `json:"ip"`
+		UpTime  string    `json:"upTime"`
+		LoadAvg string    `json:"loadAvg"`
+		Cpu     int       `json:"cpu"`
+		Disk    []Disk    `json:"disk"`
+		Stop    chan bool `json:"-"`
+	}
+
+	type IndicatorVO struct {
+		Id      string   `json:"id"`
+		Ip      string   `json:"ip"`
+		UpTime  string   `json:"upTime"`
+		LoadAvg string   `json:"loadAvg"`
+		Cpu     int64    `json:"cpu"`
+		Disk    []DiskVO `json:"disk"`
+	}
+
+	indicator := &Indicator{Id: "001", Ip: "127.0.0.1", Cpu: 1, Disk: []Disk{
+		{Name: "disk-001", Total: "100", Used: "1", Percent: 10},
+		{Name: "disk-002", Total: "200", Used: "1", Percent: 20},
+		{Name: "disk-003", Total: "300", Used: "1", Percent: 30},
+	}}
+
+	indicatorVO := IndicatorVO{}
+
+	err := CopyProperties(&indicatorVO, indicator)
+
+	assert.IsNil(err)
+	assert.Equal("001", indicatorVO.Id)
+	assert.Equal("127.0.0.1", indicatorVO.Ip)
+	assert.Equal(3, len(indicatorVO.Disk))
+}
+
+func TestToInterface(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestToInterface")
+
+	cases := []reflect.Value{
+		reflect.ValueOf("abc"),
+		reflect.ValueOf(int(0)), reflect.ValueOf(int8(1)), reflect.ValueOf(int16(-1)), reflect.ValueOf(int32(123)), reflect.ValueOf(int64(123)),
+		reflect.ValueOf(uint(123)), reflect.ValueOf(uint8(123)), reflect.ValueOf(uint16(123)), reflect.ValueOf(uint32(123)), reflect.ValueOf(uint64(123)),
+		reflect.ValueOf(float64(12.3)), reflect.ValueOf(float32(12.3)),
+		reflect.ValueOf(true), reflect.ValueOf(false),
+	}
+
+	expected := []interface{}{
+		"abc",
+		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,
+	}
+
+	for i := 0; i < len(cases); i++ {
+		actual, _ := ToInterface(cases[i])
+		assert.Equal(expected[i], actual)
+	}
+
+	nilVal, ok := ToInterface(reflect.ValueOf(nil))
+	assert.EqualValues(nil, nilVal)
+	assert.Equal(false, ok)
+}
+
+func TestUtf8ToGbk(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestUtf8ToGbk")
+
+	utf8Data := []byte("hello")
+	gbkData, err := Utf8ToGbk(utf8Data)
+
+	assert.Equal(true, utf8.Valid(utf8Data))
+	assert.Equal(true, validator.IsGBK(gbkData))
+	assert.IsNil(err)
+}
+
+func TestGbkToUtf8(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestGbkToUtf8")
+
+	gbkData, err := Utf8ToGbk([]byte("hello"))
+	utf8Data, err := GbkToUtf8(gbkData)
+
+	assert.IsNil(err)
+	assert.Equal(true, utf8.Valid(utf8Data))
+	assert.Equal("hello", string(utf8Data))
+}

cryptor/aes.go

@@ -1,174 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package cryptor implements some util functions to encrypt and decrypt.
-// Note:
-// 1. for aes crypt function, the `key` param length should be 16, 24 or 32. if not, will panic.
-package cryptor
-
-import (
-	"bytes"
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/rand"
-	"io"
-)
-
-// AesEcbEncrypt encrypt data with key use AES ECB algorithm
-// len(key) should be 16, 24 or 32
-func AesEcbEncrypt(data, key []byte) []byte {
-	cipher, _ := aes.NewCipher(generateAesKey(key))
-	length := (len(data) + aes.BlockSize) / aes.BlockSize
-	plain := make([]byte, length*aes.BlockSize)
-	copy(plain, data)
-	pad := byte(len(plain) - len(data))
-	for i := len(data); i < len(plain); i++ {
-		plain[i] = pad
-	}
-	encrypted := make([]byte, len(plain))
-	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])
-	}
-
-	return encrypted
-}
-
-// AesEcbDecrypt decrypt data with key use AES ECB algorithm
-// len(key) should be 16, 24 or 32
-func AesEcbDecrypt(encrypted, key []byte) []byte {
-	cipher, _ := aes.NewCipher(generateAesKey(key))
-	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])
-	}
-
-	trim := 0
-	if len(decrypted) > 0 {
-		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
-	}
-
-	return decrypted[:trim]
-}
-
-// AesCbcEncrypt encrypt data with key use AES CBC algorithm
-// len(key) should be 16, 24 or 32
-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)
-	}
-
-	mode := cipher.NewCBCEncrypter(block, iv)
-	mode.CryptBlocks(encrypted[aes.BlockSize:], data)
-
-	return encrypted
-}
-
-// AesCbcDecrypt decrypt data with key use AES CBC algorithm
-// len(key) should be 16, 24 or 32
-func AesCbcDecrypt(encrypted, key []byte) []byte {
-	block, _ := aes.NewCipher(key)
-
-	iv := encrypted[:aes.BlockSize]
-	encrypted = encrypted[aes.BlockSize:]
-
-	mode := cipher.NewCBCDecrypter(block, iv)
-	mode.CryptBlocks(encrypted, encrypted)
-
-	decrypted := pkcs7UnPadding(encrypted)
-	return decrypted
-}
-
-// AesCtrCrypt encrypt data with key use AES CTR algorithm
-// len(key) should be 16, 24 or 32
-func AesCtrCrypt(data, key []byte) []byte {
-	block, _ := aes.NewCipher(key)
-
-	iv := bytes.Repeat([]byte("1"), block.BlockSize())
-	stream := cipher.NewCTR(block, iv)
-
-	dst := make([]byte, len(data))
-	stream.XORKeyStream(dst, data)
-
-	return dst
-}
-
-// AesCfbEncrypt encrypt data with key use AES CFB algorithm
-// len(key) should be 16, 24 or 32
-func AesCfbEncrypt(data, key []byte) []byte {
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-
-	encrypted := make([]byte, aes.BlockSize+len(data))
-	iv := encrypted[:aes.BlockSize]
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
-	}
-
-	stream := cipher.NewCFBEncrypter(block, iv)
-	stream.XORKeyStream(encrypted[aes.BlockSize:], data)
-	return encrypted
-}
-
-// AesCfbDecrypt decrypt data with key use AES CFB algorithm
-// len(encrypted) should be great than 16, len(key) should be 16, 24 or 32
-func AesCfbDecrypt(encrypted, key []byte) []byte {
-	block, _ := aes.NewCipher(key)
-	if len(encrypted) < aes.BlockSize {
-		panic("encrypted data is too short")
-	}
-	iv := encrypted[:aes.BlockSize]
-	encrypted = encrypted[aes.BlockSize:]
-
-	stream := cipher.NewCFBDecrypter(block, iv)
-	stream.XORKeyStream(encrypted, encrypted)
-	return encrypted
-}
-
-// AesOfbEncrypt encrypt data with key use AES OFB algorithm
-// len(key) should be 16, 24 or 32
-func AesOfbEncrypt(data, key []byte) []byte {
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-	data = pkcs7Padding(data, aes.BlockSize)
-	encrypted := make([]byte, aes.BlockSize+len(data))
-	iv := encrypted[:aes.BlockSize]
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
-	}
-
-	stream := cipher.NewOFB(block, iv)
-	stream.XORKeyStream(encrypted[aes.BlockSize:], data)
-	return encrypted
-}
-
-// AesOfbDecrypt decrypt data with key use AES OFB algorithm
-// len(key) should be 16, 24 or 32
-func AesOfbDecrypt(data, key []byte) []byte {
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-
-	iv := data[:aes.BlockSize]
-	data = data[aes.BlockSize:]
-	if len(data)%aes.BlockSize != 0 {
-		return nil
-	}
-
-	decrypted := make([]byte, len(data))
-	mode := cipher.NewOFB(block, iv)
-	mode.XORKeyStream(decrypted, data)
-
-	decrypted = pkcs7UnPadding(decrypted)
-	return decrypted
-}

cryptor/aes_test.go

@@ -1,62 +0,0 @@
-package cryptor
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestAesEcbEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefghijklmnop"
-
-	aesEcbEncrypt := AesEcbEncrypt([]byte(data), []byte(key))
-	aesEcbDecrypt := AesEcbDecrypt(aesEcbEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestAesEcbEncrypt")
-	assert.Equal(data, string(aesEcbDecrypt))
-}
-
-func TestAesCbcEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefghijklmnop"
-
-	aesCbcEncrypt := AesCbcEncrypt([]byte(data), []byte(key))
-	aesCbcDecrypt := AesCbcDecrypt(aesCbcEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestAesCbcEncrypt")
-	assert.Equal(data, string(aesCbcDecrypt))
-}
-
-func TestAesCtrCrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefghijklmnop"
-
-	aesCtrCrypt := AesCtrCrypt([]byte(data), []byte(key))
-	aesCtrDeCrypt := AesCtrCrypt(aesCtrCrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestAesCtrCrypt")
-	assert.Equal(data, string(aesCtrDeCrypt))
-}
-
-func TestAesCfbEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefghijklmnop"
-
-	aesCfbEncrypt := AesCfbEncrypt([]byte(data), []byte(key))
-	aesCfbDecrypt := AesCfbDecrypt(aesCfbEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestAesCfbEncrypt")
-	assert.Equal(data, string(aesCfbDecrypt))
-}
-
-func TestAesOfbEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefghijklmnop"
-
-	aesOfbEncrypt := AesOfbEncrypt([]byte(data), []byte(key))
-	aesOfbDecrypt := AesOfbDecrypt(aesOfbEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestAesOfbEncrypt")
-	assert.Equal(data, string(aesOfbDecrypt))
-}

cryptor/basic.go

@@ -19,25 +19,52 @@ import (
 	"os"
 )
 
-// Base64StdEncode encode string with base64 encoding
+// Base64StdEncode encode string with base64 encoding.
+// Play: https://go.dev/play/p/VOaUyQUreoK
 func Base64StdEncode(s string) string {
 	return base64.StdEncoding.EncodeToString([]byte(s))
 }
 
-// Base64StdDecode decode a base64 encoded string
+// Base64StdDecode decode a base64 encoded string.
+// Play: https://go.dev/play/p/RWQylnJVgIe
 func Base64StdDecode(s string) string {
 	b, _ := base64.StdEncoding.DecodeString(s)
 	return string(b)
 }
 
-// Md5String return the md5 value of string
+// Md5String return the md5 value of string.
+// Play: https://go.dev/play/p/1bLcVetbTOI
 func Md5String(s string) string {
 	h := md5.New()
 	h.Write([]byte(s))
 	return hex.EncodeToString(h.Sum(nil))
 }
 
-// Md5File return the md5 value of file
+// Md5StringWithBase64 return the md5 value of string with base64.
+// Play: https://go.dev/play/p/Lx4gH7Vdr5_y
+func Md5StringWithBase64(s string) string {
+	h := md5.New()
+	h.Write([]byte(s))
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
+// Md5Byte return the md5 string of byte slice.
+// Play: https://go.dev/play/p/suraalH8lyC
+func Md5Byte(data []byte) string {
+	h := md5.New()
+	h.Write(data)
+	return hex.EncodeToString(h.Sum(nil))
+}
+
+// Md5ByteWithBase64 return the md5 string of byte slice with base64.
+// Play: https://go.dev/play/p/Tcb-Z7LN2ax
+func Md5ByteWithBase64(data []byte) string {
+	h := md5.New()
+	h.Write(data)
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
+// Md5File return the md5 value of file.
 func Md5File(filename string) (string, error) {
 	if fileInfo, err := os.Stat(filename); err != nil {
 		return "", err
@@ -69,51 +96,114 @@ func Md5File(filename string) (string, error) {
 	return checksum, nil
 }
 
-// HmacMd5 return the hmac hash of string use md5
-func HmacMd5(data, key string) string {
+// HmacMd5 return the hmac hash of string use md5.
+// Play: https://go.dev/play/p/uef0q1fz53I
+func HmacMd5(str, key string) string {
+	h := hmac.New(md5.New, []byte(key))
+	h.Write([]byte(str))
+	return hex.EncodeToString(h.Sum([]byte("")))
+}
+
+// HmacMd5WithBase64 return the hmac hash of string use md5 with base64.
+// todo
+func HmacMd5WithBase64(data, key string) string {
 	h := hmac.New(md5.New, []byte(key))
 	h.Write([]byte(data))
-	return hex.EncodeToString(h.Sum([]byte("")))
+	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha1 return the hmac hash of string use sha1
-func HmacSha1(data, key string) string {
+// HmacSha1 return the hmac hash of string use sha1.
+// Play: https://go.dev/play/p/1UI4oQ4WXKM
+func HmacSha1(str, key string) string {
 	h := hmac.New(sha1.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha256 return the hmac hash of string use sha256
-func HmacSha256(data, key string) string {
+// HmacSha1WithBase64 return the hmac hash of string use sha1 with base64.
+// Play: https://go.dev/play/p/47JmmGrnF7B
+func HmacSha1WithBase64(str, key string) string {
+	h := hmac.New(sha1.New, []byte(key))
+	h.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
+}
+
+// HmacSha256 return the hmac hash of string use sha256.
+// Play: https://go.dev/play/p/HhpwXxFhhC0
+func HmacSha256(str, key string) string {
 	h := hmac.New(sha256.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha512 return the hmac hash of string use sha512
-func HmacSha512(data, key string) string {
+// HmacSha256WithBase64 return the hmac hash of string use sha256 with base64.
+// Play: https://go.dev/play/p/EKbkUvPTLwO
+func HmacSha256WithBase64(str, key string) string {
+	h := hmac.New(sha256.New, []byte(key))
+	h.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
+}
+
+// HmacSha512 return the hmac hash of string use sha512.
+// Play: https://go.dev/play/p/59Od6m4A0Ud
+func HmacSha512(str, key string) string {
 	h := hmac.New(sha512.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
-// Sha1 return the sha1 value (SHA-1 hash algorithm) of string
-func Sha1(data string) string {
+// HmacSha512WithBase64 return the hmac hash of string use sha512 with base64.
+// Play: https://go.dev/play/p/c6dSe3E2ydU
+func HmacSha512WithBase64(str, key string) string {
+	h := hmac.New(sha512.New, []byte(key))
+	h.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
+}
+
+// Sha1 return the sha1 value (SHA-1 hash algorithm) of string.
+// Play: https://go.dev/play/p/_m_uoD1deMT
+func Sha1(str string) string {
 	sha1 := sha1.New()
-	sha1.Write([]byte(data))
+	sha1.Write([]byte(str))
 	return hex.EncodeToString(sha1.Sum([]byte("")))
 }
 
-// Sha256 return the sha256 value (SHA256 hash algorithm) of string
-func Sha256(data string) string {
+// Sha1WithBase64 return the sha1 value (SHA-1 hash algorithm) of base64 string.
+// Play: https://go.dev/play/p/fSyx-Gl2l2-
+func Sha1WithBase64(str string) string {
+	sha1 := sha1.New()
+	sha1.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(sha1.Sum([]byte("")))
+}
+
+// Sha256 return the sha256 value (SHA256 hash algorithm) of string.
+// Play: https://go.dev/play/p/tU9tfBMIAr1
+func Sha256(str string) string {
 	sha256 := sha256.New()
-	sha256.Write([]byte(data))
+	sha256.Write([]byte(str))
 	return hex.EncodeToString(sha256.Sum([]byte("")))
 }
 
-// Sha512 return the sha512 value (SHA512 hash algorithm) of string
-func Sha512(data string) string {
+// Sha256WithBase64 return the sha256 value (SHA256 hash algorithm) of base64 string.
+// Play: https://go.dev/play/p/85IXJHIal1k
+func Sha256WithBase64(str string) string {
+	sha256 := sha256.New()
+	sha256.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(sha256.Sum([]byte("")))
+}
+
+// Sha512 return the sha512 value (SHA512 hash algorithm) of string.
+// Play: https://go.dev/play/p/3WsvLYZxsHa
+func Sha512(str string) string {
 	sha512 := sha512.New()
-	sha512.Write([]byte(data))
+	sha512.Write([]byte(str))
 	return hex.EncodeToString(sha512.Sum([]byte("")))
 }
+
+// Sha512WithBase64 return the sha512 value (SHA512 hash algorithm) of base64 string.
+// Play: https://go.dev/play/p/q_fY2rA-k5I
+func Sha512WithBase64(str string) string {
+	sha512 := sha512.New()
+	sha512.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(sha512.Sum([]byte("")))
+}

cryptor/basic_test.go

@@ -7,21 +7,51 @@ import (
 )
 
 func TestBase64StdEncode(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBase64StdEncode")
 	assert.Equal("aGVsbG8gd29ybGQ=", Base64StdEncode("hello world"))
 }
 
 func TestBase64StdDecode(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBase64StdDecode")
 	assert.Equal("hello world", Base64StdDecode("aGVsbG8gd29ybGQ="))
 }
 
 func TestMd5String(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMd5String")
 	assert.Equal("5d41402abc4b2a76b9719d911017c592", Md5String("hello"))
 }
 
+func TestMd5StringWithBase64(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMd5StringWithBase64")
+	assert.Equal("XUFAKrxLKna5cZ2REBfFkg==", Md5StringWithBase64("hello"))
+}
+
+func TestMd5Byte(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMd5Byte")
+	data := []byte{'a'}
+	assert.Equal("0cc175b9c0f1b6a831c399e269772661", Md5Byte(data))
+}
+
+func TestMd5ByteWithBase64(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMd5ByteWithBase64")
+	assert.Equal("XUFAKrxLKna5cZ2REBfFkg==", Md5ByteWithBase64([]byte("hello")))
+}
+
 func TestMd5File(t *testing.T) {
+	t.Parallel()
+
 	fileMd5, err := Md5File("./basic.go")
 	assert := internal.NewAssert(t, "TestMd5File")
 	assert.IsNotNil(fileMd5)
@@ -29,11 +59,22 @@ func TestMd5File(t *testing.T) {
 }
 
 func TestHmacMd5(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestHmacMd5")
 	assert.Equal("5f4c9faaff0a1ad3007d9ddc06abe36d", HmacMd5("hello world", "12345"))
 }
 
+func TestHmacMd5WithBase64(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestHmacMd5WithBase64")
+	assert.Equal("6DQwbquJLYclJdSRinpjmg==", HmacMd5WithBase64("hello", "12345"))
+}
+
 func TestHmacSha1(t *testing.T) {
+	t.Parallel()
+
 	s := "hello world"
 	key := "12345"
 	hmacSha1 := HmacSha1(s, key)
@@ -43,17 +84,45 @@ func TestHmacSha1(t *testing.T) {
 	assert.Equal(expected, hmacSha1)
 }
 
-func TestHmacSha256(t *testing.T) {
-	s := "hello world"
+func TestHmacSha1WithBase64(t *testing.T) {
+	t.Parallel()
+
+	s := "hello"
 	key := "12345"
-	hmacSha256 := HmacSha256(s, key)
+	hmacSha1 := HmacSha1WithBase64(s, key)
+	expected := "XGqdsMzLkuNu0DI/0Jt/k23prOA="
+
+	assert := internal.NewAssert(t, "TestHmacSha1")
+	assert.Equal(expected, hmacSha1)
+}
+
+func TestHmacSha256(t *testing.T) {
+	t.Parallel()
+
+	str := "hello world"
+	key := "12345"
+	hmacSha256 := HmacSha256(str, key)
 	expected := "9dce2609f2d67d41f74c7f9efc8ccd44370d41ad2de52982627588dfe7289ab8"
 
 	assert := internal.NewAssert(t, "TestHmacSha256")
 	assert.Equal(expected, hmacSha256)
 }
 
+func TestHmacSha256WithBase64(t *testing.T) {
+	t.Parallel()
+
+	str := "hello"
+	key := "12345"
+	hms := HmacSha256WithBase64(str, key)
+	expected := "MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU="
+
+	assert := internal.NewAssert(t, "TestHmacSha256WithBase64")
+	assert.Equal(expected, hms)
+}
+
 func TestHmacSha512(t *testing.T) {
+	t.Parallel()
+
 	s := "hello world"
 	key := "12345"
 	hmacSha512 := HmacSha512(s, key)
@@ -63,7 +132,21 @@ func TestHmacSha512(t *testing.T) {
 	assert.Equal(expected, hmacSha512)
 }
 
+func TestHmacSha512WithBase64(t *testing.T) {
+	t.Parallel()
+
+	str := "hello"
+	key := "12345"
+	hms := HmacSha512WithBase64(str, key)
+	expected := "3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A=="
+
+	assert := internal.NewAssert(t, "TestHmacSha512WithBase64")
+	assert.Equal(expected, hms)
+}
+
 func TestSha1(t *testing.T) {
+	t.Parallel()
+
 	s := "hello world"
 	sha1 := Sha1(s)
 	expected := "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"
@@ -72,7 +155,19 @@ func TestSha1(t *testing.T) {
 	assert.Equal(expected, sha1)
 }
 
+func TestSha1WithBase64(t *testing.T) {
+	t.Parallel()
+
+	str := Sha1WithBase64("hello")
+	expected := "qvTGHdzF6KLavt4PO0gs2a6pQ00="
+
+	assert := internal.NewAssert(t, "TestSha1WithBase64")
+	assert.Equal(expected, str)
+}
+
 func TestSha256(t *testing.T) {
+	t.Parallel()
+
 	s := "hello world"
 	sha256 := Sha256(s)
 	expected := "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
@@ -81,7 +176,19 @@ func TestSha256(t *testing.T) {
 	assert.Equal(expected, sha256)
 }
 
+func TestSha256WithBase64(t *testing.T) {
+	t.Parallel()
+
+	str := Sha256WithBase64("hello")
+	expected := "LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ="
+
+	assert := internal.NewAssert(t, "TestSha256WithBase64")
+	assert.Equal(expected, str)
+}
+
 func TestSha512(t *testing.T) {
+	t.Parallel()
+
 	s := "hello world"
 	sha512 := Sha512(s)
 	expected := "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f"
@@ -89,3 +196,13 @@ func TestSha512(t *testing.T) {
 	assert := internal.NewAssert(t, "TestSha512")
 	assert.Equal(expected, sha512)
 }
+
+func TestSha512WithBase64(t *testing.T) {
+	t.Parallel()
+
+	str := Sha512WithBase64("hello")
+	expected := "m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw=="
+
+	assert := internal.NewAssert(t, "TestSha512WithBase64")
+	assert.Equal(expected, str)
+}

cryptor/crypto.go

@@ -0,0 +1,507 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package cryptor implements some util functions to encrypt and decrypt.
+// Note:
+// 1. for aes crypt function, the `key` param length should be 16, 24 or 32. if not, will panic.
+package cryptor
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/des"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/pem"
+	"io"
+	"os"
+)
+
+// AesEcbEncrypt encrypt data with key use AES ECB algorithm
+// 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")
+	}
+
+	length := (len(data) + aes.BlockSize) / aes.BlockSize
+	plain := make([]byte, length*aes.BlockSize)
+
+	copy(plain, data)
+
+	pad := byte(len(plain) - len(data))
+	for i := len(data); i < len(plain); i++ {
+		plain[i] = pad
+	}
+
+	encrypted := make([]byte, len(plain))
+	cipher, _ := aes.NewCipher(generateAesKey(key, size))
+
+	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])
+	}
+
+	return encrypted
+}
+
+// AesEcbDecrypt decrypt data with key use AES ECB algorithm
+// 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")
+	}
+	cipher, _ := aes.NewCipher(generateAesKey(key, size))
+	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])
+	}
+
+	trim := 0
+	if len(decrypted) > 0 {
+		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
+	}
+
+	return decrypted[:trim]
+}
+
+// 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)
+	}
+
+	mode := cipher.NewCBCEncrypter(block, iv)
+	mode.CryptBlocks(encrypted[aes.BlockSize:], data)
+
+	return 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)
+
+	iv := encrypted[:aes.BlockSize]
+	encrypted = encrypted[aes.BlockSize:]
+
+	mode := cipher.NewCBCDecrypter(block, iv)
+	mode.CryptBlocks(encrypted, encrypted)
+
+	decrypted := pkcs7UnPadding(encrypted)
+	return 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
+func AesCtrCrypt(data, key []byte) []byte {
+	block, _ := aes.NewCipher(key)
+
+	iv := bytes.Repeat([]byte("1"), block.BlockSize())
+	stream := cipher.NewCTR(block, iv)
+
+	dst := make([]byte, len(data))
+	stream.XORKeyStream(dst, data)
+
+	return dst
+}
+
+// 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 {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	encrypted := make([]byte, aes.BlockSize+len(data))
+	iv := encrypted[:aes.BlockSize]
+
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	stream := cipher.NewCFBEncrypter(block, iv)
+	stream.XORKeyStream(encrypted[aes.BlockSize:], data)
+
+	return encrypted
+}
+
+// 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")
+	}
+
+	block, _ := aes.NewCipher(key)
+	iv := encrypted[:aes.BlockSize]
+	encrypted = encrypted[aes.BlockSize:]
+
+	stream := cipher.NewCFBDecrypter(block, iv)
+
+	stream.XORKeyStream(encrypted, encrypted)
+
+	return encrypted
+}
+
+// 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 {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	data = pkcs7Padding(data, aes.BlockSize)
+	encrypted := make([]byte, aes.BlockSize+len(data))
+	iv := encrypted[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	stream := cipher.NewOFB(block, iv)
+	stream.XORKeyStream(encrypted[aes.BlockSize:], data)
+
+	return encrypted
+}
+
+// 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)
+	}
+
+	iv := data[:aes.BlockSize]
+	data = data[aes.BlockSize:]
+	if len(data)%aes.BlockSize != 0 {
+		return nil
+	}
+
+	decrypted := make([]byte, len(data))
+	mode := cipher.NewOFB(block, iv)
+	mode.XORKeyStream(decrypted, data)
+
+	decrypted = pkcs7UnPadding(decrypted)
+
+	return decrypted
+}
+
+// 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
+	}
+
+	encrypted := make([]byte, len(plain))
+	cipher, _ := des.NewCipher(generateDesKey(key))
+
+	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])
+	}
+
+	return encrypted
+}
+
+// DesEcbDecrypt decrypt data with key use DES ECB algorithm
+// len(key) should be 8.
+// Play: https://go.dev/play/p/8qivmPeZy4P
+func DesEcbDecrypt(encrypted, key []byte) []byte {
+	cipher, _ := des.NewCipher(generateDesKey(key))
+	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])
+	}
+
+	trim := 0
+	if len(decrypted) > 0 {
+		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
+	}
+
+	return decrypted[:trim]
+}
+
+// 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())
+
+	encrypted := make([]byte, des.BlockSize+len(data))
+	iv := encrypted[:des.BlockSize]
+
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	mode := cipher.NewCBCEncrypter(block, iv)
+	mode.CryptBlocks(encrypted[des.BlockSize:], data)
+
+	return encrypted
+}
+
+// DesCbcDecrypt decrypt data with key use DES CBC algorithm
+// len(key) should be 8.
+// Play: https://go.dev/play/p/4cC4QvWfe3_1
+func DesCbcDecrypt(encrypted, key []byte) []byte {
+	block, _ := des.NewCipher(key)
+
+	iv := encrypted[:des.BlockSize]
+	encrypted = encrypted[des.BlockSize:]
+
+	mode := cipher.NewCBCDecrypter(block, iv)
+	mode.CryptBlocks(encrypted, encrypted)
+
+	decrypted := pkcs7UnPadding(encrypted)
+	return decrypted
+}
+
+// DesCtrCrypt encrypt data with key use DES CTR algorithm
+// len(key) should be 8.
+// Play: https://go.dev/play/p/9-T6OjKpcdw
+func DesCtrCrypt(data, key []byte) []byte {
+	block, _ := des.NewCipher(key)
+
+	iv := bytes.Repeat([]byte("1"), block.BlockSize())
+	stream := cipher.NewCTR(block, iv)
+
+	dst := make([]byte, len(data))
+	stream.XORKeyStream(dst, data)
+
+	return dst
+}
+
+// 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 {
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	encrypted := make([]byte, des.BlockSize+len(data))
+	iv := encrypted[:des.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	stream := cipher.NewCFBEncrypter(block, iv)
+	stream.XORKeyStream(encrypted[des.BlockSize:], data)
+
+	return encrypted
+}
+
+// DesCfbDecrypt decrypt data with key use DES CFB algorithm
+// 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")
+	}
+	iv := encrypted[:des.BlockSize]
+	encrypted = encrypted[des.BlockSize:]
+
+	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(encrypted, encrypted)
+
+	return encrypted
+}
+
+// DesOfbEncrypt encrypt data with key use DES OFB algorithm
+// len(key) should be 16, 24 or 32.
+// Play: https://go.dev/play/p/74KmNadjN1J
+func DesOfbEncrypt(data, key []byte) []byte {
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+	data = pkcs7Padding(data, des.BlockSize)
+	encrypted := make([]byte, des.BlockSize+len(data))
+	iv := encrypted[:des.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	stream := cipher.NewOFB(block, iv)
+	stream.XORKeyStream(encrypted[des.BlockSize:], data)
+
+	return encrypted
+}
+
+// DesOfbDecrypt decrypt data with key use DES OFB algorithm
+// len(key) should be 8.
+// Play: https://go.dev/play/p/74KmNadjN1J
+func DesOfbDecrypt(data, key []byte) []byte {
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	iv := data[:des.BlockSize]
+	data = data[des.BlockSize:]
+	if len(data)%des.BlockSize != 0 {
+		return nil
+	}
+
+	decrypted := make([]byte, len(data))
+	mode := cipher.NewOFB(block, iv)
+	mode.XORKeyStream(decrypted, data)
+
+	decrypted = pkcs7UnPadding(decrypted)
+
+	return decrypted
+}
+
+// GenerateRsaKey create rsa private and public pemo file.
+// Play: https://go.dev/play/p/zutRHrDqs0X
+func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error {
+	// private key
+	privateKey, err := rsa.GenerateKey(rand.Reader, keySize)
+	if err != nil {
+		return err
+	}
+
+	derText := x509.MarshalPKCS1PrivateKey(privateKey)
+
+	block := pem.Block{
+		Type:  "rsa private key",
+		Bytes: derText,
+	}
+
+	file, err := os.Create(priKeyFile)
+	if err != nil {
+		panic(err)
+	}
+	err = pem.Encode(file, &block)
+	if err != nil {
+		return err
+	}
+
+	file.Close()
+
+	// public key
+	publicKey := privateKey.PublicKey
+
+	derpText, err := x509.MarshalPKIXPublicKey(&publicKey)
+	if err != nil {
+		return err
+	}
+
+	block = pem.Block{
+		Type:  "rsa public key",
+		Bytes: derpText,
+	}
+
+	file, err = os.Create(pubKeyFile)
+	if err != nil {
+		return err
+	}
+
+	err = pem.Encode(file, &block)
+	if err != nil {
+		return err
+	}
+
+	file.Close()
+
+	return nil
+}
+
+// RsaEncrypt encrypt data with ras algorithm.
+// Play: https://go.dev/play/p/rDqTT01SPkZ
+func RsaEncrypt(data []byte, pubKeyFileName string) []byte {
+	file, err := os.Open(pubKeyFileName)
+	if err != nil {
+		panic(err)
+	}
+	fileInfo, err := file.Stat()
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+	buf := make([]byte, fileInfo.Size())
+
+	_, err = file.Read(buf)
+	if err != nil {
+		panic(err)
+	}
+
+	block, _ := pem.Decode(buf)
+
+	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
+	if err != nil {
+		panic(err)
+	}
+	pubKey := pubInterface.(*rsa.PublicKey)
+
+	cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, pubKey, data)
+	if err != nil {
+		panic(err)
+	}
+	return cipherText
+}
+
+// RsaDecrypt decrypt data with ras algorithm.
+// Play: https://go.dev/play/p/rDqTT01SPkZ
+func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
+	file, err := os.Open(privateKeyFileName)
+	if err != nil {
+		panic(err)
+	}
+	fileInfo, err := file.Stat()
+	if err != nil {
+		panic(err)
+	}
+	buf := make([]byte, fileInfo.Size())
+	defer file.Close()
+
+	_, err = file.Read(buf)
+	if err != nil {
+		panic(err)
+	}
+
+	block, _ := pem.Decode(buf)
+
+	priKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
+	if err != nil {
+		panic(err)
+	}
+
+	plainText, err := rsa.DecryptPKCS1v15(rand.Reader, priKey, data)
+	if err != nil {
+		panic(err)
+	}
+	return plainText
+}

cryptor/crypto_example_test.go

@@ -0,0 +1,486 @@
+package cryptor
+
+import "fmt"
+
+func ExampleAesEcbEncrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesEcbEncrypt([]byte(data), []byte(key))
+
+	decrypted := AesEcbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleAesEcbDecrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesEcbEncrypt([]byte(data), []byte(key))
+
+	decrypted := AesEcbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleAesCbcEncrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesCbcEncrypt([]byte(data), []byte(key))
+
+	decrypted := AesCbcDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleAesCbcDecrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesCbcEncrypt([]byte(data), []byte(key))
+
+	decrypted := AesCbcDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleAesCtrCrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesCtrCrypt([]byte(data), []byte(key))
+	decrypted := AesCtrCrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleAesCfbEncrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesCfbEncrypt([]byte(data), []byte(key))
+
+	decrypted := AesCfbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleAesCfbDecrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesCfbEncrypt([]byte(data), []byte(key))
+
+	decrypted := AesCfbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleAesOfbEncrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesOfbEncrypt([]byte(data), []byte(key))
+
+	decrypted := AesOfbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleAesOfbDecrypt() {
+	data := "hello"
+	key := "abcdefghijklmnop"
+
+	encrypted := AesOfbEncrypt([]byte(data), []byte(key))
+
+	decrypted := AesOfbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleDesEcbEncrypt() {
+	data := "hello"
+	key := "abcdefgh"
+
+	encrypted := DesEcbEncrypt([]byte(data), []byte(key))
+
+	decrypted := DesEcbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleDesEcbDecrypt() {
+	data := "hello"
+	key := "abcdefgh"
+
+	encrypted := DesEcbEncrypt([]byte(data), []byte(key))
+
+	decrypted := DesEcbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleDesCbcEncrypt() {
+	data := "hello"
+	key := "abcdefgh"
+
+	encrypted := DesCbcEncrypt([]byte(data), []byte(key))
+
+	decrypted := DesCbcDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleDesCbcDecrypt() {
+	data := "hello"
+	key := "abcdefgh"
+
+	encrypted := DesCbcEncrypt([]byte(data), []byte(key))
+
+	decrypted := DesCbcDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleDesCtrCrypt() {
+	data := "hello"
+	key := "abcdefgh"
+
+	encrypted := DesCtrCrypt([]byte(data), []byte(key))
+	decrypted := DesCtrCrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleDesCfbEncrypt() {
+	data := "hello"
+	key := "abcdefgh"
+
+	encrypted := DesCfbEncrypt([]byte(data), []byte(key))
+
+	decrypted := DesCfbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleDesCfbDecrypt() {
+	data := "hello"
+	key := "abcdefgh"
+
+	encrypted := DesCfbEncrypt([]byte(data), []byte(key))
+
+	decrypted := DesCfbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleDesOfbEncrypt() {
+	data := "hello"
+	key := "abcdefgh"
+
+	encrypted := DesOfbEncrypt([]byte(data), []byte(key))
+
+	decrypted := DesOfbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleDesOfbDecrypt() {
+	data := "hello"
+	key := "abcdefgh"
+
+	encrypted := DesOfbEncrypt([]byte(data), []byte(key))
+
+	decrypted := DesOfbDecrypt(encrypted, []byte(key))
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleGenerateRsaKey() {
+	// Create ras private and public pem file
+	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	if err != nil {
+		return
+	}
+
+	fmt.Println("foo")
+
+	// Output:
+	// foo
+}
+
+func ExampleRsaEncrypt() {
+	// Create ras private and public pem file
+	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	if err != nil {
+		return
+	}
+
+	data := []byte("hello")
+	encrypted := RsaEncrypt(data, "rsa_public.pem")
+	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleRsaDecrypt() {
+	// Create ras private and public pem file
+	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	if err != nil {
+		return
+	}
+
+	data := []byte("hello")
+	encrypted := RsaEncrypt(data, "rsa_public.pem")
+	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello
+}
+
+func ExampleBase64StdEncode() {
+	base64Str := Base64StdEncode("hello")
+
+	fmt.Println(base64Str)
+
+	// Output:
+	// aGVsbG8=
+}
+
+func ExampleBase64StdDecode() {
+	str := Base64StdDecode("aGVsbG8=")
+
+	fmt.Println(str)
+
+	// Output:
+	// hello
+}
+
+func ExampleHmacMd5() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacMd5(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// e834306eab892d872525d4918a7a639a
+}
+
+func ExampleHmacMd5WithBase64() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacMd5WithBase64(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// 6DQwbquJLYclJdSRinpjmg==
+}
+
+func ExampleHmacSha1() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacSha1(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// 5c6a9db0cccb92e36ed0323fd09b7f936de9ace0
+}
+
+func ExampleHmacSha1WithBase64() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacSha1WithBase64(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// XGqdsMzLkuNu0DI/0Jt/k23prOA=
+}
+
+func ExampleHmacSha256() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacSha256(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// 315bb93c4e989862ba09cb62e05d73a5f376cb36f0d786edab0c320d059fde75
+}
+
+func ExampleHmacSha256WithBase64() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacSha256WithBase64(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU=
+}
+
+func ExampleHmacSha512() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacSha512(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// dd8f1290a9dd23d354e2526d9a2e9ce8cffffdd37cb320800d1c6c13d2efc363288376a196c5458daf53f8e1aa6b45a6d856303d5c0a2064bff9785861d48cfc
+}
+
+func ExampleHmacSha512WithBase64() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacSha512WithBase64(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
+}
+
+func ExampleMd5String() {
+	md5Str := Md5String("hello")
+	fmt.Println(md5Str)
+
+	// Output:
+	// 5d41402abc4b2a76b9719d911017c592
+}
+
+func ExampleMd5StringWithBase64() {
+	md5Str := Md5StringWithBase64("hello")
+	fmt.Println(md5Str)
+
+	// Output:
+	// XUFAKrxLKna5cZ2REBfFkg==
+}
+
+func ExampleMd5Byte() {
+	md5Str := Md5Byte([]byte{'a'})
+	fmt.Println(md5Str)
+
+	// Output:
+	// 0cc175b9c0f1b6a831c399e269772661
+}
+
+func ExampleMd5ByteWithBase64() {
+	md5Str := Md5ByteWithBase64([]byte("hello"))
+	fmt.Println(md5Str)
+
+	// Output:
+	// XUFAKrxLKna5cZ2REBfFkg==
+}
+
+func ExampleSha1() {
+	result := Sha1("hello")
+	fmt.Println(result)
+
+	// Output:
+	// aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
+}
+
+func ExampleSha1WithBase64() {
+	result := Sha1WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
+}
+
+func ExampleSha256() {
+	result := Sha256("hello")
+	fmt.Println(result)
+
+	// Output:
+	// 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
+}
+
+func ExampleSha256WithBase64() {
+	result := Sha256WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
+}
+
+func ExampleSha512() {
+	result := Sha512("hello")
+	fmt.Println(result)
+
+	// Output:
+	// 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
+}
+
+func ExampleSha512WithBase64() {
+	result := Sha512WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
+}

cryptor/crypto_internal.go

@@ -2,11 +2,11 @@ package cryptor
 
 import "bytes"
 
-func generateAesKey(key []byte) []byte {
-	genKey := make([]byte, 16)
+func generateAesKey(key []byte, size int) []byte {
+	genKey := make([]byte, size)
 	copy(genKey, key)
-	for i := 16; i < len(key); {
-		for j := 0; j < 16 && i < len(key); j, i = j+1, i+1 {
+	for i := size; i < len(key); {
+		for j := 0; j < size && i < len(key); j, i = j+1, i+1 {
 			genKey[j] ^= key[i]
 		}
 	}

cryptor/crypto_test.go

@@ -0,0 +1,152 @@
+package cryptor
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestAesEcbEncrypt(t *testing.T) {
+	t.Parallel()
+
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesEcbEncrypt := AesEcbEncrypt([]byte(data), []byte(key))
+	aesEcbDecrypt := AesEcbDecrypt(aesEcbEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestAesEcbEncrypt")
+	assert.Equal(data, string(aesEcbDecrypt))
+}
+
+func TestAesCbcEncrypt(t *testing.T) {
+	t.Parallel()
+
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesCbcEncrypt := AesCbcEncrypt([]byte(data), []byte(key))
+	aesCbcDecrypt := AesCbcDecrypt(aesCbcEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestAesCbcEncrypt")
+	assert.Equal(data, string(aesCbcDecrypt))
+}
+
+func TestAesCtrCrypt(t *testing.T) {
+	t.Parallel()
+
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesCtrCrypt := AesCtrCrypt([]byte(data), []byte(key))
+	aesCtrDeCrypt := AesCtrCrypt(aesCtrCrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestAesCtrCrypt")
+	assert.Equal(data, string(aesCtrDeCrypt))
+}
+
+func TestAesCfbEncrypt(t *testing.T) {
+	t.Parallel()
+
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesCfbEncrypt := AesCfbEncrypt([]byte(data), []byte(key))
+	aesCfbDecrypt := AesCfbDecrypt(aesCfbEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestAesCfbEncrypt")
+	assert.Equal(data, string(aesCfbDecrypt))
+}
+
+func TestAesOfbEncrypt(t *testing.T) {
+	t.Parallel()
+
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesOfbEncrypt := AesOfbEncrypt([]byte(data), []byte(key))
+	aesOfbDecrypt := AesOfbDecrypt(aesOfbEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestAesOfbEncrypt")
+	assert.Equal(data, string(aesOfbDecrypt))
+}
+
+func TestDesEcbEncrypt(t *testing.T) {
+	t.Parallel()
+
+	data := "hello world"
+	key := "abcdefgh"
+
+	desEcbEncrypt := DesEcbEncrypt([]byte(data), []byte(key))
+	desEcbDecrypt := DesEcbDecrypt(desEcbEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestDesEcbEncrypt")
+	assert.Equal(data, string(desEcbDecrypt))
+}
+
+func TestDesCbcEncrypt(t *testing.T) {
+	t.Parallel()
+
+	data := "hello world"
+	key := "abcdefgh"
+
+	desCbcEncrypt := DesCbcEncrypt([]byte(data), []byte(key))
+	desCbcDecrypt := DesCbcDecrypt(desCbcEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestDesCbcEncrypt")
+	assert.Equal(data, string(desCbcDecrypt))
+}
+
+func TestDesCtrCrypt(t *testing.T) {
+	t.Parallel()
+
+	data := "hello world"
+	key := "abcdefgh"
+
+	desCtrCrypt := DesCtrCrypt([]byte(data), []byte(key))
+	desCtrDeCrypt := DesCtrCrypt(desCtrCrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestDesCtrCrypt")
+	assert.Equal(data, string(desCtrDeCrypt))
+}
+
+func TestDesCfbEncrypt(t *testing.T) {
+	t.Parallel()
+
+	data := "hello world"
+	key := "abcdefgh"
+
+	desCfbEncrypt := DesCfbEncrypt([]byte(data), []byte(key))
+	desCfbDecrypt := DesCfbDecrypt(desCfbEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestDesCfbEncrypt")
+	assert.Equal(data, string(desCfbDecrypt))
+}
+
+func TestDesOfbEncrypt(t *testing.T) {
+	t.Parallel()
+
+	data := "hello world"
+	key := "abcdefgh"
+
+	desOfbEncrypt := DesOfbEncrypt([]byte(data), []byte(key))
+	desOfbDecrypt := DesOfbDecrypt(desOfbEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestDesOfbEncrypt")
+	assert.Equal(data, string(desOfbDecrypt))
+}
+
+func TestRsaEncrypt(t *testing.T) {
+	t.Parallel()
+
+	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	if err != nil {
+		t.FailNow()
+	}
+	data := []byte("hello world")
+	encrypted := RsaEncrypt(data, "rsa_public.pem")
+	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
+
+	assert := internal.NewAssert(t, "TestRsaEncrypt")
+	assert.Equal(string(data), string(decrypted))
+}

cryptor/des.go

@@ -1,178 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package cryptor implements some util functions to encrypt and decrypt.
-package cryptor
-
-import (
-	"bytes"
-	"crypto/cipher"
-	"crypto/des"
-	"crypto/rand"
-	"io"
-)
-
-// DesEcbEncrypt encrypt data with key use DES ECB algorithm
-// len(key) should be 8
-func DesEcbEncrypt(data, key []byte) []byte {
-	cipher, _ := des.NewCipher(generateDesKey(key))
-	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
-	}
-
-	encrypted := make([]byte, len(plain))
-	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])
-	}
-
-	return encrypted
-}
-
-// DesEcbDecrypt decrypt data with key use DES ECB algorithm
-// len(key) should be 8
-func DesEcbDecrypt(encrypted, key []byte) []byte {
-	cipher, _ := des.NewCipher(generateDesKey(key))
-	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])
-	}
-
-	trim := 0
-	if len(decrypted) > 0 {
-		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
-	}
-
-	return decrypted[:trim]
-}
-
-// DesCbcEncrypt encrypt data with key use DES CBC algorithm
-// len(key) should be 8
-func DesCbcEncrypt(data, key []byte) []byte {
-	block, _ := des.NewCipher(key)
-	data = pkcs7Padding(data, block.BlockSize())
-
-	encrypted := make([]byte, des.BlockSize+len(data))
-	iv := encrypted[:des.BlockSize]
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
-	}
-
-	mode := cipher.NewCBCEncrypter(block, iv)
-	mode.CryptBlocks(encrypted[des.BlockSize:], data)
-
-	return encrypted
-}
-
-// DesCbcDecrypt decrypt data with key use DES CBC algorithm
-// len(key) should be 8
-func DesCbcDecrypt(encrypted, key []byte) []byte {
-	block, _ := des.NewCipher(key)
-
-	iv := encrypted[:des.BlockSize]
-	encrypted = encrypted[des.BlockSize:]
-
-	mode := cipher.NewCBCDecrypter(block, iv)
-	mode.CryptBlocks(encrypted, encrypted)
-
-	decrypted := pkcs7UnPadding(encrypted)
-	return decrypted
-}
-
-// DesCtrCrypt encrypt data with key use DES CTR algorithm
-// len(key) should be 8
-func DesCtrCrypt(data, key []byte) []byte {
-	block, _ := des.NewCipher(key)
-
-	iv := bytes.Repeat([]byte("1"), block.BlockSize())
-	stream := cipher.NewCTR(block, iv)
-
-	dst := make([]byte, len(data))
-	stream.XORKeyStream(dst, data)
-
-	return dst
-}
-
-// DesCfbEncrypt encrypt data with key use DES CFB algorithm
-// len(key) should be 8
-func DesCfbEncrypt(data, key []byte) []byte {
-	block, err := des.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-
-	encrypted := make([]byte, des.BlockSize+len(data))
-	iv := encrypted[:des.BlockSize]
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
-	}
-
-	stream := cipher.NewCFBEncrypter(block, iv)
-	stream.XORKeyStream(encrypted[des.BlockSize:], data)
-
-	return encrypted
-}
-
-// DesCfbDecrypt decrypt data with key use DES CFB algorithm
-// len(encrypted) should be great than 16, len(key) should be 8
-func DesCfbDecrypt(encrypted, key []byte) []byte {
-	block, _ := des.NewCipher(key)
-	if len(encrypted) < des.BlockSize {
-		panic("encrypted data is too short")
-	}
-	iv := encrypted[:des.BlockSize]
-	encrypted = encrypted[des.BlockSize:]
-
-	stream := cipher.NewCFBDecrypter(block, iv)
-	stream.XORKeyStream(encrypted, encrypted)
-
-	return encrypted
-}
-
-// DesOfbEncrypt encrypt data with key use DES OFB algorithm
-// len(key) should be 16, 24 or 32
-func DesOfbEncrypt(data, key []byte) []byte {
-	block, err := des.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-	data = pkcs7Padding(data, des.BlockSize)
-	encrypted := make([]byte, des.BlockSize+len(data))
-	iv := encrypted[:des.BlockSize]
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
-	}
-
-	stream := cipher.NewOFB(block, iv)
-	stream.XORKeyStream(encrypted[des.BlockSize:], data)
-
-	return encrypted
-}
-
-// DesOfbDecrypt decrypt data with key use DES OFB algorithm
-// len(key) should be 8
-func DesOfbDecrypt(data, key []byte) []byte {
-	block, err := des.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-
-	iv := data[:des.BlockSize]
-	data = data[des.BlockSize:]
-	if len(data)%des.BlockSize != 0 {
-		return nil
-	}
-
-	decrypted := make([]byte, len(data))
-	mode := cipher.NewOFB(block, iv)
-	mode.XORKeyStream(decrypted, data)
-
-	decrypted = pkcs7UnPadding(decrypted)
-
-	return decrypted
-}

cryptor/des_test.go

@@ -1,62 +0,0 @@
-package cryptor
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestDesEcbEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefgh"
-
-	desEcbEncrypt := DesEcbEncrypt([]byte(data), []byte(key))
-	desEcbDecrypt := DesEcbDecrypt(desEcbEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestDesEcbEncrypt")
-	assert.Equal(data, string(desEcbDecrypt))
-}
-
-func TestDesCbcEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefgh"
-
-	desCbcEncrypt := DesCbcEncrypt([]byte(data), []byte(key))
-	desCbcDecrypt := DesCbcDecrypt(desCbcEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestDesCbcEncrypt")
-	assert.Equal(data, string(desCbcDecrypt))
-}
-
-func TestDesCtrCrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefgh"
-
-	desCtrCrypt := DesCtrCrypt([]byte(data), []byte(key))
-	desCtrDeCrypt := DesCtrCrypt(desCtrCrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestDesCtrCrypt")
-	assert.Equal(data, string(desCtrDeCrypt))
-}
-
-func TestDesCfbEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefgh"
-
-	desCfbEncrypt := DesCfbEncrypt([]byte(data), []byte(key))
-	desCfbDecrypt := DesCfbDecrypt(desCfbEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestDesCfbEncrypt")
-	assert.Equal(data, string(desCfbDecrypt))
-}
-
-func TestDesOfbEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefgh"
-
-	desOfbEncrypt := DesOfbEncrypt([]byte(data), []byte(key))
-	desOfbDecrypt := DesOfbDecrypt(desOfbEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestDesOfbEncrypt")
-	assert.Equal(data, string(desOfbDecrypt))
-}

cryptor/rsa.go

@@ -1,118 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package cryptor implements some util functions to encrypt and decrypt.
-package cryptor
-
-import (
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"encoding/pem"
-	"os"
-)
-
-// GenerateRsaKey make  a rsa private key, and return key file name
-// Generated key file is `rsa_private.pem` and `rsa_public.pem` in current path
-func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error {
-	// private key
-	privateKey, err := rsa.GenerateKey(rand.Reader, keySize)
-	if err != nil {
-		return err
-	}
-
-	derText := x509.MarshalPKCS1PrivateKey(privateKey)
-
-	block := pem.Block{
-		Type:  "rsa private key",
-		Bytes: derText,
-	}
-
-	//file,err := os.Create("rsa_private.pem")
-	file, err := os.Create(priKeyFile)
-	if err != nil {
-		panic(err)
-	}
-	pem.Encode(file, &block)
-	file.Close()
-
-	// public key
-	publicKey := privateKey.PublicKey
-
-	derpText, err := x509.MarshalPKIXPublicKey(&publicKey)
-	if err != nil {
-		return err
-	}
-
-	block = pem.Block{
-		Type:  "rsa public key",
-		Bytes: derpText,
-	}
-
-	//file,err = os.Create("rsa_public.pem")
-	file, err = os.Create(pubKeyFile)
-	if err != nil {
-		return err
-	}
-	pem.Encode(file, &block)
-	file.Close()
-
-	return nil
-}
-
-// RsaEncrypt encrypt data with ras algorithm
-func RsaEncrypt(data []byte, pubKeyFileName string) []byte {
-	file, err := os.Open(pubKeyFileName)
-	if err != nil {
-		panic(err)
-	}
-	fileInfo, err := file.Stat()
-	if err != nil {
-		panic(err)
-	}
-	defer file.Close()
-	buf := make([]byte, fileInfo.Size())
-	file.Read(buf)
-
-	block, _ := pem.Decode(buf)
-
-	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
-	if err != nil {
-		panic(err)
-	}
-	pubKey := pubInterface.(*rsa.PublicKey)
-
-	cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, pubKey, data)
-	if err != nil {
-		panic(err)
-	}
-	return cipherText
-}
-
-// RsaDecrypt decrypt data with ras algorithm
-func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
-	file, err := os.Open(privateKeyFileName)
-	if err != nil {
-		panic(err)
-	}
-	fileInfo, err := file.Stat()
-	if err != nil {
-		panic(err)
-	}
-	buf := make([]byte, fileInfo.Size())
-	defer file.Close()
-	file.Read(buf)
-
-	block, _ := pem.Decode(buf)
-
-	priKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
-	if err != nil {
-		panic(err)
-	}
-
-	plainText, err := rsa.DecryptPKCS1v15(rand.Reader, priKey, data)
-	if err != nil {
-		panic(err)
-	}
-	return plainText
-}

cryptor/rsa_test.go

@@ -1,20 +0,0 @@
-package cryptor
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestRsaEncrypt(t *testing.T) {
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
-	if err != nil {
-		t.FailNow()
-	}
-	data := []byte("hello world")
-	encrypted := RsaEncrypt(data, "rsa_public.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
-
-	assert := internal.NewAssert(t, "TestRsaEncrypt")
-	assert.Equal(string(data), string(decrypted))
-}

datastructure/hashmap/hashmap.go

@@ -1,12 +1,13 @@
 // Copyright 2021 dudaodong@gmail.com. All rights reserved.
 // Use of this source code is governed by MIT license
 
-// Package datastructure implements some data structure. eg. list, linklist, stack, queue, tree, graph.
+// Package datastructure implements some data structure. hashmap structure.
 package datastructure
 
 import (
 	"fmt"
 	"hash/fnv"
+	"reflect"
 )
 
 var defaultMapCapacity uint64 = 1 << 10
@@ -17,7 +18,7 @@ type mapNode struct {
 	next  *mapNode
 }
 
-//HashMap implements a hash map
+// HashMap implements a hash map
 type HashMap struct {
 	capacity uint64
 	size     uint64
@@ -45,13 +46,24 @@ func NewHashMapWithCapacity(size, capacity uint64) *HashMap {
 func (hm *HashMap) Get(key any) any {
 	hashValue := hm.hash(key)
 	node := hm.table[hashValue]
-	if node != nil {
-		return node.value
+	for node != nil {
+		if reflect.DeepEqual(node.key, key) {
+			return node.value
+		}
+		node = node.next
 	}
-
 	return nil
 }
 
+// GetOrDefault return the value of given key in hashmap, if not found return default value
+func (hm *HashMap) GetOrDefault(key any, defaultValue any) any {
+	value := hm.Get(key)
+	if value == nil {
+		return defaultValue
+	}
+	return value
+}
+
 // Put new key value in hashmap
 func (hm *HashMap) Put(key any, value any) {
 	hm.putValue(hm.hash(key), key, value)
@@ -90,7 +102,13 @@ func (hm *HashMap) Delete(key any) {
 // Contains checks if given key is in hashmap or not
 func (hm *HashMap) Contains(key any) bool {
 	node := hm.table[hm.hash(key)]
-	return node != nil
+	for node != nil {
+		if reflect.DeepEqual(node.key, key) {
+			return true
+		}
+		node = node.next
+	}
+	return false
 }
 
 // Iterate executes iteratee funcation for every key and value pair of hashmap (random order)

datastructure/hashmap/hashmap_test.go

@@ -32,6 +32,8 @@ func TestHashMap_Resize(t *testing.T) {
 }
 
 func TestHashMap_Delete(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestHashMap_Delete")
 
 	hm := NewHashMap()
@@ -44,6 +46,8 @@ func TestHashMap_Delete(t *testing.T) {
 }
 
 func TestHashMap_Contains(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestHashMap_Contains")
 
 	hm := NewHashMap()
@@ -54,6 +58,8 @@ func TestHashMap_Contains(t *testing.T) {
 }
 
 func TestHashMap_KeysValues(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestHashMap_KeysValues")
 
 	hm := NewHashMap()
@@ -64,8 +70,38 @@ func TestHashMap_KeysValues(t *testing.T) {
 
 	keys := hm.Keys()
 	values := hm.Values()
-	t.Log(keys, values)
 
 	assert.Equal(3, len(values))
 	assert.Equal(3, len(keys))
 }
+
+func TestHashMap_Keys(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestHashMap_Keys")
+
+	hm := NewHashMap()
+
+	hm.Put("a", 1)
+	hm.Put("b", 2)
+	hm.Put("c", 3)
+
+	keys := hm.Keys()
+
+	assert.Equal(3, len(keys))
+}
+
+func TestHashMap_GetOrDefault(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestHashMap_GetOrDefault")
+
+	hm := NewHashMap()
+
+	hm.Put("a", 1)
+	hm.Put("b", 2)
+	hm.Put("c", 3)
+
+	assert.Equal(1, hm.GetOrDefault("a", 5))
+	assert.Equal(5, hm.GetOrDefault("d", 5))
+}

datastructure/heap/maxheap.go

@@ -1,7 +1,7 @@
 // Copyright 2021 dudaodong@gmail.com. All rights reserved.
 // Use of this source code is governed by MIT license
 
-// Package datastructure implements some data structure. eg. list, linklist, stack, queue, tree, graph.
+// Package datastructure implements some data structure. MaxHeap is a binary max heap.
 package datastructure
 
 import (
@@ -146,9 +146,9 @@ func (h *MaxHeap[T]) PrintStructure() {
 	lastNum := powerTwo(level - 1)
 	lastLen := lastNum + (lastNum - 1)
 
-	heapTree := make([][]string, level, level)
+	heapTree := make([][]string, level)
 	for i := 0; i < level; i++ {
-		heapTree[i] = make([]string, lastLen, lastLen)
+		heapTree[i] = make([]string, lastLen)
 		for j := 0; j < lastLen; j++ {
 			heapTree[i][j] = ""
 		}
@@ -169,9 +169,9 @@ func (h *MaxHeap[T]) PrintStructure() {
 		for n := 0; n < lastLen; n++ {
 			val := heapTree[m][n]
 			if val == "" {
-				fmt.Printf(" ")
+				fmt.Print(" ")
 			} else {
-				fmt.Printf(val)
+				fmt.Print(val)
 			}
 		}
 		fmt.Println()

datastructure/heap/maxheap_test.go

@@ -21,6 +21,8 @@ func (c *intComparator) Compare(v1, v2 any) int {
 }
 
 func TestMaxHeap_BuildMaxHeap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMaxHeap_BuildMaxHeap")
 
 	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
@@ -30,11 +32,11 @@ func TestMaxHeap_BuildMaxHeap(t *testing.T) {
 	assert.Equal(expected, heap.data)
 
 	assert.Equal(12, heap.Size())
-
-	heap.PrintStructure()
 }
 
 func TestMaxHeap_Push(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMaxHeap_Push")
 
 	heap := NewMaxHeap[int](&intComparator{})
@@ -53,6 +55,8 @@ func TestMaxHeap_Push(t *testing.T) {
 }
 
 func TestMaxHeap_Pop(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMaxHeap_Pop")
 
 	heap := NewMaxHeap[int](&intComparator{})
@@ -72,6 +76,8 @@ func TestMaxHeap_Pop(t *testing.T) {
 }
 
 func TestMaxHeap_Peek(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMaxHeap_Peek")
 
 	heap := NewMaxHeap[int](&intComparator{})

datastructure/link/doublylink.go

@@ -1,13 +1,16 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure contains some data structure. Link structure contains SinglyLink and DoublyLink.
 package datastructure
 
 import (
-	"errors"
 	"fmt"
 
 	"github.com/duke-git/lancet/v2/datastructure"
 )
 
-// DoublyLink is a linked list. Whose node has a generic Value, Pre pointer points to a previous node of the link, Next pointer points to a next node of the link.
+// DoublyLink is a linked list. Whose node has a generic Value, Pre pointer points to a previous node of the dl, Next pointer points to a next node of the dl.
 type DoublyLink[T any] struct {
 	Head   *datastructure.LinkNode[T]
 	length int
@@ -19,30 +22,30 @@ func NewDoublyLink[T any]() *DoublyLink[T] {
 }
 
 // InsertAtHead insert value into doubly linklist at head index
-func (link *DoublyLink[T]) InsertAtHead(value T) {
+func (dl *DoublyLink[T]) InsertAtHead(value T) {
 	newNode := datastructure.NewLinkNode(value)
-	size := link.Size()
+	size := dl.Size()
 
 	if size == 0 {
-		link.Head = newNode
-		link.length++
+		dl.Head = newNode
+		dl.length++
 		return
 	}
 
-	newNode.Next = link.Head
+	newNode.Next = dl.Head
 	newNode.Pre = nil
 
-	link.Head.Pre = newNode
-	link.Head = newNode
+	dl.Head.Pre = newNode
+	dl.Head = newNode
 
-	link.length++
+	dl.length++
 }
 
 // InsertAtTail insert value into doubly linklist at tail index
-func (link *DoublyLink[T]) InsertAtTail(value T) {
-	current := link.Head
+func (dl *DoublyLink[T]) InsertAtTail(value T) {
+	current := dl.Head
 	if current == nil {
-		link.InsertAtHead(value)
+		dl.InsertAtHead(value)
 		return
 	}
 
@@ -55,28 +58,29 @@ func (link *DoublyLink[T]) InsertAtTail(value T) {
 	newNode.Pre = current
 	current.Next = newNode
 
-	link.length++
+	dl.length++
 }
 
 // InsertAt insert value into doubly linklist at index
-func (link *DoublyLink[T]) InsertAt(index int, value T) error {
-	size := link.length
+// param `index` should between [0, length], if index do not meet the conditions, do nothing
+func (dl *DoublyLink[T]) InsertAt(index int, value T) {
+	size := dl.length
 	if index < 0 || index > size {
-		return errors.New("param index should between 0 and the length of doubly link.")
+		return
 	}
 
 	if index == 0 {
-		link.InsertAtHead(value)
-		return nil
+		dl.InsertAtHead(value)
+		return
 	}
 
 	if index == size {
-		link.InsertAtTail(value)
-		return nil
+		dl.InsertAtTail(value)
+		return
 	}
 
 	i := 0
-	current := link.Head
+	current := dl.Head
 
 	for current != nil {
 		if i == index-1 {
@@ -85,38 +89,36 @@ func (link *DoublyLink[T]) InsertAt(index int, value T) error {
 			newNode.Pre = current
 
 			current.Next = newNode
-			link.length++
+			dl.length++
 
-			return nil
+			return
 		}
 		i++
 		current = current.Next
 	}
-
-	return errors.New("doubly link list no exist")
 }
 
 // DeleteAtHead delete value in doubly linklist at head index
-func (link *DoublyLink[T]) DeleteAtHead() error {
-	if link.Head == nil {
-		return errors.New("doubly link list no exist")
+func (dl *DoublyLink[T]) DeleteAtHead() {
+	if dl.Head == nil {
+		return
 	}
-	current := link.Head
-	link.Head = current.Next
-	link.Head.Pre = nil
-	link.length--
 
-	return nil
+	current := dl.Head
+	dl.Head = current.Next
+	dl.Head.Pre = nil
+	dl.length--
 }
 
-// DeleteAtTail delete value in doubly linklist at tail index
-func (link *DoublyLink[T]) DeleteAtTail() error {
-	if link.Head == nil {
-		return errors.New("doubly link list no exist")
+// DeleteAtTail delete value in doubly linklist at tail
+func (dl *DoublyLink[T]) DeleteAtTail() {
+	if dl.Head == nil {
+		return
 	}
-	current := link.Head
+
+	current := dl.Head
 	if current.Next == nil {
-		return link.DeleteAtHead()
+		dl.DeleteAtHead()
 	}
 
 	for current.Next.Next != nil {
@@ -124,45 +126,44 @@ func (link *DoublyLink[T]) DeleteAtTail() error {
 	}
 
 	current.Next = nil
-	link.length--
-	return nil
+	dl.length--
 }
 
 // DeleteAt delete value in doubly linklist at index
-func (link *DoublyLink[T]) DeleteAt(index int) error {
-	if link.Head == nil {
-		return errors.New("doubly link list no exist")
+// param `index` should be [0, len(DoublyLink)-1]
+func (dl *DoublyLink[T]) DeleteAt(index int) {
+	if dl.Head == nil {
+		return
 	}
-	current := link.Head
+
+	current := dl.Head
 	if current.Next == nil || index == 0 {
-		return link.DeleteAtHead()
+		dl.DeleteAtHead()
 	}
 
-	if index == link.length-1 {
-		return link.DeleteAtTail()
+	if index == dl.length-1 {
+		dl.DeleteAtTail()
 	}
 
-	if index < 0 || index > link.length-1 {
-		return errors.New("param index should between 0 and link size -1.")
+	if index < 0 || index > dl.length-1 {
+		return
 	}
 
 	i := 0
 	for current != nil {
 		if i == index-1 {
 			current.Next = current.Next.Next
-			link.length--
-			return nil
+			dl.length--
+			return
 		}
 		i++
 		current = current.Next
 	}
-
-	return errors.New("delete error")
 }
 
 // Reverse the linked list
-func (link *DoublyLink[T]) Reverse() {
-	current := link.Head
+func (dl *DoublyLink[T]) Reverse() {
+	current := dl.Head
 	var temp *datastructure.LinkNode[T]
 
 	for current != nil {
@@ -173,20 +174,20 @@ func (link *DoublyLink[T]) Reverse() {
 	}
 
 	if temp != nil {
-		link.Head = temp.Pre
+		dl.Head = temp.Pre
 	}
 }
 
 // GetMiddleNode return node at middle index of linked list
-func (link *DoublyLink[T]) GetMiddleNode() *datastructure.LinkNode[T] {
-	if link.Head == nil {
+func (dl *DoublyLink[T]) GetMiddleNode() *datastructure.LinkNode[T] {
+	if dl.Head == nil {
 		return nil
 	}
-	if link.Head.Next == nil {
-		return link.Head
+	if dl.Head.Next == nil {
+		return dl.Head
 	}
-	fast := link.Head
-	slow := link.Head
+	fast := dl.Head
+	slow := dl.Head
 
 	for fast != nil {
 		fast = fast.Next
@@ -202,14 +203,14 @@ func (link *DoublyLink[T]) GetMiddleNode() *datastructure.LinkNode[T] {
 }
 
 // Size return the count of doubly linked list
-func (link *DoublyLink[T]) Size() int {
-	return link.length
+func (dl *DoublyLink[T]) Size() int {
+	return dl.length
 }
 
 // Values return slice of all doubly linklist node value
-func (link *DoublyLink[T]) Values() []T {
+func (dl *DoublyLink[T]) Values() []T {
 	result := []T{}
-	current := link.Head
+	current := dl.Head
 	for current != nil {
 		result = append(result, current.Value)
 		current = current.Next
@@ -218,8 +219,8 @@ func (link *DoublyLink[T]) Values() []T {
 }
 
 // Print all nodes info of a linked list
-func (link *DoublyLink[T]) Print() {
-	current := link.Head
+func (dl *DoublyLink[T]) Print() {
+	current := dl.Head
 	info := "[ "
 	for current != nil {
 		info += fmt.Sprintf("%+v, ", current)
@@ -229,13 +230,13 @@ func (link *DoublyLink[T]) Print() {
 	fmt.Println(info)
 }
 
-// IsEmpty checks if link is empty or not
-func (link *DoublyLink[T]) IsEmpty() bool {
-	return link.length == 0
+// IsEmpty checks if dl is empty or not
+func (dl *DoublyLink[T]) IsEmpty() bool {
+	return dl.length == 0
 }
 
 // Clear all nodes in doubly linklist
-func (link *DoublyLink[T]) Clear() {
-	link.Head = nil
-	link.length = 0
+func (dl *DoublyLink[T]) Clear() {
+	dl.Head = nil
+	dl.length = 0
 }

datastructure/link/doublylink_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestDoublyLink_InsertAtFirst(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_InsertAtFirst")
 
 	link := NewDoublyLink[int]()
@@ -22,6 +24,8 @@ func TestDoublyLink_InsertAtFirst(t *testing.T) {
 }
 
 func TestDoublyLink_InsertAtTail(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_InsertAtTail")
 
 	link := NewDoublyLink[int]()
@@ -37,33 +41,30 @@ func TestDoublyLink_InsertAtTail(t *testing.T) {
 }
 
 func TestDoublyLink_InsertAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_InsertAt")
 
 	link := NewDoublyLink[int]()
-
-	err := link.InsertAt(1, 1)
-	assert.IsNotNil(err)
-
+	link.InsertAt(1, 1) //do nothing
 	link.InsertAt(0, 1)
 	link.InsertAt(1, 2)
 	link.InsertAt(2, 4)
 	link.InsertAt(2, 3)
 
-	link.Print()
-
 	expected := []int{1, 2, 3, 4}
 	values := link.Values()
 
 	assert.Equal(expected, values)
-
 }
 
 func TestDoublyLink_DeleteAtHead(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAtHead")
 
 	link := NewDoublyLink[int]()
-	err := link.DeleteAtHead()
-	assert.IsNotNil(err)
+	link.DeleteAtHead()
 
 	link.InsertAtTail(1)
 	link.InsertAtTail(2)
@@ -71,7 +72,6 @@ func TestDoublyLink_DeleteAtHead(t *testing.T) {
 	link.InsertAtTail(4)
 
 	link.DeleteAtHead()
-	link.Print()
 
 	expected := []int{2, 3, 4}
 	values := link.Values()
@@ -80,11 +80,12 @@ func TestDoublyLink_DeleteAtHead(t *testing.T) {
 }
 
 func TestDoublyLink_DeleteAtTail(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAtTail")
 
 	link := NewDoublyLink[int]()
-	err := link.DeleteAtTail()
-	assert.IsNotNil(err)
+	link.DeleteAtTail()
 
 	link.InsertAtTail(1)
 	link.InsertAtTail(2)
@@ -92,7 +93,6 @@ func TestDoublyLink_DeleteAtTail(t *testing.T) {
 	link.InsertAtTail(4)
 
 	link.DeleteAtTail()
-	link.Print()
 
 	expected := []int{1, 2, 3}
 	values := link.Values()
@@ -101,11 +101,12 @@ func TestDoublyLink_DeleteAtTail(t *testing.T) {
 }
 
 func TestDoublyLink_DeleteAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAt")
 
 	link := NewDoublyLink[int]()
-	err := link.DeleteAt(0)
-	assert.IsNotNil(err)
+	link.DeleteAt(0)
 
 	link.InsertAtTail(1)
 	link.InsertAtTail(2)
@@ -113,11 +114,7 @@ func TestDoublyLink_DeleteAt(t *testing.T) {
 	link.InsertAtTail(4)
 	link.InsertAtTail(5)
 
-	err = link.DeleteAt(5)
-	assert.IsNotNil(err)
-
-	err = link.DeleteAt(0)
-	assert.IsNil(err)
+	link.DeleteAt(0)
 	assert.Equal([]int{2, 3, 4, 5}, link.Values())
 
 	link.DeleteAt(3)
@@ -129,6 +126,8 @@ func TestDoublyLink_DeleteAt(t *testing.T) {
 }
 
 func TestDoublyLink_Reverse(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_Reverse")
 
 	link := NewDoublyLink[int]()
@@ -143,6 +142,8 @@ func TestDoublyLink_Reverse(t *testing.T) {
 }
 
 func TestDoublyLink_GetMiddleNode(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_GetMiddleNode")
 
 	link := NewDoublyLink[int]()
@@ -162,10 +163,11 @@ func TestDoublyLink_GetMiddleNode(t *testing.T) {
 }
 
 func TestDoublyLink_Clear(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_Clear")
 
 	link := NewDoublyLink[int]()
-
 	assert.Equal(true, link.IsEmpty())
 	assert.Equal(0, link.Size())
 

datastructure/link/singlylink.go

@@ -1,14 +1,17 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure contains some data structure. Link structure contains SinglyLink and DoublyLink.
 package datastructure
 
 import (
-	"errors"
 	"fmt"
 	"reflect"
 
 	"github.com/duke-git/lancet/v2/datastructure"
 )
 
-// SinglyLink is a linked list. Whose node has a Value generics and Next pointer points to a next node of the link.
+// SinglyLink is a linked list. Whose node has a Value generics and Next pointer points to a next node of the sl.
 type SinglyLink[T any] struct {
 	Head   *datastructure.LinkNode[T]
 	length int
@@ -20,18 +23,18 @@ func NewSinglyLink[T any]() *SinglyLink[T] {
 }
 
 // InsertAtHead insert value into singly linklist at head index
-func (link *SinglyLink[T]) InsertAtHead(value T) {
+func (sl *SinglyLink[T]) InsertAtHead(value T) {
 	newNode := datastructure.NewLinkNode(value)
-	newNode.Next = link.Head
-	link.Head = newNode
-	link.length++
+	newNode.Next = sl.Head
+	sl.Head = newNode
+	sl.length++
 }
 
 // InsertAtTail insert value into singly linklist at tail index
-func (link *SinglyLink[T]) InsertAtTail(value T) {
-	current := link.Head
+func (sl *SinglyLink[T]) InsertAtTail(value T) {
+	current := sl.Head
 	if current == nil {
-		link.InsertAtHead(value)
+		sl.InsertAtHead(value)
 		return
 	}
 
@@ -43,65 +46,63 @@ func (link *SinglyLink[T]) InsertAtTail(value T) {
 	newNode.Next = nil
 	current.Next = newNode
 
-	link.length++
+	sl.length++
 }
 
 // InsertAt insert value into singly linklist at index
-func (link *SinglyLink[T]) InsertAt(index int, value T) error {
-	size := link.length
+// param `index` should between [0, len(SinglyLink)], if index do not meet the conditions, do nothing
+func (sl *SinglyLink[T]) InsertAt(index int, value T) {
+	size := sl.length
 	if index < 0 || index > size {
-		return errors.New("param index should between 0 and the length of singly link.")
+		return
 	}
 
 	if index == 0 {
-		link.InsertAtHead(value)
-		return nil
+		sl.InsertAtHead(value)
+		return
 	}
 
 	if index == size {
-		link.InsertAtTail(value)
-		return nil
+		sl.InsertAtTail(value)
+		return
 	}
 
 	i := 0
-	current := link.Head
+	current := sl.Head
 
 	for current != nil {
 		if i == index-1 {
 			newNode := datastructure.NewLinkNode(value)
 			newNode.Next = current.Next
 			current.Next = newNode
-			link.length++
-
-			return nil
+			sl.length++
+			return
 		}
 		i++
 		current = current.Next
 	}
-
-	return errors.New("singly link list no exist")
 }
 
 // DeleteAtHead delete value in singly linklist at head index
-func (link *SinglyLink[T]) DeleteAtHead() error {
-	if link.Head == nil {
-		return errors.New("singly link list no exist")
+func (sl *SinglyLink[T]) DeleteAtHead() {
+	if sl.Head == nil {
+		return
 	}
-	current := link.Head
-	link.Head = current.Next
-	link.length--
 
-	return nil
+	current := sl.Head
+	sl.Head = current.Next
+	sl.length--
 }
 
-// DeleteAtTail delete value in singly linklist at tail index
-func (link *SinglyLink[T]) DeleteAtTail() error {
-	if link.Head == nil {
-		return errors.New("singly link list no exist")
+// DeleteAtTail delete value in singly linklist at tail
+func (sl *SinglyLink[T]) DeleteAtTail() {
+	if sl.Head == nil {
+		return
 	}
-	current := link.Head
+
+	current := sl.Head
 	if current.Next == nil {
-		return link.DeleteAtHead()
+		sl.DeleteAtHead()
 	}
 
 	for current.Next.Next != nil {
@@ -109,68 +110,66 @@ func (link *SinglyLink[T]) DeleteAtTail() error {
 	}
 
 	current.Next = nil
-	link.length--
-	return nil
+	sl.length--
 }
 
 // DeleteAt delete value in singly linklist at index
-func (link *SinglyLink[T]) DeleteAt(index int) error {
-	if link.Head == nil {
-		return errors.New("singly link list no exist")
+// param `index` should be [0, len(SinglyLink)-1]
+func (sl *SinglyLink[T]) DeleteAt(index int) {
+	if sl.Head == nil {
+		return
 	}
-	current := link.Head
+	current := sl.Head
 	if current.Next == nil || index == 0 {
-		return link.DeleteAtHead()
+		sl.DeleteAtHead()
 	}
 
-	if index == link.length-1 {
-		return link.DeleteAtTail()
+	if index == sl.length-1 {
+		sl.DeleteAtTail()
 	}
 
-	if index < 0 || index > link.length-1 {
-		return errors.New("param index should between 0 and link size -1.")
+	if index < 0 || index > sl.length-1 {
+		return
 	}
 
 	i := 0
 	for current != nil {
 		if i == index-1 {
 			current.Next = current.Next.Next
-			link.length--
-			return nil
+			sl.length--
+			return
 		}
 		i++
 		current = current.Next
 	}
-
-	return errors.New("delete error")
 }
 
 // DeleteValue delete value in singly linklist
-func (link *SinglyLink[T]) DeleteValue(value T) {
-	if link.Head == nil {
+func (sl *SinglyLink[T]) DeleteValue(value T) {
+	if sl.Head == nil {
 		return
 	}
 	dummyHead := datastructure.NewLinkNode(value)
-	dummyHead.Next = link.Head
+	dummyHead.Next = sl.Head
 	current := dummyHead
 
 	for current.Next != nil {
 		if reflect.DeepEqual(current.Next.Value, value) {
 			current.Next = current.Next.Next
-			link.length--
+			sl.length--
 		} else {
 			current = current.Next
 		}
 	}
 
-	link.Head = dummyHead.Next
+	sl.Head = dummyHead.Next
 }
 
 // Reverse the linked list
-func (link *SinglyLink[T]) Reverse() {
+func (sl *SinglyLink[T]) Reverse() {
 	var pre, next *datastructure.LinkNode[T]
 
-	current := link.Head
+	current := sl.Head
 
 	for current != nil {
 		next = current.Next
@@ -179,19 +178,19 @@ func (link *SinglyLink[T]) Reverse() {
 		current = next
 	}
 
-	link.Head = pre
+	sl.Head = pre
 }
 
 // GetMiddleNode return node at middle index of linked list
-func (link *SinglyLink[T]) GetMiddleNode() *datastructure.LinkNode[T] {
-	if link.Head == nil {
+func (sl *SinglyLink[T]) GetMiddleNode() *datastructure.LinkNode[T] {
+	if sl.Head == nil {
 		return nil
 	}
-	if link.Head.Next == nil {
-		return link.Head
+	if sl.Head.Next == nil {
+		return sl.Head
 	}
-	fast := link.Head
-	slow := link.Head
+	fast := sl.Head
+	slow := sl.Head
 
 	for fast != nil {
 		fast = fast.Next
@@ -207,14 +206,14 @@ func (link *SinglyLink[T]) GetMiddleNode() *datastructure.LinkNode[T] {
 }
 
 // Size return the count of singly linked list
-func (link *SinglyLink[T]) Size() int {
-	return link.length
+func (sl *SinglyLink[T]) Size() int {
+	return sl.length
 }
 
 // Values return slice of all singly linklist node value
-func (link *SinglyLink[T]) Values() []T {
+func (sl *SinglyLink[T]) Values() []T {
 	result := []T{}
-	current := link.Head
+	current := sl.Head
 	for current != nil {
 		result = append(result, current.Value)
 		current = current.Next
@@ -222,20 +221,20 @@ func (link *SinglyLink[T]) Values() []T {
 	return result
 }
 
-// IsEmpty checks if link is empty or not
-func (link *SinglyLink[T]) IsEmpty() bool {
-	return link.length == 0
+// IsEmpty checks if sl is empty or not
+func (sl *SinglyLink[T]) IsEmpty() bool {
+	return sl.length == 0
 }
 
 // Clear all the node in singly linklist
-func (link *SinglyLink[T]) Clear() {
-	link.Head = nil
-	link.length = 0
+func (sl *SinglyLink[T]) Clear() {
+	sl.Head = nil
+	sl.length = 0
 }
 
 // Print all nodes info of a linked list
-func (link *SinglyLink[T]) Print() {
-	current := link.Head
+func (sl *SinglyLink[T]) Print() {
+	current := sl.Head
 	info := "[ "
 	for current != nil {
 		info += fmt.Sprintf("%+v, ", current)

datastructure/link/singlylink_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestSinglyLink_InsertAtFirst(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_InsertAtFirst")
 
 	link := NewSinglyLink[int]()
@@ -22,6 +24,8 @@ func TestSinglyLink_InsertAtFirst(t *testing.T) {
 }
 
 func TestSinglyLink_InsertAtTail(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_InsertAtTail")
 
 	link := NewSinglyLink[int]()
@@ -37,29 +41,18 @@ func TestSinglyLink_InsertAtTail(t *testing.T) {
 }
 
 func TestSinglyLink_InsertAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_InsertAt")
 
 	link := NewSinglyLink[int]()
 
-	err := link.InsertAt(1, 1)
-	assert.IsNotNil(err)
+	link.InsertAt(1, 1) //do nothing
 
-	err = link.InsertAt(0, 1)
-	if err != nil {
-		t.FailNow()
-	}
-	err = link.InsertAt(1, 2)
-	if err != nil {
-		t.FailNow()
-	}
-	err = link.InsertAt(2, 4)
-	if err != nil {
-		t.FailNow()
-	}
-	err = link.InsertAt(2, 3)
-	if err != nil {
-		t.FailNow()
-	}
+	link.InsertAt(0, 1)
+	link.InsertAt(1, 2)
+	link.InsertAt(2, 4)
+	link.InsertAt(2, 3)
 
 	link.Print()
 
@@ -70,11 +63,13 @@ func TestSinglyLink_InsertAt(t *testing.T) {
 }
 
 func TestSinglyLink_DeleteAtHead(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAtHead")
 
 	link := NewSinglyLink[int]()
-	err := link.DeleteAtHead()
-	assert.IsNotNil(err)
+
+	link.DeleteAtHead()
 
 	link.InsertAtTail(1)
 	link.InsertAtTail(2)
@@ -91,19 +86,17 @@ func TestSinglyLink_DeleteAtHead(t *testing.T) {
 }
 
 func TestSinglyLink_DeleteAtTail(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAtTail")
 
 	link := NewSinglyLink[int]()
-	err := link.DeleteAtTail()
-	assert.IsNotNil(err)
-
 	link.InsertAtTail(1)
 	link.InsertAtTail(2)
 	link.InsertAtTail(3)
 	link.InsertAtTail(4)
 
 	link.DeleteAtTail()
-	link.Print()
 
 	expected := []int{1, 2, 3}
 	values := link.Values()
@@ -112,10 +105,11 @@ func TestSinglyLink_DeleteAtTail(t *testing.T) {
 }
 
 func TestSinglyLink_DeleteValue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_DeleteValue")
 
 	link := NewSinglyLink[int]()
-
 	link.InsertAtTail(1)
 	link.InsertAtTail(2)
 	link.InsertAtTail(2)
@@ -130,23 +124,18 @@ func TestSinglyLink_DeleteValue(t *testing.T) {
 }
 
 func TestSinglyLink_DeleteAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAt")
 
 	link := NewSinglyLink[int]()
-	err := link.DeleteAt(0)
-	assert.IsNotNil(err)
-
 	link.InsertAtTail(1)
 	link.InsertAtTail(2)
 	link.InsertAtTail(3)
 	link.InsertAtTail(4)
 	link.InsertAtTail(5)
 
-	err = link.DeleteAt(5)
-	assert.IsNotNil(err)
-
-	err = link.DeleteAt(0)
-	assert.IsNil(err)
+	link.DeleteAt(0)
 	assert.Equal([]int{2, 3, 4, 5}, link.Values())
 
 	link.DeleteAt(3)
@@ -158,6 +147,8 @@ func TestSinglyLink_DeleteAt(t *testing.T) {
 }
 
 func TestSinglyLink_Reverse(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_Reverse")
 
 	link := NewSinglyLink[int]()
@@ -167,11 +158,12 @@ func TestSinglyLink_Reverse(t *testing.T) {
 	link.InsertAtTail(4)
 
 	link.Reverse()
-	link.Print()
 	assert.Equal([]int{4, 3, 2, 1}, link.Values())
 }
 
 func TestSinglyLink_GetMiddleNode(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_GetMiddleNode")
 
 	link := NewSinglyLink[int]()
@@ -186,6 +178,7 @@ func TestSinglyLink_GetMiddleNode(t *testing.T) {
 	link.InsertAtTail(5)
 	link.InsertAtTail(6)
 	link.InsertAtTail(7)
+
 	middle2 := link.GetMiddleNode()
 	assert.Equal(4, middle2.Value)
 }

datastructure/list/copyonwritelist.go

@@ -0,0 +1,350 @@
+package datastructure
+
+import (
+	"reflect"
+	"sort"
+	"sync"
+)
+
+type CopyOnWriteList[T any] struct {
+	data []T
+	lock sync.Locker
+}
+
+// NewCopyOnWriteList Creates an empty list.
+func NewCopyOnWriteList[T any](data []T) *CopyOnWriteList[T] {
+	return &CopyOnWriteList[T]{data: data, lock: &sync.RWMutex{}}
+}
+
+func (c *CopyOnWriteList[T]) getList() []T {
+	return c.data
+}
+func (c *CopyOnWriteList[T]) setList(data []T) {
+	c.data = data
+}
+
+// Size returns the number of elements in this list.
+func (c *CopyOnWriteList[T]) Size() int {
+	return len(c.getList())
+}
+
+// IsEmpty returns true if this list contains no elements.
+func (c *CopyOnWriteList[T]) IsEmpty() bool {
+	return c.Size() == 0
+}
+
+// Contain returns true if this list contains the specified element.
+func (c *CopyOnWriteList[T]) Contain(e T) bool {
+	list := c.getList()
+	return indexOf(e, list, 0, c.Size()) >= 0
+}
+
+// ValueOf returns the index of the first occurrence of the specified element in this list, or null if this list does not contain the element.
+func (c *CopyOnWriteList[T]) ValueOf(index int) (*T, bool) {
+	list := c.getList()
+	if index < 0 || index >= len(c.data) {
+		return nil, false
+	}
+	return get(list, index), true
+}
+
+// IndexOf returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
+func (c *CopyOnWriteList[T]) IndexOf(e T) int {
+	list := c.getList()
+	return indexOf(e, list, 0, c.Size())
+}
+
+// indexOf returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
+// start the start position of the search (inclusive)
+// end the end position of the search (exclusive)
+func indexOf[T any](o T, e []T, start int, end int) int {
+	if start >= end {
+		return -1
+	}
+	for i := start; i < end; i++ {
+		if reflect.DeepEqual(e[i], o) {
+			return i
+		}
+	}
+	return -1
+}
+
+// LastIndexOf returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
+func (c *CopyOnWriteList[T]) LastIndexOf(e T) int {
+	list := c.getList()
+	return lastIndexOf(e, list, 0, c.Size())
+}
+
+// lastIndexOf returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
+// start the start position of the search (inclusive)
+// end the end position of the search (exclusive)
+func lastIndexOf[T any](o T, e []T, start int, end int) int {
+	if start >= end {
+		return -1
+	}
+	for i := end - 1; i >= start; i-- {
+		if reflect.DeepEqual(e[i], o) {
+			return i
+		}
+	}
+	return -1
+}
+
+// get returns the element at the specified position in this list.
+func get[T any](o []T, index int) *T {
+	return &o[index]
+}
+
+// Get returns the element at the specified position in this list.
+func (c *CopyOnWriteList[T]) Get(index int) *T {
+	list := c.getList()
+	if index < 0 || index >= len(list) {
+		return nil
+	}
+	return get(list, index)
+}
+
+func (c *CopyOnWriteList[T]) set(index int, e T) (oldValue *T) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+	list := c.getList()
+	oldValue = get(list, index)
+
+	if reflect.DeepEqual(oldValue, e) {
+		c.setList(list)
+	} else {
+		newList := make([]T, len(list))
+		copy(newList, list)
+		newList[index] = e
+		c.setList(newList)
+	}
+	return
+}
+
+// Set replaces the element at the specified position in this list with the specified element.
+func (c *CopyOnWriteList[T]) Set(index int, e T) (oldValue *T, ok bool) {
+	list := c.getList()
+	if index < 0 || index >= len(list) {
+		return oldValue, false
+	}
+	return c.set(index, e), true
+}
+
+// Add appends the specified element to the end of this list.
+func (c *CopyOnWriteList[T]) Add(e T) bool {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	newList := make([]T, len(list)+1)
+	copy(newList, list)
+	newList[len(list)] = e
+	c.setList(newList)
+	return true
+}
+
+// AddAll appends all the elements in the specified collection to the end of this list
+func (c *CopyOnWriteList[T]) AddAll(e []T) bool {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	newList := make([]T, len(list)+len(e))
+	copy(newList, list)
+	copy(newList[len(list):], e)
+	c.setList(newList)
+	return true
+}
+
+// AddByIndex inserts the specified element at the specified position in this list.
+func (c *CopyOnWriteList[T]) AddByIndex(index int, e T) bool {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+	if index < 0 || index > length {
+		return false
+	}
+	var newList []T
+	var numMove = length - index
+	if numMove == 0 {
+		newList = make([]T, length+1)
+		copy(newList, list)
+	} else {
+		newList = make([]T, length+1)
+		copy(newList, list[:index])
+		copy(newList[index+1:], list[index:])
+	}
+	newList[index] = e
+	c.setList(newList)
+	return true
+}
+
+// delete removes the element at the specified position in this list.
+func (c *CopyOnWriteList[T]) delete(index int) *T {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+
+	oldValue := get(list, index)
+	numMove := length - index - 1
+	var newList []T
+	if numMove == 0 {
+		newList = make([]T, length-1)
+		copy(newList, list[:index])
+	} else {
+		newList = make([]T, length-1)
+		copy(newList, list[:index])
+		copy(newList[index:], list[index+1:])
+	}
+
+	c.setList(newList)
+	return oldValue
+}
+
+// DeleteAt removes the element at the specified position in this list.
+func (c *CopyOnWriteList[T]) DeleteAt(index int) (*T, bool) {
+	list := c.getList()
+	if index < 0 || index >= len(list) {
+		return nil, false
+	}
+	return c.delete(index), true
+}
+
+// DeleteBy removes the first occurrence of the specified element from this list, if it is present.
+func (c *CopyOnWriteList[T]) DeleteBy(o T) (*T, bool) {
+	list := c.getList()
+	index := indexOf(o, list, 0, len(list))
+	if index == -1 {
+		return nil, false
+	}
+	return c.delete(index), true
+}
+
+// DeleteRange removes from this list all the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
+// left close and right open
+func (c *CopyOnWriteList[T]) DeleteRange(start int, end int) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+	if start < 0 || end > length || start > end {
+		return
+	}
+	var newList []T
+	numMove := length - end
+	if numMove == 0 {
+		newList = make([]T, length-(end-start))
+		copy(newList, list[:start])
+	} else {
+		newList = make([]T, length-(end-start))
+		copy(newList, list[:start])
+		copy(newList[start:], list[end:])
+	}
+	c.setList(newList)
+}
+
+// DeleteIf removes all the elements of this collection that satisfy the given predicate.
+func (c *CopyOnWriteList[T]) DeleteIf(f func(T) bool) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+	var newList []T
+	for i := 0; i < length; i++ {
+		if !f(list[i]) {
+			newList = append(newList, list[i])
+		}
+	}
+	c.setList(newList)
+}
+
+// Equal returns true if the specified object is equal to this list.
+func (c *CopyOnWriteList[T]) Equal(other *[]T) bool {
+	if other == nil {
+		return false
+	}
+	if c.Size() != len(*other) {
+		return false
+	}
+	list := c.getList()
+	otherList := NewCopyOnWriteList(*other).getList()
+	for i := 0; i < len(list); i++ {
+		if !reflect.DeepEqual(list[i], otherList[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// Clear removes all the elements from this list.
+func (c *CopyOnWriteList[T]) Clear() {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	list = make([]T, 0)
+	c.setList(list)
+}
+
+// Merge a tow list to one, change the list
+func (c *CopyOnWriteList[T]) Merge(other []T) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	list = append(list, other...)
+	c.setList(list)
+}
+
+// ForEach performs the given action for each element of the Iterable until all elements have been processed
+// or the action throws an exception.
+func (c *CopyOnWriteList[T]) ForEach(f func(T)) {
+	list := c.getList()
+	for i := 0; i < len(list); i++ {
+		f(list[i])
+	}
+
+}
+
+// Sort sorts this list according to the order induced by the specified Comparator.
+func (c *CopyOnWriteList[T]) Sort(compare func(o1 T, o2 T) bool) {
+	lock := c.lock
+	lock.Lock()
+	list := c.getList()
+
+	sort.Slice(list, func(i, j int) bool {
+		return compare(list[i], list[j])
+	})
+
+	c.setList(list)
+}
+
+func (c *CopyOnWriteList[T]) SubList(start int, end int) (newList []T) {
+	lock := c.lock
+	lock.Lock()
+	list := c.getList()
+	length := len(list)
+	defer lock.Unlock()
+	if start < 0 || end > length || start > end {
+		return []T{}
+	}
+	newList = make([]T, end-start)
+	copy(newList, list[start:end])
+	c.setList(newList)
+	return
+}

datastructure/list/copyonwritelist_test.go

@@ -0,0 +1,235 @@
+package datastructure
+
+import (
+	"github.com/duke-git/lancet/v2/internal"
+	"testing"
+)
+
+func TestCopyOnWriteList_ValueOf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+
+	assert := internal.NewAssert(t, "CopyOnWriteList_IndexOf")
+	of, ok := list.ValueOf(3)
+	assert.Equal(4, *of)
+	assert.Equal(true, ok)
+
+	_, ok = list.ValueOf(6)
+	assert.Equal(false, ok)
+}
+
+func TestCopyOnWriteList_Contain(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Contains")
+	assert.Equal(true, list.Contain(3))
+}
+
+func TestCopyOnWriteList_IsEmpty(t *testing.T) {
+	list := NewCopyOnWriteList([]int{})
+	assert := internal.NewAssert(t, "CopyOnWriteList_IsEmpty")
+	assert.Equal(true, list.IsEmpty())
+}
+
+func TestCopyOnWriteList_Size(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_size")
+	assert.Equal(5, list.Size())
+}
+
+func TestCopyOnWriteList_GetList(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_GetList")
+	assert.Equal([]int{1, 2, 3, 4, 5}, list.getList())
+}
+
+func TestCopyOnWriteList_Get(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Get")
+	i := list.Get(2)
+	assert.Equal(3, *i)
+}
+
+func TestCopyOnWriteList_Set(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Set")
+	list.Set(2, 6)
+	assert.Equal(6, list.getList()[2])
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.Set(0, 6)
+	assert.Equal(6, list.getList()[0])
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.Set(0, 1)
+	assert.Equal(1, list.getList()[0])
+}
+
+func TestCopyOnWriteList_Add(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Add")
+	list.Add(6)
+	assert.Equal([]int{1, 2, 3, 4, 5, 6}, list.getList())
+}
+
+func TestCopyOnWriteList_AddAll(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_AddAll")
+	list.AddAll([]int{6, 7, 8})
+	assert.Equal([]int{1, 2, 3, 4, 5, 6, 7, 8}, list.getList())
+}
+
+func TestCopyOnWriteList_AddByIndex(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_AddByIndex")
+	list.AddByIndex(2, 6)
+	assert.Equal([]int{1, 2, 6, 3, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.AddByIndex(0, 6)
+	assert.Equal([]int{6, 1, 2, 3, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.AddByIndex(5, 6)
+	assert.Equal([]int{1, 2, 3, 4, 5, 6}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteAt2(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_RemoveByIndex")
+	list.DeleteAt(2)
+	assert.Equal([]int{1, 2, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.DeleteAt(4)
+	assert.Equal([]int{1, 2, 3, 4}, list.getList())
+}
+
+func TestCopyOnWriteList_RemoveByValue(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_RemoveByValue")
+	list.DeleteBy(3)
+	assert.Equal([]int{1, 2, 4, 5}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteRange(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_RemoveRange")
+	list.DeleteRange(1, 3)
+	assert.Equal([]int{1, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.DeleteRange(0, 5)
+	assert.Equal([]int{}, list.getList())
+}
+
+func TestCopyOnWriteList_LastIndexOf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3})
+	assert := internal.NewAssert(t, "CopyOnWriteList_LastIndexOf")
+	assert.Equal(5, list.LastIndexOf(3))
+}
+
+func TestCopyOnWriteList_DeleteAt(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3})
+	assert := internal.NewAssert(t, "CopyOnWriteList_DeleteAt")
+	list.DeleteAt(2)
+	assert.Equal([]int{1, 2, 4, 5, 3}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteBy(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3})
+	assert := internal.NewAssert(t, "CopyOnWriteList_DeleteBy")
+	list.DeleteBy(3)
+	assert.Equal([]int{1, 2, 4, 5, 3}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteIf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_DeleteIf")
+
+	list.DeleteIf(func(i int) bool {
+		return i%2 == 0
+	})
+
+	assert.Equal([]int{1, 3, 5, 3}, list.getList())
+}
+
+func TestCopyOnWriteList_Equal(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Equal")
+
+	assert.Equal(true, list.Equal(&[]int{1, 2, 3, 4, 5, 3, 6}))
+}
+
+func TestCopyOnWriteList_ForEach(t *testing.T) {
+	testList := make([]int, 0)
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_ForEach")
+
+	list.ForEach(func(i int) {
+		testList = append(testList, i)
+	})
+	assert.Equal([]int{1, 2, 3, 4, 5, 3, 6}, testList)
+
+	list.ForEach(func(i int) {
+		list.Add(i)
+	})
+	assert.Equal([]int{1, 2, 3, 4, 5, 3, 6, 1, 2, 3, 4, 5, 3, 6}, list.getList())
+}
+
+func TestCopyOnWriteList_Clear(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Clear")
+
+	list.Clear()
+	assert.Equal([]int{}, list.getList())
+}
+
+func TestCopyOnWriteList_Merge(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Merge")
+
+	list.Merge([]int{2, 4, 6, 8, 10})
+	assert.Equal([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10}, list.getList())
+
+}
+
+func TestCopyOnWriteList_Sort(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Sort")
+
+	list.Sort(func(i, j int) bool {
+		return i < j
+	})
+	assert.Equal([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, list.getList())
+}
+
+func TestCopyOnWriteList_IndexOf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	assert := internal.NewAssert(t, "CopyOnWriteList_IndexOf")
+
+	assert.Equal(0, list.IndexOf(1))
+	assert.Equal(9, list.IndexOf(10))
+	assert.Equal(-1, list.IndexOf(11))
+}
+
+func TestCopyOnWriteList_SubList(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+
+	assert := internal.NewAssert(t, "CopyOnWriteList_SubList")
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	subList := list.SubList(1, 3)
+	assert.Equal([]int{3, 5}, subList)
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	subList = list.SubList(1, 1)
+	assert.Equal([]int{}, subList)
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	assert.Equal(10, list.Size())
+	subList = list.SubList(1, 10)
+	assert.Equal([]int{3, 5, 7, 9, 2, 4, 6, 8, 10}, subList)
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	subList = list.SubList(11, 1)
+	assert.Equal([]int{}, subList)
+}

datastructure/list/list.go

@@ -1,24 +1,26 @@
 // Copyright 2021 dudaodong@gmail.com. All rights reserved.
 // Use of this source code is governed by MIT license
 
-// Package datastructure implements some data structure. eg. list, linklist, stack, queue, tree, graph.
+// Package datastructure contains some data structure. list is a linear table, implemented with slice.
 package datastructure
 
 import (
 	"reflect"
+
+	"github.com/duke-git/lancet/v2/iterator"
 )
 
-// List is a linear table, implemented with slice
+// List is a linear table, implemented with slice.
 type List[T any] struct {
 	data []T
 }
 
-// NewList return a pointer of List
+// NewList return a pointer of List.
 func NewList[T any](data []T) *List[T] {
 	return &List[T]{data: data}
 }
 
-// Data return list data
+// Data return list data.
 func (l *List[T]) Data() []T {
 	return l.data
 }
@@ -31,7 +33,7 @@ func (l *List[T]) ValueOf(index int) (*T, bool) {
 	return &l.data[index], true
 }
 
-// IndexOf returns the index of value. if not found return -1
+// IndexOf returns the index of value. if not found return -1.
 func (l *List[T]) IndexOf(value T) int {
 	index := -1
 	data := l.data
@@ -45,7 +47,7 @@ func (l *List[T]) IndexOf(value T) int {
 }
 
 // LastIndexOf returns the index of the last occurrence of the value in this list.
-// if not found return -1
+// if not found return -1.
 func (l *List[T]) LastIndexOf(value T) int {
 	index := -1
 	data := l.data
@@ -59,7 +61,7 @@ func (l *List[T]) LastIndexOf(value T) int {
 }
 
 // IndexOfFunc returns the first index satisfying f(v)
-// if not found return -1
+// if not found return -1.
 func (l *List[T]) IndexOfFunc(f func(T) bool) int {
 	index := -1
 	data := l.data
@@ -73,7 +75,7 @@ func (l *List[T]) IndexOfFunc(f func(T) bool) int {
 }
 
 // LastIndexOfFunc returns the index of the last occurrence of the value in this list satisfying f(data[i])
-// if not found return -1
+// if not found return -1.
 func (l *List[T]) LastIndexOfFunc(f func(T) bool) int {
 	index := -1
 	data := l.data
@@ -86,7 +88,7 @@ func (l *List[T]) LastIndexOfFunc(f func(T) bool) int {
 	return index
 }
 
-// Contain checks if the value in the list or not
+// Contain checks if the value in the list or not.
 func (l *List[T]) Contain(value T) bool {
 	data := l.data
 	for _, v := range data {
@@ -97,22 +99,22 @@ func (l *List[T]) Contain(value T) bool {
 	return false
 }
 
-// Push append value to the list data
+// Push append value to the list data.
 func (l *List[T]) Push(value T) {
 	l.data = append(l.data, value)
 }
 
-// InsertAtFirst insert value into list at first index
+// InsertAtFirst insert value into list at first index.
 func (l *List[T]) InsertAtFirst(value T) {
 	l.InsertAt(0, value)
 }
 
-// InsertAtLast insert value into list at last index
+// InsertAtLast insert value into list at last index.
 func (l *List[T]) InsertAtLast(value T) {
 	l.InsertAt(len(l.data), value)
 }
 
-// InsertAt insert value into list at index
+// InsertAt insert value into list at index.
 func (l *List[T]) InsertAt(index int, value T) {
 	data := l.data
 	size := len(data)
@@ -123,7 +125,7 @@ func (l *List[T]) InsertAt(index int, value T) {
 	l.data = append(data[:index], append([]T{value}, data[index:]...)...)
 }
 
-// PopFirst delete the first value of list and return it
+// PopFirst delete the first value of list and return it.
 func (l *List[T]) PopFirst() (*T, bool) {
 	if len(l.data) == 0 {
 		return nil, false
@@ -135,7 +137,7 @@ func (l *List[T]) PopFirst() (*T, bool) {
 	return &v, true
 }
 
-// PopLast delete the last value of list and return it
+// PopLast delete the last value of list and return it.
 func (l *List[T]) PopLast() (*T, bool) {
 	size := len(l.data)
 	if size == 0 {
@@ -148,7 +150,7 @@ func (l *List[T]) PopLast() (*T, bool) {
 	return &v, true
 }
 
-// DeleteAt delete the value of list at index
+// DeleteAt delete the value of list at index.
 func (l *List[T]) DeleteAt(index int) {
 	data := l.data
 	size := len(data)
@@ -156,7 +158,7 @@ func (l *List[T]) DeleteAt(index int) {
 		return
 	}
 	if index == size-1 {
-		data = append(data[:index])
+		data = data[:index]
 	} else {
 		data = append(data[:index], data[index+1:]...)
 	}
@@ -174,7 +176,7 @@ func (l *List[T]) DeleteIf(f func(T) bool) int {
 			continue
 		}
 		if index == size-1 {
-			data = append(data[:index])
+			data = data[:index]
 		} else {
 			data = append(data[:index], data[index+1:]...)
 			index--
@@ -199,7 +201,7 @@ func (l *List[T]) UpdateAt(index int, value T) {
 	l.data = append(data[:index], append([]T{value}, data[index+1:]...)...)
 }
 
-// Equal compare list to other list, use reflect.DeepEqual
+// Equal compare list to other list, use reflect.DeepEqual.
 func (l *List[T]) Equal(other *List[T]) bool {
 	if len(l.data) != len(other.data) {
 		return false
@@ -214,17 +216,17 @@ func (l *List[T]) Equal(other *List[T]) bool {
 	return true
 }
 
-// IsEmpty check if the list is empty or not
+// IsEmpty check if the list is empty or not.
 func (l *List[T]) IsEmpty() bool {
 	return len(l.data) == 0
 }
 
-// Clear the data of list
+// Clear the data of list.
 func (l *List[T]) Clear() {
-	l.data = make([]T, 0, 0)
+	l.data = make([]T, 0)
 }
 
-// Clone return a copy of list
+// Clone return a copy of list.
 func (l *List[T]) Clone() *List[T] {
 	cl := NewList(make([]T, len(l.data)))
 	copy(cl.data, l.data)
@@ -232,10 +234,10 @@ func (l *List[T]) Clone() *List[T] {
 	return cl
 }
 
-// Merge two list, return new list, don't change original list
+// Merge two list, return new list, don't change original list.
 func (l *List[T]) Merge(other *List[T]) *List[T] {
 	l1, l2 := len(l.data), len(other.data)
-	ml := NewList(make([]T, l1+l2, l1+l2))
+	ml := NewList(make([]T, l1+l2))
 
 	data := append([]T{}, append(l.data, other.data...)...)
 	ml.data = data
@@ -243,17 +245,17 @@ func (l *List[T]) Merge(other *List[T]) *List[T] {
 	return ml
 }
 
-// Size return number of list data items
+// Size return number of list data items.
 func (l *List[T]) Size() int {
 	return len(l.data)
 }
 
-// Cap return cap of the inner data
+// Cap return cap of the inner data.
 func (l *List[T]) Cap() int {
 	return cap(l.data)
 }
 
-// Swap the value of index i and j in list
+// Swap the value of index i and j in list.
 func (l *List[T]) Swap(i, j int) {
 	size := len(l.data)
 	if i < 0 || i >= size || j < 0 || j >= size {
@@ -262,19 +264,19 @@ func (l *List[T]) Swap(i, j int) {
 	l.data[i], l.data[j] = l.data[j], l.data[i]
 }
 
-// Reverse the item order of list
+// Reverse the item order of list.
 func (l *List[T]) Reverse() {
 	for i, j := 0, len(l.data)-1; i < j; i, j = i+1, j-1 {
 		l.data[i], l.data[j] = l.data[j], l.data[i]
 	}
 }
 
-// Unique remove duplicate items in list
+// Unique delete duplicate items in list.
 func (l *List[T]) Unique() {
 	data := l.data
 	size := len(data)
 
-	uniqueData := make([]T, 0, 0)
+	uniqueData := make([]T, 0)
 	for i := 0; i < size; i++ {
 		value := data[i]
 		skip := true
@@ -292,7 +294,7 @@ func (l *List[T]) Unique() {
 	l.data = uniqueData
 }
 
-// Union creates a new list contain all element in list l and other, remove duplicate element.
+// Union creates a new list contain all element in list l and other, delete duplicate element.
 func (l *List[T]) Union(other *List[T]) *List[T] {
 	result := NewList([]T{})
 
@@ -303,9 +305,9 @@ func (l *List[T]) Union(other *List[T]) *List[T] {
 	return result
 }
 
-// Intersection creates a new list whose element both be contained in list l and other
+// Intersection creates a new list whose element both be contained in list l and other.
 func (l *List[T]) Intersection(other *List[T]) *List[T] {
-	result := NewList(make([]T, 0, 0))
+	result := NewList(make([]T, 0))
 
 	for _, v := range l.data {
 		if other.Contain(v) {
@@ -316,6 +318,43 @@ func (l *List[T]) Intersection(other *List[T]) *List[T] {
 	return result
 }
 
+// Difference returns the difference between two collections.
+// return a list whose element in the original list, not in the given list.
+func (l *List[T]) Difference(other *List[T]) *List[T] {
+	result := NewList(make([]T, 0))
+
+	intersectList := l.Intersection(other)
+
+	for _, v := range l.data {
+		if !intersectList.Contain(v) {
+			result.data = append(result.data, v)
+		}
+	}
+
+	return result
+}
+
+// SymmetricDifference oppoiste operation of intersection function.
+func (l *List[T]) SymmetricDifference(other *List[T]) *List[T] {
+	result := NewList(make([]T, 0))
+
+	intersectList := l.Intersection(other)
+
+	for _, v := range l.data {
+		if !intersectList.Contain(v) {
+			result.data = append(result.data, v)
+		}
+	}
+
+	for _, v := range other.data {
+		if !intersectList.Contain(v) {
+			result.data = append(result.data, v)
+		}
+	}
+
+	return result
+}
+
 // SubList returns a sub list of the original list between the specified fromIndex, inclusive, and toIndex, exclusive.
 func (l *List[T]) SubList(fromIndex, toIndex int) *List[T] {
 	data := l.data[fromIndex:toIndex]
@@ -323,3 +362,57 @@ func (l *List[T]) SubList(fromIndex, toIndex int) *List[T] {
 	copy(subList, data)
 	return NewList(subList)
 }
+
+// ForEach performs the given action for each element of the list.
+func (l *List[T]) ForEach(consumer func(T)) {
+	for _, it := range l.data {
+		consumer(it)
+	}
+}
+
+// RetainAll retains only the elements in this list that are contained in the given list.
+func (l *List[T]) RetainAll(list *List[T]) bool {
+	return l.batchRemove(list, true)
+}
+
+// DeleteAll removes from this list all of its elements that are contained in the given list.
+func (l *List[T]) DeleteAll(list *List[T]) bool {
+	return l.batchRemove(list, false)
+}
+
+func (l *List[T]) batchRemove(list *List[T], complement bool) bool {
+	var (
+		w    = 0
+		data = l.data
+		size = len(data)
+	)
+
+	for i := 0; i < size; i++ {
+		if list.Contain(data[i]) == complement {
+			data[w] = data[i]
+			w++
+		}
+	}
+
+	if w != size {
+		l.data = data[:w]
+		return true
+	}
+	return false
+}
+
+// Iterator returns an iterator over the elements in this list in proper sequence.
+func (l *List[T]) Iterator() iterator.Iterator[T] {
+	return iterator.FromSlice(l.data)
+}
+
+// ListToMap convert a list to a map based on iteratee function.
+func ListToMap[T any, K comparable, V any](list *List[T], iteratee func(T) (K, V)) map[K]V {
+	result := make(map[K]V, list.Size())
+	for _, item := range list.data {
+		k, v := iteratee(item)
+		result[k] = v
+	}
+
+	return result
+}

datastructure/list/list_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestListData(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestListData")
 
 	list := NewList([]int{1, 2, 3})
@@ -14,6 +16,8 @@ func TestListData(t *testing.T) {
 }
 
 func TestValueOf(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestValueOf")
 
 	list := NewList([]int{1, 2, 3})
@@ -26,6 +30,8 @@ func TestValueOf(t *testing.T) {
 }
 
 func TestIndexOf(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIndexOf")
 
 	list := NewList([]int{1, 2, 3})
@@ -37,6 +43,8 @@ func TestIndexOf(t *testing.T) {
 }
 
 func TestIndexOfFunc(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIndexOf")
 
 	list := NewList([]int{1, 2, 3})
@@ -48,6 +56,8 @@ func TestIndexOfFunc(t *testing.T) {
 }
 
 func TestLastIndexOf(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIndexOf")
 
 	list := NewList([]int{1, 2, 3, 3, 3, 3, 4, 5, 6, 9})
@@ -65,6 +75,8 @@ func TestLastIndexOf(t *testing.T) {
 }
 
 func TestLastIndexOfFunc(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIndexOf")
 
 	list := NewList([]int{1, 2, 3, 3, 3, 3, 4, 5, 6, 9})
@@ -82,6 +94,8 @@ func TestLastIndexOfFunc(t *testing.T) {
 }
 
 func TestContain(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestContain")
 
 	list := NewList([]int{1, 2, 3})
@@ -90,6 +104,8 @@ func TestContain(t *testing.T) {
 }
 
 func TestPush(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPush")
 
 	list := NewList([]int{1, 2, 3})
@@ -99,6 +115,8 @@ func TestPush(t *testing.T) {
 }
 
 func TestInsertAtFirst(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestInsertAtFirst")
 
 	list := NewList([]int{1, 2, 3})
@@ -108,6 +126,8 @@ func TestInsertAtFirst(t *testing.T) {
 }
 
 func TestInsertAtLast(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestInsertAtLast")
 
 	list := NewList([]int{1, 2, 3})
@@ -117,6 +137,8 @@ func TestInsertAtLast(t *testing.T) {
 }
 
 func TestInsertAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestInsertAt")
 
 	list := NewList([]int{1, 2, 3})
@@ -135,6 +157,8 @@ func TestInsertAt(t *testing.T) {
 }
 
 func TestPopFirst(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPopFirst")
 
 	list := NewList([]int{1, 2, 3})
@@ -150,6 +174,8 @@ func TestPopFirst(t *testing.T) {
 }
 
 func TestPopLast(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPopLast")
 
 	list := NewList([]int{1, 2, 3})
@@ -165,6 +191,8 @@ func TestPopLast(t *testing.T) {
 }
 
 func TestDeleteAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDeleteAt")
 
 	list := NewList([]int{1, 2, 3, 4})
@@ -183,6 +211,8 @@ func TestDeleteAt(t *testing.T) {
 }
 
 func TestUpdateAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUpdateAt")
 
 	list := NewList([]int{1, 2, 3, 4})
@@ -201,6 +231,8 @@ func TestUpdateAt(t *testing.T) {
 }
 
 func TestEqual(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEqual")
 
 	list1 := NewList([]int{1, 2, 3, 4})
@@ -212,6 +244,8 @@ func TestEqual(t *testing.T) {
 }
 
 func TestIsEmpty(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsEmpty")
 
 	list1 := NewList([]int{1, 2, 3, 4})
@@ -222,6 +256,8 @@ func TestIsEmpty(t *testing.T) {
 }
 
 func TestIsClear(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsClear")
 
 	list1 := NewList([]int{1, 2, 3, 4})
@@ -232,6 +268,8 @@ func TestIsClear(t *testing.T) {
 }
 
 func TestClone(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestClone")
 
 	list1 := NewList([]int{1, 2, 3, 4})
@@ -241,6 +279,8 @@ func TestClone(t *testing.T) {
 }
 
 func TestMerge(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMerge")
 
 	list1 := NewList([]int{1, 2, 3, 4})
@@ -252,6 +292,8 @@ func TestMerge(t *testing.T) {
 }
 
 func TestSize(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSize")
 
 	list := NewList([]int{1, 2, 3, 4})
@@ -262,6 +304,8 @@ func TestSize(t *testing.T) {
 }
 
 func TestCap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCap")
 
 	data := make([]int, 0, 100)
@@ -274,6 +318,8 @@ func TestCap(t *testing.T) {
 }
 
 func TestSwap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSwap")
 
 	list := NewList([]int{1, 2, 3, 4})
@@ -285,6 +331,8 @@ func TestSwap(t *testing.T) {
 }
 
 func TestReverse(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestReverse")
 
 	list := NewList([]int{1, 2, 3, 4})
@@ -296,6 +344,8 @@ func TestReverse(t *testing.T) {
 }
 
 func TestUnique(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUnique")
 
 	list := NewList([]int{1, 2, 2, 3, 4})
@@ -307,6 +357,8 @@ func TestUnique(t *testing.T) {
 }
 
 func TestUnion(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUnion")
 
 	list1 := NewList([]int{1, 2, 3, 4})
@@ -318,6 +370,8 @@ func TestUnion(t *testing.T) {
 }
 
 func TestIntersection(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIntersection")
 
 	list1 := NewList([]int{1, 2, 3, 4})
@@ -328,7 +382,35 @@ func TestIntersection(t *testing.T) {
 	assert.Equal(true, expected.Equal(list3))
 }
 
+func TestDifference(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestDifference")
+
+	list1 := NewList([]int{1, 2, 3})
+	list2 := NewList([]int{1, 2, 4})
+	expected := NewList([]int{3})
+
+	list3 := list1.Difference(list2)
+	assert.Equal(true, expected.Equal(list3))
+}
+
+func TestSymmetricDifference(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSymmetricDifference")
+
+	list1 := NewList([]int{1, 2, 3})
+	list2 := NewList([]int{1, 2, 4})
+	expected := NewList([]int{3, 4})
+
+	list3 := list1.SymmetricDifference(list2)
+	assert.Equal(true, expected.Equal(list3))
+}
+
 func TestSubSlice(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSubSlice")
 
 	list := NewList([]int{1, 2, 3, 4, 5, 8})
@@ -345,6 +427,8 @@ func BenchmarkSubSlice(b *testing.B) {
 }
 
 func TestDeleteIf(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDeleteIf")
 
 	list := NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})
@@ -357,3 +441,91 @@ func TestDeleteIf(t *testing.T) {
 	assert.Equal([]int{2, 3, 4}, list.Data())
 	assert.Equal(0, count)
 }
+
+func TestForEach(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestForEach")
+
+	list := NewList([]int{1, 2, 3, 4})
+	rs := make([]int, 0)
+	list.ForEach(func(i int) {
+		rs = append(rs, i)
+	})
+
+	assert.Equal([]int{1, 2, 3, 4}, rs)
+}
+
+func TestRetainAll(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestRetainAll")
+
+	list := NewList([]int{1, 2, 3, 4})
+	list1 := NewList([]int{1, 2, 3, 4})
+	list2 := NewList([]int{1, 2, 3, 4})
+
+	retain := NewList([]int{1, 2})
+	retain1 := NewList([]int{2, 3})
+	retain2 := NewList([]int{1, 2, 5})
+
+	list.RetainAll(retain)
+	list1.RetainAll(retain1)
+	list2.RetainAll(retain2)
+
+	assert.Equal([]int{1, 2}, list.Data())
+	assert.Equal([]int{2, 3}, list1.Data())
+	assert.Equal([]int{1, 2}, list2.Data())
+}
+
+func TestDeleteAll(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestDeleteAll")
+
+	list := NewList([]int{1, 2, 3, 4})
+	list1 := NewList([]int{1, 2, 3, 4})
+	list2 := NewList([]int{1, 2, 3, 4})
+
+	del := NewList([]int{1})
+	del1 := NewList([]int{2, 3})
+	del2 := NewList([]int{1, 2, 5})
+
+	list.DeleteAll(del)
+	list1.DeleteAll(del1)
+	list2.DeleteAll(del2)
+	assert.Equal([]int{2, 3, 4}, list.Data())
+	assert.Equal([]int{1, 4}, list1.Data())
+	assert.Equal([]int{3, 4}, list2.Data())
+}
+
+func TestIterator(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestIterator")
+
+	list := NewList([]int{1, 2, 3, 4})
+	iterator := list.Iterator()
+
+	rs := make([]int, 0)
+	for iterator.HasNext() {
+		item, _ := iterator.Next()
+		rs = append(rs, item)
+	}
+
+	assert.Equal([]int{1, 2, 3, 4}, rs)
+}
+
+func TestListToMap(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "ListToMap")
+
+	list := NewList([]int{1, 2, 3, 4})
+	result := ListToMap(list, func(n int) (int, bool) {
+		return n, n > 1
+	})
+
+	expected := map[int]bool{1: false, 2: true, 3: true, 4: true}
+	assert.Equal(expected, result)
+}

datastructure/node.go

@@ -1,7 +1,7 @@
 // Copyright 2021 dudaodong@gmail.com. All rights reserved.
 // Use of this source code is governed by MIT license
 
-// Package datastructure implements some data structure. eg. list, linklist, stack, queue, tree, graph.
+// Package datastructure implements some data structure.
 package datastructure
 
 // LinkNode is a linkedlist node, which have a Value and Pre points to previous node, Next points to a next node of the link.

datastructure/queue/arrayqueue.go

@@ -1,3 +1,8 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure contains some data structure.
+// Queue structure contains ArrayQueue, LinkedQueue, CircularQueue, and PriorityQueue.
 package datastructure
 
 import (

datastructure/queue/arrayqueue_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestArrayQueue_Enqueue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayQueue_Enqueue")
 
 	queue := NewArrayQueue[int](5)
@@ -14,17 +16,16 @@ func TestArrayQueue_Enqueue(t *testing.T) {
 	queue.Enqueue(2)
 	queue.Enqueue(3)
 
-	expected := []int{1, 2, 3}
 	data := queue.Data()
 	size := queue.Size()
 
-	queue.Print()
-
-	assert.Equal(expected, data)
+	assert.Equal([]int{1, 2, 3}, data)
 	assert.Equal(3, size)
 }
 
 func TestArrayQueue_Dequeue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayQueue_Dequeue")
 
 	queue := NewArrayQueue[int](4)
@@ -35,12 +36,13 @@ func TestArrayQueue_Dequeue(t *testing.T) {
 	val, ok := queue.Dequeue()
 	assert.Equal(true, ok)
 
-	queue.Print()
 	assert.Equal(1, val)
 	assert.Equal([]int{2, 3}, queue.Data())
 }
 
 func TestArrayQueue_Front(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayQueue_Front")
 
 	queue := NewArrayQueue[int](4)
@@ -50,13 +52,13 @@ func TestArrayQueue_Front(t *testing.T) {
 
 	val := queue.Front()
 
-	queue.Print()
-
 	assert.Equal(1, val)
 	assert.Equal([]int{1, 2, 3}, queue.Data())
 }
 
 func TestArrayQueue_Back(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayQueue_Back")
 
 	queue := NewArrayQueue[int](4)
@@ -66,13 +68,13 @@ func TestArrayQueue_Back(t *testing.T) {
 
 	val := queue.Back()
 
-	queue.Print()
-
 	assert.Equal(3, val)
 	assert.Equal([]int{1, 2, 3}, queue.Data())
 }
 
 func TestArrayQueue_Contain(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayQueue_Contain")
 
 	queue := NewArrayQueue[int](4)
@@ -85,6 +87,8 @@ func TestArrayQueue_Contain(t *testing.T) {
 }
 
 func TestArrayQueue_Clear(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayQueue_Clear")
 
 	queue := NewArrayQueue[int](4)
@@ -102,6 +106,8 @@ func TestArrayQueue_Clear(t *testing.T) {
 }
 
 func TestArrayQueue_IsFull(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayQueue_IsFull")
 
 	queue := NewArrayQueue[int](3)

datastructure/queue/circularqueue.go

@@ -1,3 +1,8 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure contains some data structure.
+// Queue structure contains ArrayQueue, LinkedQueue, CircularQueue, and PriorityQueue.
 package datastructure
 
 import (

datastructure/queue/circularqueue_test.go

@@ -7,34 +7,50 @@ import (
 )
 
 func TestCircularQueue_Enqueue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Enqueue")
 
 	queue := NewCircularQueue[int](6)
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-	queue.Enqueue(4)
-	queue.Enqueue(5)
 
-	queue.Print()
+	err := queue.Enqueue(1)
+	assert.IsNil(err)
+
+	err = queue.Enqueue(2)
+	assert.IsNil(err)
+
+	err = queue.Enqueue(3)
+	assert.IsNil(err)
+
+	err = queue.Enqueue(4)
+	assert.IsNil(err)
+
+	err = queue.Enqueue(5)
+	assert.IsNil(err)
+
 	assert.Equal([]int{1, 2, 3, 4, 5}, queue.Data())
 	assert.Equal(5, queue.Size())
 
-	err := queue.Enqueue(6)
+	err = queue.Enqueue(6)
 	assert.IsNotNil(err)
 }
 
 func TestCircularQueue_Dequeue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_DeQueue")
 
-	queue := NewCircularQueue[int](6)
+	queue := NewCircularQueue[int](4)
 	assert.Equal(true, queue.IsEmpty())
 
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-	queue.Enqueue(4)
-	queue.Enqueue(5)
+	err := queue.Enqueue(1)
+	assert.IsNil(err)
+
+	err = queue.Enqueue(2)
+	assert.IsNil(err)
+
+	err = queue.Enqueue(3)
+	assert.IsNil(err)
 
 	val, err := queue.Dequeue()
 	assert.IsNil(err)
@@ -43,79 +59,82 @@ func TestCircularQueue_Dequeue(t *testing.T) {
 	assert.Equal(false, queue.IsFull())
 
 	val, _ = queue.Dequeue()
-	queue.Print()
 	assert.Equal(2, *val)
-
-	queue.Enqueue(6)
-	queue.Print()
 	assert.Equal(false, queue.IsFull())
 }
 
 func TestCircularQueue_Front(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Front")
 
 	queue := NewCircularQueue[int](6)
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-	queue.Enqueue(4)
-	queue.Enqueue(5)
 
-	queue.Print()
+	err := queue.Enqueue(1)
+	assert.IsNil(err)
 
-	queue.Dequeue()
-	queue.Dequeue()
-	queue.Enqueue(6)
-	queue.Enqueue(7)
+	err = queue.Enqueue(2)
+	assert.IsNil(err)
 
-	queue.Print()
+	err = queue.Enqueue(3)
+	assert.IsNil(err)
 
 	val := queue.Front()
-	assert.Equal(3, val)
-	assert.Equal(5, queue.Size())
+	assert.IsNil(err)
+	assert.Equal(1, val)
+	assert.Equal(3, queue.Size())
 }
 
 func TestCircularQueue_Back(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Back")
 
-	queue := NewCircularQueue[int](6)
+	queue := NewCircularQueue[int](3)
 	assert.Equal(true, queue.IsEmpty())
 
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-	queue.Enqueue(4)
-	queue.Enqueue(5)
+	err := queue.Enqueue(1)
+	assert.IsNil(err)
 
-	queue.Print()
-	assert.Equal(5, queue.Back())
+	err = queue.Enqueue(2)
+	assert.IsNil(err)
 
-	queue.Dequeue()
-	queue.Dequeue()
-	queue.Enqueue(6)
-	queue.Enqueue(7)
+	assert.Equal(2, queue.Back())
 
-	queue.Print()
-	assert.Equal(7, queue.Back())
+	val, _ := queue.Dequeue()
+	assert.Equal(1, *val)
+
+	err = queue.Enqueue(3)
+	assert.IsNil(err)
+
+	assert.Equal(3, queue.Back())
 }
 
 func TestCircularQueue_Contain(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Contain")
 
 	queue := NewCircularQueue[int](2)
-	queue.Enqueue(1)
+	err := queue.Enqueue(1)
+	assert.IsNil(err)
+
 	assert.Equal(true, queue.Contain(1))
 	assert.Equal(false, queue.Contain(2))
 }
 
 func TestCircularQueue_Clear(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Clear")
 
 	queue := NewCircularQueue[int](3)
 	assert.Equal(true, queue.IsEmpty())
 	assert.Equal(0, queue.Size())
 
-	queue.Enqueue(1)
+	err := queue.Enqueue(1)
+	assert.IsNil(err)
+
 	assert.Equal(false, queue.IsEmpty())
 	assert.Equal(1, queue.Size())
 
@@ -125,24 +144,16 @@ func TestCircularQueue_Clear(t *testing.T) {
 }
 
 func TestCircularQueue_Data(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Data")
 
-	queue := NewCircularQueue[int](6)
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-	queue.Enqueue(4)
-	queue.Enqueue(5)
+	queue := NewCircularQueue[int](3)
+	err := queue.Enqueue(1)
+	assert.IsNil(err)
 
-	queue.Print()
-	assert.Equal([]int{1, 2, 3, 4, 5}, queue.Data())
-
-	queue.Dequeue()
-	queue.Dequeue()
-	queue.Enqueue(6)
-	queue.Enqueue(7)
-
-	queue.Print()
-	assert.Equal([]int{3, 4, 5, 6, 7}, queue.Data())
+	err = queue.Enqueue(2)
+	assert.IsNil(err)
 
+	assert.Equal([]int{1, 2}, queue.Data())
 }

datastructure/queue/linkedqueue.go

@@ -1,3 +1,8 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure contains some data structure.
+// Queue structure contains ArrayQueue, LinkedQueue, CircularQueue, and PriorityQueue.
 package datastructure
 
 import (

datastructure/queue/linkedqueue_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestLinkedQueue_Enqueue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLinkedQueue_Enqueue")
 
 	queue := NewLinkedQueue[int]()
@@ -14,13 +16,13 @@ func TestLinkedQueue_Enqueue(t *testing.T) {
 	queue.Enqueue(2)
 	queue.Enqueue(3)
 
-	queue.Print()
-
 	assert.Equal([]int{1, 2, 3}, queue.Data())
 	assert.Equal(3, queue.Size())
 }
 
 func TestLinkedQueue_Dequeue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLinkedQueue_DeQueue")
 
 	queue := NewLinkedQueue[int]()
@@ -37,6 +39,8 @@ func TestLinkedQueue_Dequeue(t *testing.T) {
 }
 
 func TestLinkedQueue_Front(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLinkedQueue_Front")
 
 	queue := NewLinkedQueue[int]()
@@ -53,6 +57,8 @@ func TestLinkedQueue_Front(t *testing.T) {
 }
 
 func TestLinkedQueue_Back(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLinkedQueue_Back")
 
 	queue := NewLinkedQueue[int]()
@@ -69,6 +75,8 @@ func TestLinkedQueue_Back(t *testing.T) {
 }
 
 func TestLinkedQueue_Clear(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLinkedQueue_Back")
 
 	queue := NewLinkedQueue[int]()
@@ -84,10 +92,11 @@ func TestLinkedQueue_Clear(t *testing.T) {
 }
 
 func TestLinkedQueue_Contain(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLinkedQueue_Contain")
 
 	queue := NewLinkedQueue[int]()
-
 	queue.Enqueue(1)
 	queue.Enqueue(2)
 	queue.Enqueue(3)

datastructure/queue/priorityqueue.go

@@ -1,3 +1,8 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure contains some data structure.
+// Queue structure contains ArrayQueue, LinkedQueue, CircularQueue, and PriorityQueue.
 package datastructure
 
 import (

datastructure/queue/priorityqueue_test.go

@@ -20,45 +20,55 @@ func (c *intComparator) Compare(v1, v2 any) int {
 	return 0
 }
 func TestPriorityQueue_Enqueue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPriorityQueue_Enqueue")
 
 	comparator := &intComparator{}
-	pq := NewPriorityQueue[int](10, comparator)
+	pq := NewPriorityQueue[int](3, comparator)
 
 	assert.Equal(true, pq.IsEmpty())
 	assert.Equal(false, pq.IsFull())
 
-	for i := 1; i < 11; i++ {
-		pq.Enqueue(i)
-	}
+	err := pq.Enqueue(1)
+	assert.IsNil(err)
+
+	err = pq.Enqueue(2)
+	assert.IsNil(err)
+
+	err = pq.Enqueue(3)
+	assert.IsNil(err)
 
 	assert.Equal(true, pq.IsFull())
 
 	queueData := pq.Data()
-	assert.Equal([]int{10, 9, 6, 7, 8, 2, 5, 1, 4, 3}, queueData)
+	assert.Equal([]int{3, 1, 2}, queueData)
 
 }
 
 func TestPriorityQueue_Dequeue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPriorityQueue_Dequeue")
 
 	comparator := &intComparator{}
-	pq := NewPriorityQueue[int](10, comparator)
+	pq := NewPriorityQueue[int](3, comparator)
 
 	_, ok := pq.Dequeue()
 	assert.Equal(false, ok)
 
-	for i := 1; i < 11; i++ {
-		pq.Enqueue(i)
-	}
+	err := pq.Enqueue(1)
+	assert.IsNil(err)
 
-	assert.Equal(10, pq.Size())
+	err = pq.Enqueue(2)
+	assert.IsNil(err)
+
+	err = pq.Enqueue(3)
+	assert.IsNil(err)
+
+	assert.Equal(3, pq.Size())
 
 	val, ok := pq.Dequeue()
 	assert.Equal(true, ok)
-	assert.Equal(10, val)
-
-	assert.Equal([]int{9, 8, 6, 7, 3, 2, 5, 1, 4}, pq.Data())
-
-	assert.Equal(9, pq.Size())
+	assert.Equal(3, val)
 }

datastructure/set/set.go

@@ -1,25 +1,66 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure contains some data structure. Set is a data container, like slice, but element of set is not duplicate.
 package datastructure
 
-// Set is a data container, like slice, but element of set is not duplicate
+// 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](values ...T) Set[T] {
+func NewSet[T comparable](items ...T) Set[T] {
 	set := make(Set[T])
-	set.Add(values...)
+	set.Add(items...)
 	return set
 }
 
-// Add value to set
-func (s Set[T]) Add(values ...T) {
-	for _, v := range values {
+// NewSetFromSlice create a set from slice
+func NewSetFromSlice[T comparable](items []T) Set[T] {
+	set := make(Set[T])
+	for _, item := range items {
+		set.Add(item)
+	}
+	return set
+}
+
+// Add items to set
+func (s Set[T]) Add(items ...T) {
+	for _, v := range items {
 		s[v] = struct{}{}
 	}
 }
 
-// Contain checks if set contains value or not
-func (s Set[T]) Contain(value T) bool {
-	_, ok := s[value]
+// AddIfNotExist checks if item exists in the set,
+// it adds the item to set and returns true if it does not exist in the set,
+// or else it does nothing and returns false.
+func (s Set[T]) AddIfNotExist(item T) bool {
+	if !s.Contain(item) {
+		if _, ok := s[item]; !ok {
+			s[item] = struct{}{}
+			return true
+		}
+	}
+	return false
+}
+
+// AddIfNotExistBy checks if item exists in the set and pass the `checker` function
+// it adds the item to set and returns true if it does not exists in the set and
+// function `checker` returns true, or else it does nothing and returns false.
+func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool {
+	if !s.Contain(item) {
+		if checker(item) {
+			if _, ok := s[item]; !ok {
+				s[item] = struct{}{}
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// Contain checks if set contains item or not
+func (s Set[T]) Contain(item T) bool {
+	_, ok := s[item]
 	return ok
 }
 
@@ -41,9 +82,9 @@ func (s Set[T]) Clone() Set[T] {
 	return set
 }
 
-// Delete value of set
-func (s Set[T]) Delete(values ...T) {
-	for _, v := range values {
+// Delete item of set
+func (s Set[T]) Delete(items ...T) {
+	for _, v := range items {
 		delete(s, v)
 	}
 }
@@ -58,7 +99,7 @@ func (s Set[T]) Equal(other Set[T]) bool {
 }
 
 // Iterate call function by every element of set
-func (s Set[T]) Iterate(fn func(value T)) {
+func (s Set[T]) Iterate(fn func(item T)) {
 	for v := range s {
 		fn(v)
 	}
@@ -76,13 +117,13 @@ func (s Set[T]) Size() int {
 
 // Values return all values of set
 func (s Set[T]) Values() []T {
-	values := make([]T, 0, 0)
+	result := make([]T, 0, len(s))
 
 	s.Iterate(func(value T) {
-		values = append(values, value)
+		result = append(result, value)
 	})
 
-	return values
+	return result
 }
 
 // Union creates a new set contain all element of set s and other
@@ -134,3 +175,25 @@ func (s Set[T]) Minus(comparedSet Set[T]) Set[T] {
 
 	return set
 }
+
+// EachWithBreak iterates over elements of a set and invokes function for each element,
+// when iteratee return false, will break the for each loop.
+func (s Set[T]) EachWithBreak(iteratee func(item T) bool) {
+	for _, v := range s.Values() {
+		if !iteratee(v) {
+			break
+		}
+	}
+}
+
+// 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
+	}
+
+	return v, false
+}

datastructure/set/set_test.go

@@ -6,18 +6,73 @@ import (
 	"github.com/duke-git/lancet/v2/internal"
 )
 
+func TestSet_NewSetFromSlice(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSet_NewSetFromSlice")
+
+	s1 := NewSetFromSlice([]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{})
+	assert.Equal(0, s2.Size())
+}
+
 func TestSet_Add(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Add")
 
 	set := NewSet[int]()
 	set.Add(1, 2, 3)
 
-	expected := NewSet(1, 2, 3)
+	cmpSet := NewSet(1, 2, 3)
 
-	assert.Equal(true, set.Equal(expected))
+	assert.Equal(true, set.Equal(cmpSet))
+}
+
+func TestSet_AddIfNotExist(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSet_AddIfNotExist")
+
+	set := NewSet[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)
+}
+
+func TestSet_AddIfNotExistBy(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSet_AddIfNotExistBy")
+
+	set := NewSet[int]()
+	set.Add(1, 2)
+
+	ok := set.AddIfNotExistBy(3, func(val int) bool {
+		return val%2 != 0
+	})
+
+	notOk := set.AddIfNotExistBy(4, func(val int) bool {
+		return val%2 != 0
+	})
+
+	assert.Equal(true, ok)
+	assert.Equal(false, notOk)
+
+	assert.Equal(true, set.Contain(3))
+	assert.Equal(false, set.Contain(4))
 }
 
 func TestSet_Contain(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Contain")
 
 	set := NewSet[int]()
@@ -28,6 +83,8 @@ func TestSet_Contain(t *testing.T) {
 }
 
 func TestSet_ContainAll(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_ContainAll")
 
 	set1 := NewSet(1, 2, 3)
@@ -39,6 +96,8 @@ func TestSet_ContainAll(t *testing.T) {
 }
 
 func TestSet_Clone(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Clone")
 
 	set1 := NewSet(1, 2, 3)
@@ -49,18 +108,20 @@ func TestSet_Clone(t *testing.T) {
 }
 
 func TestSet_Delete(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Delete")
 
 	set := NewSet[int]()
 	set.Add(1, 2, 3)
 	set.Delete(3)
 
-	expected := NewSet(1, 2)
-
-	assert.Equal(true, set.Equal(expected))
+	assert.Equal(true, set.Equal(NewSet(1, 2)))
 }
 
 func TestSet_Equal(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Equal")
 
 	set1 := NewSet(1, 2, 3)
@@ -72,6 +133,8 @@ func TestSet_Equal(t *testing.T) {
 }
 
 func TestSet_Iterate(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Iterate")
 
 	set := NewSet(1, 2, 3)
@@ -84,6 +147,8 @@ func TestSet_Iterate(t *testing.T) {
 }
 
 func TestSet_IsEmpty(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_IsEmpty")
 
 	set := NewSet[int]()
@@ -91,6 +156,8 @@ func TestSet_IsEmpty(t *testing.T) {
 }
 
 func TestSet_Size(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Size")
 
 	set := NewSet(1, 2, 3)
@@ -98,6 +165,8 @@ func TestSet_Size(t *testing.T) {
 }
 
 func TestSet_Values(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Values")
 
 	set := NewSet(1, 2, 3)
@@ -107,28 +176,33 @@ func TestSet_Values(t *testing.T) {
 }
 
 func TestSet_Union(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Union")
 
 	set1 := NewSet(1, 2, 3)
 	set2 := NewSet(2, 3, 4, 5)
-	expected := NewSet(1, 2, 3, 4, 5)
+
 	unionSet := set1.Union(set2)
 
-	assert.Equal(expected, unionSet)
+	assert.Equal(NewSet(1, 2, 3, 4, 5), unionSet)
 }
 
 func TestSet_Intersection(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Intersection")
 
 	set1 := NewSet(1, 2, 3)
 	set2 := NewSet(2, 3, 4, 5)
-	expected := NewSet(2, 3)
 	intersectionSet := set1.Intersection(set2)
 
-	assert.Equal(expected, intersectionSet)
+	assert.Equal(NewSet(2, 3), intersectionSet)
 }
 
 func TestSet_SymmetricDifference(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_SymmetricDifference")
 
 	set1 := NewSet(1, 2, 3)
@@ -138,6 +212,8 @@ func TestSet_SymmetricDifference(t *testing.T) {
 }
 
 func TestSet_Minus(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Minus")
 
 	set1 := NewSet(1, 2, 3)
@@ -147,3 +223,40 @@ func TestSet_Minus(t *testing.T) {
 	assert.Equal(NewSet(1), set1.Minus(set2))
 	assert.Equal(NewSet(4, 5), set2.Minus(set3))
 }
+
+func TestEachWithBreak(t *testing.T) {
+	// s := NewSet(1, 2, 3, 4, 5)
+
+	// var sum int
+
+	// s.EachWithBreak(func(n int) bool {
+	// 	if n > 3 {
+	// 		return false
+	// 	}
+	// 	sum += n
+	// 	return true
+	// })
+
+	// assert := internal.NewAssert(t, "TestEachWithBreak")
+	// assert.Equal(6, sum)
+}
+
+// func TestPop(t *testing.T) {
+// 	assert := internal.NewAssert(t, "TestPop")
+
+// 	s := NewSet[int]()
+
+// 	val, ok := s.Pop()
+// 	assert.Equal(0, val)
+// 	assert.Equal(false, ok)
+
+// 	s.Add(1)
+// 	s.Add(2)
+// 	s.Add(3)
+
+// 	// s = NewSet(1, 2, 3, 4, 5)
+
+// 	val, ok = s.Pop()
+// 	assert.Equal(3, val)
+// 	assert.Equal(true, ok)
+// }

datastructure/stack/arraystack.go

@@ -1,3 +1,7 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure contains some data structure. Stack structure contains ArrayStack and LinkedStack.
 package datastructure
 
 import "errors"

datastructure/stack/arraystack_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestArrayStack_Push(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayStack_Push")
 
 	stack := NewArrayStack[int]()
@@ -14,15 +16,16 @@ func TestArrayStack_Push(t *testing.T) {
 	stack.Push(2)
 	stack.Push(3)
 
-	expected := []int{3, 2, 1}
 	values := stack.Data()
 	length := stack.Size()
 
-	assert.Equal(expected, values)
+	assert.Equal([]int{3, 2, 1}, values)
 	assert.Equal(3, length)
 }
 
 func TestArrayStack_Pop(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayStack_Pop")
 
 	stack := NewArrayStack[int]()
@@ -37,11 +40,12 @@ func TestArrayStack_Pop(t *testing.T) {
 	assert.IsNil(err)
 	assert.Equal(3, *topItem)
 
-	expected := []int{2, 1}
-	assert.Equal(expected, stack.Data())
+	assert.Equal([]int{2, 1}, stack.Data())
 }
 
 func TestArrayStack_Peak(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayStack_Peak")
 
 	stack := NewArrayStack[int]()
@@ -56,11 +60,12 @@ func TestArrayStack_Peak(t *testing.T) {
 	assert.IsNil(err)
 	assert.Equal(3, *topItem)
 
-	expected := []int{3, 2, 1}
-	assert.Equal(expected, stack.Data())
+	assert.Equal([]int{3, 2, 1}, stack.Data())
 }
 
 func TestArrayStack_Clear(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayStack_Clear")
 
 	stack := NewArrayStack[int]()

datastructure/stack/linkedstack.go

@@ -1,3 +1,7 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure contains some data structure. Stack structure contains ArrayStack and LinkedStack.
 package datastructure
 
 import (

datastructure/stack/linkedstack_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestLinkedStack_Push(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLinkedStack_Push")
 
 	stack := NewLinkedStack[int]()
@@ -14,17 +16,16 @@ func TestLinkedStack_Push(t *testing.T) {
 	stack.Push(2)
 	stack.Push(3)
 
-	stack.Print()
-
-	expected := []int{3, 2, 1}
 	values := stack.Data()
 	size := stack.Size()
 
-	assert.Equal(expected, values)
+	assert.Equal([]int{3, 2, 1}, values)
 	assert.Equal(3, size)
 }
 
 func TestLinkedStack_Pop(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLinkedStack_Pop")
 
 	stack := NewLinkedStack[int]()
@@ -39,12 +40,13 @@ func TestLinkedStack_Pop(t *testing.T) {
 	assert.IsNil(err)
 	assert.Equal(3, *topItem)
 
-	expected := []int{2, 1}
 	stack.Print()
-	assert.Equal(expected, stack.Data())
+	assert.Equal([]int{2, 1}, stack.Data())
 }
 
 func TestLinkedStack_Peak(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLinkedStack_Peak")
 
 	stack := NewLinkedStack[int]()
@@ -59,11 +61,12 @@ func TestLinkedStack_Peak(t *testing.T) {
 	assert.IsNil(err)
 	assert.Equal(3, *topItem)
 
-	expected := []int{3, 2, 1}
-	assert.Equal(expected, stack.Data())
+	assert.Equal([]int{3, 2, 1}, stack.Data())
 }
 
 func TestLinkedStack_Empty(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLinkedStack_Empty")
 
 	stack := NewLinkedStack[int]()

datastructure/tree/bstree.go

@@ -1,3 +1,7 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure contains some data structure. BSTree is binary search tree.
 package datastructure
 
 import (

datastructure/tree/bstree_test.go

@@ -20,18 +20,9 @@ func (c *intComparator) Compare(v1, v2 any) int {
 	return 0
 }
 
-func TestBSTree_Insert(t *testing.T) {
-	bstree := NewBSTree(6, &intComparator{})
-
-	bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-	bstree.Print()
-}
-
 func TestBSTree_PreOrderTraverse(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBSTree_PreOrderTraverse")
 
 	bstree := NewBSTree(6, &intComparator{})
@@ -42,11 +33,12 @@ func TestBSTree_PreOrderTraverse(t *testing.T) {
 	bstree.Insert(4)
 
 	acturl := bstree.PreOrderTraverse()
-	t.Log(acturl)
 	assert.Equal([]int{6, 5, 2, 4, 7}, acturl)
 }
 
 func TestBSTree_PostOrderTraverse(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBSTree_PostOrderTraverse")
 
 	bstree := NewBSTree(6, &intComparator{})
@@ -57,11 +49,12 @@ func TestBSTree_PostOrderTraverse(t *testing.T) {
 	bstree.Insert(4)
 
 	acturl := bstree.PostOrderTraverse()
-	t.Log(acturl)
 	assert.Equal([]int{5, 2, 4, 7, 6}, acturl)
 }
 
 func TestBSTree_InOrderTraverse(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBSTree_InOrderTraverse")
 
 	bstree := NewBSTree(6, &intComparator{})
@@ -72,11 +65,12 @@ func TestBSTree_InOrderTraverse(t *testing.T) {
 	bstree.Insert(4)
 
 	acturl := bstree.InOrderTraverse()
-	t.Log(acturl)
 	assert.Equal([]int{2, 4, 5, 6, 7}, acturl)
 }
 
 func TestBSTree_LevelOrderTraverse(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBSTree_LevelOrderTraverse")
 
 	bstree := NewBSTree(6, &intComparator{})
@@ -86,14 +80,13 @@ func TestBSTree_LevelOrderTraverse(t *testing.T) {
 	bstree.Insert(2)
 	bstree.Insert(4)
 
-	bstree.Print()
-
 	acturl := bstree.LevelOrderTraverse()
-	t.Log(acturl)
 	assert.Equal([]int{6, 5, 7, 2, 4}, acturl)
 }
 
 func TestBSTree_Delete(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBSTree_Delete")
 
 	bstree := NewBSTree(6, &intComparator{})
@@ -103,23 +96,21 @@ func TestBSTree_Delete(t *testing.T) {
 	bstree.Insert(2)
 	bstree.Insert(4)
 
-	bstree.Print()
-
 	bstree.Delete(4)
-	bstree.Print()
+
 	acturl1 := bstree.InOrderTraverse()
-	t.Log(acturl1)
 	assert.Equal([]int{2, 5, 6, 7}, acturl1)
 
 	//todo
 	// bstree.DeletetNode(6, comparator)
 	// bstree.Print()
 	// acturl2 := bstree.InOrderTraverse()
-	// t.Log(acturl2)
 	// assert.Equal([]int{2, 5, 7}, acturl2)
 }
 
 func TestBSTree_Depth(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBSTree_Depth")
 
 	bstree := NewBSTree(6, &intComparator{})
@@ -129,12 +120,12 @@ func TestBSTree_Depth(t *testing.T) {
 	bstree.Insert(2)
 	bstree.Insert(4)
 
-	bstree.Print()
-
 	assert.Equal(bstree.Depth(), 4)
 }
 
 func TestBSTree_IsSubTree(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBSTree_IsSubTree")
 
 	superTree := NewBSTree(8, &intComparator{})
@@ -150,8 +141,6 @@ func TestBSTree_IsSubTree(t *testing.T) {
 	subTree.Insert(4)
 	subTree.Insert(6)
 
-	subTree.Print()
-
 	assert.Equal(true, superTree.HasSubTree(subTree))
 	assert.Equal(false, subTree.HasSubTree(superTree))
 }

datastructure/tree/tree_internal.go

@@ -38,35 +38,35 @@ func inOrderTraverse[T any](node *datastructure.TreeNode[T]) []T {
 	return data
 }
 
-func preOrderPrint[T any](node *datastructure.TreeNode[T]) {
-	if node == nil {
-		return
-	}
+// func preOrderPrint[T any](node *datastructure.TreeNode[T]) {
+// 	if node == nil {
+// 		return
+// 	}
 
-	fmt.Printf("%v, ", node.Value)
-	preOrderPrint(node.Left)
-	preOrderPrint(node.Right)
-}
+// 	fmt.Printf("%v, ", node.Value)
+// 	preOrderPrint(node.Left)
+// 	preOrderPrint(node.Right)
+// }
 
-func postOrderPrint[T any](node *datastructure.TreeNode[T]) {
-	if node == nil {
-		return
-	}
+// func postOrderPrint[T any](node *datastructure.TreeNode[T]) {
+// 	if node == nil {
+// 		return
+// 	}
 
-	preOrderPrint(node.Left)
-	preOrderPrint(node.Right)
-	fmt.Printf("%v, ", node.Value)
-}
+// 	postOrderPrint(node.Left)
+// 	postOrderPrint(node.Right)
+// 	fmt.Printf("%v, ", node.Value)
+// }
 
-func inOrderPrint[T any](node *datastructure.TreeNode[T]) {
-	if node == nil {
-		return
-	}
+// func inOrderPrint[T any](node *datastructure.TreeNode[T]) {
+// 	if node == nil {
+// 		return
+// 	}
 
-	inOrderPrint(node.Left)
-	fmt.Printf("%v, ", node.Value)
-	inOrderPrint(node.Right)
-}
+// 	inOrderPrint(node.Left)
+// 	fmt.Printf("%v, ", node.Value)
+// 	inOrderPrint(node.Right)
+// }
 
 func levelOrderTraverse[T any](root *datastructure.TreeNode[T], traversal *[]T) {
 	var q []*datastructure.TreeNode[T] // queue

datetime/conversion.go

@@ -9,17 +9,20 @@ type theTime struct {
 	unix int64
 }
 
-// NewUnixNow return unix timestamp of current time
+// NewUnixNow return unix timestamp of current time.
+// Play: https://go.dev/play/p/U4PPx-9D0oz
 func NewUnixNow() *theTime {
 	return &theTime{unix: time.Now().Unix()}
 }
 
-// NewUnix return unix timestamp of specified time
+// NewUnix return unix timestamp of specified time.
+// Play: https://go.dev/play/p/psoSuh_kLRt
 func NewUnix(unix int64) *theTime {
 	return &theTime{unix: unix}
 }
 
-// NewFormat return unix timestamp of specified time string, t should be "yyyy-mm-dd hh:mm:ss"
+// NewFormat return unix timestamp of specified time string, t should be "yyyy-mm-dd hh:mm:ss".
+// Play: https://go.dev/play/p/VkW08ZOaXPZ
 func NewFormat(t string) (*theTime, error) {
 	timeLayout := "2006-01-02 15:04:05"
 	loc := time.FixedZone("CST", 8*3600)
@@ -30,7 +33,8 @@ func NewFormat(t string) (*theTime, error) {
 	return &theTime{unix: tt.Unix()}, nil
 }
 
-// NewISO8601 return unix timestamp of specified iso8601 time string
+// NewISO8601 return unix timestamp of specified iso8601 time string.
+// Play: https://go.dev/play/p/mkhOHQkdeA2
 func NewISO8601(iso8601 string) (*theTime, error) {
 	t, err := time.ParseInLocation(time.RFC3339, iso8601, time.UTC)
 	if err != nil {
@@ -39,22 +43,26 @@ func NewISO8601(iso8601 string) (*theTime, error) {
 	return &theTime{unix: t.Unix()}, nil
 }
 
-// ToUnix return unix timestamp
+// ToUnix return unix timestamp.
+// Play: https://go.dev/play/p/_LUiwAdocjy
 func (t *theTime) ToUnix() int64 {
 	return t.unix
 }
 
-// ToFormat return the time string 'yyyy-mm-dd hh:mm:ss' of unix time
+// ToFormat return the time string 'yyyy-mm-dd hh:mm:ss' of unix time.
+// Play: https://go.dev/play/p/VkW08ZOaXPZ
 func (t *theTime) ToFormat() string {
 	return time.Unix(t.unix, 0).Format("2006-01-02 15:04:05")
 }
 
-// ToFormatForTpl return the time string which format is specified tpl
+// ToFormatForTpl return the time string which format is specified tpl.
+// Play: https://go.dev/play/p/nyXxXcQJ8L5
 func (t *theTime) ToFormatForTpl(tpl string) string {
 	return time.Unix(t.unix, 0).Format(tpl)
 }
 
-// ToFormatForTpl return iso8601 time string
+// ToFormatForTpl return iso8601 time string.
+// Play: https://go.dev/play/p/mkhOHQkdeA2
 func (t *theTime) ToIso8601() string {
 	return time.Unix(t.unix, 0).Format(time.RFC3339)
 }

datetime/conversion_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestToUnix(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToUnix")
 
 	tm1 := NewUnixNow()
@@ -17,37 +19,37 @@ func TestToUnix(t *testing.T) {
 }
 
 func TestToFormat(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToFormat")
 
-	_, err := NewFormat("2022/03/18 17:04:05")
-	assert.IsNotNil(err)
-
 	tm, err := NewFormat("2022-03-18 17:04:05")
+	t.Log("TestToFormat", tm.ToFormat())
 	assert.IsNil(err)
-
-	t.Log("ToFormat -> ", tm.ToFormat())
 }
 
 func TestToFormatForTpl(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToFormatForTpl")
 
 	_, err := NewFormat("2022/03/18 17:04:05")
 	assert.IsNotNil(err)
 
 	tm, err := NewFormat("2022-03-18 17:04:05")
+	t.Log("TestToFormatForTpl", tm.ToFormatForTpl("2006/01/02 15:04:05"))
 	assert.IsNil(err)
-
-	t.Log("ToFormatForTpl -> ", tm.ToFormatForTpl("2006/01/02 15:04:05"))
 }
 
 func TestToIso8601(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToIso8601")
 
 	_, err := NewISO8601("2022-03-18 17:04:05")
 	assert.IsNotNil(err)
 
 	tm, err := NewISO8601("2006-01-02T15:04:05.999Z")
+	t.Log("TestToIso8601", tm.ToIso8601())
 	assert.IsNil(err)
-
-	t.Log("ToIso8601 -> ", tm.ToIso8601())
 }

datetime/datetime.go

@@ -3,7 +3,7 @@
 
 // Package datetime implements some functions to format date and time.
 // Note:
-// 1. `format` param in FormatTimeToStr function should be as flow:
+// 1. `format` param in FormatTimeToStr function should be as flow (case no sensitive):
 // "yyyy-mm-dd hh:mm:ss"
 // "yyyy-mm-dd hh:mm"
 // "yyyy-mm-dd hh"
@@ -18,14 +18,19 @@
 // "yyyy/mm"
 // "mm/dd"
 // "dd/mm/yy hh:mm:ss"
+// "yyyymmdd"
+// "mmddyy"
 // "yyyy"
+// "yy"
 // "mm"
 // "hh:mm:ss"
+// "hh:mm"
 // "mm:ss"
 package datetime
 
 import (
 	"fmt"
+	"strings"
 	"time"
 )
 
@@ -35,7 +40,7 @@ func init() {
 	timeFormat = map[string]string{
 		"yyyy-mm-dd hh:mm:ss": "2006-01-02 15:04:05",
 		"yyyy-mm-dd hh:mm":    "2006-01-02 15:04",
-		"yyyy-mm-dd hh":       "2006-01-02 15:04",
+		"yyyy-mm-dd hh":       "2006-01-02 15",
 		"yyyy-mm-dd":          "2006-01-02",
 		"yyyy-mm":             "2006-01",
 		"mm-dd":               "01-02",
@@ -47,107 +52,167 @@ func init() {
 		"yyyy/mm":             "2006/01",
 		"mm/dd":               "01/02",
 		"dd/mm/yy hh:mm:ss":   "02/01/06 15:04:05",
+		"yyyymmdd":            "20060102",
+		"mmddyy":              "010206",
 		"yyyy":                "2006",
+		"yy":                  "06",
 		"mm":                  "01",
 		"hh:mm:ss":            "15:04:05",
+		"hh:mm":               "15:04",
 		"mm:ss":               "04:05",
 	}
 }
 
-// AddMinute add or sub minute to the time
+// AddMinute add or sub minute 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))
 }
 
-// AddHour add or sub hour to the time
+// AddHour add or sub hour 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))
 }
 
-// AddDay add or sub day to the time
+// AddDay add or sub day 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))
 }
 
-// GetNowDate return format yyyy-mm-dd of current date
+// 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))
+}
+
+// GetNowDate return format yyyy-mm-dd of current date.
+// Play: https://go.dev/play/p/PvfkPpcpBBf
 func GetNowDate() string {
 	return time.Now().Format("2006-01-02")
 }
 
-// GetNowTime return format hh-mm-ss of current time
+// GetNowTime return format hh-mm-ss of current time.
+// Play: https://go.dev/play/p/l7BNxCkTmJS
 func GetNowTime() string {
 	return time.Now().Format("15:04:05")
 }
 
-// GetNowDateTime return format yyyy-mm-dd hh-mm-ss of current datetime
+// GetNowDateTime return format yyyy-mm-dd hh-mm-ss of current datetime.
+// Play: https://go.dev/play/p/pI4AqngD0al
 func GetNowDateTime() string {
 	return time.Now().Format("2006-01-02 15:04:05")
 }
 
-// GetZeroHourTimestamp return timestamp of zero hour (timestamp of 00:00)
+// GetTodayStartTime return the start time of today, format: yyyy-mm-dd 00:00:00.
+// Play: https://go.dev/play/p/84siyYF7t99
+func GetTodayStartTime() string {
+	return time.Now().Format("2006-01-02") + " 00:00:00"
+}
+
+// GetTodayEndTime return the end time of today, format: yyyy-mm-dd 23:59:59.
+// Play: https://go.dev/play/p/jjrLnfoqgn3
+func GetTodayEndTime() string {
+	return time.Now().Format("2006-01-02") + " 23:59:59"
+}
+
+// GetZeroHourTimestamp return timestamp of zero hour (timestamp of 00:00).
+// Play: https://go.dev/play/p/QmL2oIaGE3q
 func GetZeroHourTimestamp() int64 {
 	ts := time.Now().Format("2006-01-02")
 	t, _ := time.Parse("2006-01-02", ts)
 	return t.UTC().Unix() - 8*3600
 }
 
-// GetNightTimestamp return timestamp of zero hour (timestamp of 23:59)
+// GetNightTimestamp return timestamp of zero hour (timestamp of 23:59).
+// Play: https://go.dev/play/p/UolysR3MYP1
 func GetNightTimestamp() int64 {
 	return GetZeroHourTimestamp() + 86400 - 1
 }
 
-// FormatTimeToStr convert time to string
-func FormatTimeToStr(t time.Time, format string) string {
-	return t.Format(timeFormat[format])
-}
-
-// FormatStrToTime convert string to time
-func FormatStrToTime(str, format string) (time.Time, error) {
-	v, ok := timeFormat[format]
+// FormatTimeToStr convert time to string.
+// Play: https://go.dev/play/p/_Ia7M8H_OvE
+func FormatTimeToStr(t time.Time, format string, timezone ...string) string {
+	tf, ok := timeFormat[strings.ToLower(format)]
 	if !ok {
-		return time.Time{}, fmt.Errorf("format %s not found", format)
+		return ""
 	}
 
-	return time.Parse(v, str)
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return ""
+		}
+		return t.In(loc).Format(tf)
+	}
+	return t.Format(tf)
 }
 
-// BeginOfMinute return beginning minute time of day
+// FormatStrToTime convert string to time.
+// Play: https://go.dev/play/p/1h9FwdU8ql4
+func FormatStrToTime(str, format string, timezone ...string) (time.Time, error) {
+	tf, ok := timeFormat[strings.ToLower(format)]
+	if !ok {
+		return time.Time{}, fmt.Errorf("format %s not support", format)
+	}
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return time.Time{}, err
+		}
+
+		return time.ParseInLocation(tf, str, loc)
+	}
+
+	return time.Parse(tf, str)
+}
+
+// BeginOfMinute return beginning minute time of day.
+// Play: https://go.dev/play/p/ieOLVJ9CiFT
 func BeginOfMinute(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, t.Hour(), t.Minute(), 0, 0, t.Location())
 }
 
-// EndOfMinute return end minute time of day
+// EndOfMinute return end minute time of day.
+// Play: https://go.dev/play/p/yrL5wGzPj4z
 func EndOfMinute(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, t.Hour(), t.Minute(), 59, int(time.Second-time.Nanosecond), t.Location())
 }
 
-// BeginOfHour return beginning hour time of day
+// BeginOfHour return beginning hour time of day.
+// Play: https://go.dev/play/p/GhdGFnDWpYs
 func BeginOfHour(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, t.Hour(), 0, 0, 0, t.Location())
 }
 
-// EndOfHour return end hour time of day
+// EndOfHour return end hour time of day.
+// Play: https://go.dev/play/p/6ce3j_6cVqN
 func EndOfHour(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, t.Hour(), 59, 59, int(time.Second-time.Nanosecond), t.Location())
 }
 
-// BeginOfDay return beginning hour time of day
+// BeginOfDay return beginning hour time of day.
+// Play: https://go.dev/play/p/94m_UT6cWs9
 func BeginOfDay(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, 0, 0, 0, 0, t.Location())
 }
 
-// EndOfDay return end time of day
+// EndOfDay return end time of day.
+// Play: https://go.dev/play/p/eMBOvmq5Ih1
 func EndOfDay(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, 23, 59, 59, int(time.Second-time.Nanosecond), t.Location())
 }
 
-// BeginOfWeek return beginning week, default week begin from Sunday
+// 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 {
@@ -161,7 +226,8 @@ func BeginOfWeek(t time.Time, beginFrom ...time.Weekday) time.Time {
 	return beginOfWeek
 }
 
-// EndOfWeek return end week time, default week end with Saturday
+// 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 {
@@ -175,24 +241,143 @@ func EndOfWeek(t time.Time, endWith ...time.Weekday) time.Time {
 	return endWithWeek
 }
 
-// BeginOfMonth return beginning of month
+// BeginOfMonth return beginning of month.
+// Play: https://go.dev/play/p/bWXVFsmmzwL
 func BeginOfMonth(t time.Time) time.Time {
 	y, m, _ := t.Date()
 	return time.Date(y, m, 1, 0, 0, 0, 0, t.Location())
 }
 
-// EndOfMonth return end of month
+// EndOfMonth return end of month.
+// Play: https://go.dev/play/p/_GWh10B3Nqi
 func EndOfMonth(t time.Time) time.Time {
 	return BeginOfMonth(t).AddDate(0, 1, 0).Add(-time.Nanosecond)
 }
 
-// BeginOfYear return beginning of year
+// BeginOfYear return the date time at the begin of year.
+// Play: https://go.dev/play/p/i326DSwLnV8
 func BeginOfYear(t time.Time) time.Time {
 	y, _, _ := t.Date()
 	return time.Date(y, time.January, 1, 0, 0, 0, 0, t.Location())
 }
 
-// EndOfYear return end of year
+// EndOfYear return the date time at the end of year.
+// Play: https://go.dev/play/p/G01cKlMCvNm
 func EndOfYear(t time.Time) time.Time {
 	return BeginOfYear(t).AddDate(1, 0, 0).Add(-time.Nanosecond)
 }
+
+// IsLeapYear check if param year is leap year or not.
+// Play: https://go.dev/play/p/xS1eS2ejGew
+func IsLeapYear(year int) bool {
+	return year%4 == 0 && (year%100 != 0 || year%400 == 0)
+}
+
+// BetweenSeconds returns the number of seconds between two times.
+// Play: https://go.dev/play/p/n3YDRyfyXJu
+func BetweenSeconds(t1 time.Time, t2 time.Time) int64 {
+	index := t2.Unix() - t1.Unix()
+	return index
+}
+
+// DayOfYear returns which day of the year the parameter date `t` is.
+// Play: https://go.dev/play/p/0hjqhTwFNlH
+func DayOfYear(t time.Time) int {
+	y, m, d := t.Date()
+	firstDay := time.Date(y, 1, 1, 0, 0, 0, 0, t.Location())
+	nowDate := time.Date(y, m, d, 0, 0, 0, 0, t.Location())
+
+	return int(nowDate.Sub(firstDay).Hours() / 24)
+}
+
+// IsWeekend checks if passed time is weekend or not.
+// Play: https://go.dev/play/p/cupRM5aZOIY
+// Deprecated Use '== Weekday' instead
+func IsWeekend(t time.Time) bool {
+	return time.Saturday == t.Weekday() || time.Sunday == t.Weekday()
+}
+
+// NowDateOrTime return current datetime with specific format and timezone.
+// Play: https://go.dev/play/p/EZ-begEjtT0
+func NowDateOrTime(format string, timezone ...string) string {
+	tf, ok := timeFormat[strings.ToLower(format)]
+	if !ok {
+		return ""
+	}
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return ""
+		}
+
+		return time.Now().In(loc).Format(tf)
+	}
+
+	return time.Now().Format(tf)
+}
+
+// Timestamp return current second timestamp.
+// Play: https://go.dev/play/p/iU5b7Vvjx6x
+func Timestamp(timezone ...string) int64 {
+	t := time.Now()
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return 0
+		}
+
+		t = t.In(loc)
+	}
+
+	return t.Unix()
+}
+
+// TimestampMilli return current mill second timestamp.
+// Play: https://go.dev/play/p/4gvEusOTu1T
+func TimestampMilli(timezone ...string) int64 {
+	t := time.Now()
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return 0
+		}
+		t = t.In(loc)
+	}
+
+	return int64(time.Nanosecond) * t.UnixNano() / int64(time.Millisecond)
+}
+
+// TimestampMicro return current micro second timestamp.
+// Play: https://go.dev/play/p/2maANglKHQE
+func TimestampMicro(timezone ...string) int64 {
+	t := time.Now()
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return 0
+		}
+		t = t.In(loc)
+	}
+
+	return int64(time.Nanosecond) * t.UnixNano() / int64(time.Microsecond)
+}
+
+// TimestampNano return current nano second timestamp.
+// Play: https://go.dev/play/p/A9Oq_COrcCF
+func TimestampNano(timezone ...string) int64 {
+	t := time.Now()
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return 0
+		}
+		t = t.In(loc)
+	}
+
+	return t.UnixNano()
+}

datetime/datetime_example_test.go

@@ -0,0 +1,410 @@
+package datetime
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+)
+
+func ExampleAddDay() {
+	now := time.Now()
+
+	tomorrow := AddDay(now, 1)
+	diff1 := tomorrow.Sub(now)
+
+	yesterday := AddDay(now, -1)
+	diff2 := yesterday.Sub(now)
+
+	fmt.Println(diff1)
+	fmt.Println(diff2)
+
+	// Output:
+	// 24h0m0s
+	// -24h0m0s
+}
+
+func ExampleAddHour() {
+	now := time.Now()
+
+	after2Hours := AddHour(now, 2)
+	diff1 := after2Hours.Sub(now)
+
+	before2Hours := AddHour(now, -2)
+	diff2 := before2Hours.Sub(now)
+
+	fmt.Println(diff1)
+	fmt.Println(diff2)
+
+	// Output:
+	// 2h0m0s
+	// -2h0m0s
+}
+
+func ExampleAddMinute() {
+	now := time.Now()
+
+	after2Minutes := AddMinute(now, 2)
+	diff1 := after2Minutes.Sub(now)
+
+	before2Minutes := AddMinute(now, -2)
+	diff2 := before2Minutes.Sub(now)
+
+	fmt.Println(diff1)
+	fmt.Println(diff2)
+
+	// Output:
+	// 2m0s
+	// -2m0s
+}
+
+func ExampleAddYear() {
+	now := time.Now()
+
+	after1Year := AddYear(now, 1)
+	diff1 := after1Year.Sub(now)
+
+	before1Year := AddYear(now, -1)
+	diff2 := before1Year.Sub(now)
+
+	fmt.Println(diff1)
+	fmt.Println(diff2)
+
+	// Output:
+	// 8760h0m0s
+	// -8760h0m0s
+}
+
+func ExampleGetNowDate() {
+	result := GetNowDate()
+
+	expected := time.Now().Format("2006-01-02")
+
+	fmt.Println(result == expected)
+
+	// Output:
+	// true
+}
+
+func ExampleGetNowTime() {
+	result := GetNowTime()
+
+	expected := time.Now().Format("15:04:05")
+
+	fmt.Println(result == expected)
+
+	// Output:
+	// true
+}
+
+func ExampleGetNowDateTime() {
+	result := GetNowDateTime()
+
+	expected := time.Now().Format("2006-01-02 15:04:05")
+
+	fmt.Println(result == expected)
+
+	// Output:
+	// true
+}
+
+// func ExampleGetZeroHourTimestamp() {
+// 	ts := GetZeroHourTimestamp()
+
+// 	fmt.Println(ts)
+
+// 	// Output:
+// 	// 1673107200
+// }
+
+// func ExampleGetNightTimestamp() {
+// 	ts := GetNightTimestamp()
+
+// 	fmt.Println(ts)
+
+// 	// Output:
+// 	// 1673193599
+// }
+
+func ExampleFormatTimeToStr() {
+	datetime, _ := time.Parse("2006-01-02 15:04:05", "2021-01-02 16:04:08")
+
+	result1 := FormatTimeToStr(datetime, "yyyy-mm-dd hh:mm:ss")
+	result2 := FormatTimeToStr(datetime, "yyyy-mm-dd")
+	result3 := FormatTimeToStr(datetime, "dd-mm-yy hh:mm:ss")
+	result4 := FormatTimeToStr(datetime, "yyyy-mm-dd hh")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// 2021-01-02 16:04:08
+	// 2021-01-02
+	// 02-01-21 16:04:08
+	// 2021-01-02 16
+}
+
+func ExampleFormatStrToTime() {
+	result1, _ := FormatStrToTime("2021-01-02 16:04:08", "yyyy-mm-dd hh:mm:ss")
+	result2, _ := FormatStrToTime("2021-01-02", "yyyy-mm-dd")
+	result3, _ := FormatStrToTime("02-01-21 16:04:08", "dd-mm-yy hh:mm:ss")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// 2021-01-02 16:04:08 +0000 UTC
+	// 2021-01-02 00:00:00 +0000 UTC
+	// 2021-01-02 16:04:08 +0000 UTC
+}
+
+func ExampleBeginOfMinute() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := BeginOfMinute(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-01-08 18:50:00 +0000 UTC
+}
+
+func ExampleEndOfMinute() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := EndOfMinute(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-01-08 18:50:59.999999999 +0000 UTC
+}
+
+func ExampleBeginOfHour() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := BeginOfHour(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-01-08 18:00:00 +0000 UTC
+}
+
+func ExampleEndOfHour() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := EndOfHour(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-01-08 18:59:59.999999999 +0000 UTC
+}
+
+func ExampleBeginOfDay() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := BeginOfDay(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-01-08 00:00:00 +0000 UTC
+}
+
+func ExampleEndOfDay() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := EndOfDay(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-01-08 23:59:59.999999999 +0000 UTC
+}
+
+func ExampleBeginOfWeek() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := BeginOfWeek(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-01-08 00:00:00 +0000 UTC
+}
+
+func ExampleEndOfWeek() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := EndOfWeek(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-01-14 23:59:59.999999999 +0000 UTC
+}
+
+func ExampleBeginOfMonth() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := BeginOfMonth(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-01-01 00:00:00 +0000 UTC
+}
+
+func ExampleEndOfMonth() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := EndOfMonth(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-01-31 23:59:59.999999999 +0000 UTC
+}
+
+func ExampleBeginOfYear() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := BeginOfYear(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-01-01 00:00:00 +0000 UTC
+}
+
+func ExampleEndOfYear() {
+	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
+
+	result := EndOfYear(input)
+
+	fmt.Println(result)
+
+	// Output:
+	// 2023-12-31 23:59:59.999999999 +0000 UTC
+}
+
+func ExampleNewUnix() {
+	result := NewUnix(1647597438)
+
+	fmt.Println(result)
+
+	// Output:
+	// &{1647597438}
+}
+
+func ExampleNewUnixNow() {
+	tm1 := NewUnixNow()
+
+	unixTimestamp := tm1.ToUnix()
+
+	tm2 := NewUnix(unixTimestamp)
+
+	fmt.Println(reflect.DeepEqual(tm1, tm2))
+
+	// Output:
+	// true
+}
+
+// func ExampleNewFormat() {
+// 	tm, err := NewFormat("2022-03-18 17:04:05")
+// 	if err != nil {
+// 		return
+// 	}
+
+// 	result := tm.ToFormat()
+
+// 	fmt.Println(result)
+
+// 	// Output:
+// 	// 2022-03-18 17:04:05
+// }
+
+// func ExampleNewISO8601() {
+// 	tm, err := NewISO8601("2006-01-02T15:04:05.999Z")
+// 	if err != nil {
+// 		return
+// 	}
+
+// 	result := tm.ToIso8601()
+
+// 	fmt.Println(result)
+
+// 	// Output:
+// 	// 2006-01-02T23:04:05+08:00
+// }
+
+func ExampleIsLeapYear() {
+	result1 := IsLeapYear(2000)
+	result2 := IsLeapYear(2001)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// true
+	// false
+}
+
+func ExampleBetweenSeconds() {
+	today := time.Now()
+	tomorrow := AddDay(today, 1)
+	yesterday := AddDay(today, -1)
+
+	result1 := BetweenSeconds(today, tomorrow)
+	result2 := BetweenSeconds(today, yesterday)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// 86400
+	// -86400
+}
+
+func ExampleDayOfYear() {
+	date1 := time.Date(2023, 02, 01, 1, 1, 1, 0, time.Local)
+	result1 := DayOfYear(date1)
+
+	date2 := time.Date(2023, 01, 02, 1, 1, 1, 0, time.Local)
+	result2 := DayOfYear(date2)
+
+	date3 := time.Date(2023, 01, 01, 1, 1, 1, 0, time.Local)
+	result3 := DayOfYear(date3)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// 31
+	// 1
+	// 0
+}
+
+func ExampleIsWeekend() {
+	date1 := time.Date(2023, 06, 03, 0, 0, 0, 0, time.Local)
+	date2 := time.Date(2023, 06, 04, 0, 0, 0, 0, time.Local)
+	date3 := time.Date(2023, 06, 02, 0, 0, 0, 0, time.Local)
+
+	result1 := IsWeekend(date1)
+	result2 := IsWeekend(date2)
+	result3 := IsWeekend(date3)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// true
+	// true
+	// false
+}

datetime/datetime_test.go

@@ -7,7 +7,40 @@ import (
 	"github.com/duke-git/lancet/v2/internal"
 )
 
+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())
+
+	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)
+}
+
 func TestAddDay(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestAddDay")
 
 	now := time.Now()
@@ -21,6 +54,8 @@ func TestAddDay(t *testing.T) {
 }
 
 func TestAddHour(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestAddHour")
 
 	now := time.Now()
@@ -34,6 +69,8 @@ func TestAddHour(t *testing.T) {
 }
 
 func TestAddMinute(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestAddMinute")
 
 	now := time.Now()
@@ -47,45 +84,77 @@ func TestAddMinute(t *testing.T) {
 }
 
 func TestGetNowDate(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestGetNowDate")
 	expected := time.Now().Format("2006-01-02")
 	assert.Equal(expected, GetNowDate())
 }
 
-func TestGetNotTime(t *testing.T) {
-	assert := internal.NewAssert(t, "TestGetNotTime")
+func TestGetNowTime(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestGetNowTime")
 	expected := time.Now().Format("15:04:05")
 	assert.Equal(expected, GetNowTime())
 }
 
 func TestGetNowDateTime(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestGetNowDateTime")
 	expected := time.Now().Format("2006-01-02 15:04:05")
 	assert.Equal(expected, GetNowDateTime())
 }
 
+func TestGetTodayStartTime(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestGetTodayStartTime")
+	expected := time.Now().Format("2006-01-02") + " 00:00:00"
+	assert.Equal(expected, GetTodayStartTime())
+}
+
+func TestGetTodayEndTime(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestGetTodayEndTime")
+	expected := time.Now().Format("2006-01-02") + " 23:59:59"
+	assert.Equal(expected, GetTodayEndTime())
+}
+
 func TestFormatTimeToStr(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFormatTimeToStr")
 
 	datetime, _ := time.Parse("2006-01-02 15:04:05", "2021-01-02 16:04:08")
 	cases := []string{
 		"yyyy-mm-dd hh:mm:ss", "yyyy-mm-dd",
 		"dd-mm-yy hh:mm:ss", "yyyy/mm/dd hh:mm:ss",
-		"hh:mm:ss", "yyyy/mm"}
+		"hh:mm:ss", "yyyy/mm",
+		"yyyy-mm-dd hh",
+	}
 
 	expected := []string{
 		"2021-01-02 16:04:08", "2021-01-02",
 		"02-01-21 16:04:08", "2021/01/02 16:04:08",
-		"16:04:08", "2021/01"}
+		"16:04:08", "2021/01",
+		"2021-01-02 16",
+	}
 
 	for i := 0; i < len(cases); i++ {
 		actual := FormatTimeToStr(datetime, cases[i])
 		assert.Equal(expected[i], actual)
-
 	}
+
+	ds := FormatTimeToStr(datetime, "yyyy-mm-dd hh:mm:ss", "EST")
+	t.Log(ds)
 }
 
 func TestFormatStrToTime(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFormatStrToTime")
 
 	formats := []string{
@@ -97,22 +166,28 @@ func TestFormatStrToTime(t *testing.T) {
 		"dd-mm-yy hh:mm:ss", "yyyy/mm/dd hh:mm:ss",
 		"yyyy/mm"}
 
-	datetimeStr := []string{
+	expected := []string{
 		"2021-01-02 16:04:08", "2021-01-02",
 		"02-01-21 16:04:08", "2021/01/02 16:04:08",
 		"2021/01"}
 
 	for i := 0; i < len(cases); i++ {
-		actual, err := FormatStrToTime(datetimeStr[i], cases[i])
+		actual, err := FormatStrToTime(expected[i], cases[i])
 		if err != nil {
 			t.Fatal(err)
 		}
-		expected, _ := time.Parse(formats[i], datetimeStr[i])
+		expected, _ := time.Parse(formats[i], expected[i])
 		assert.Equal(expected, actual)
 	}
+
+	estTime, err := FormatStrToTime("2021-01-02 16:04:08", "yyyy-mm-dd hh:mm:ss", "EST")
+	t.Log(estTime)
+	assert.IsNil(err)
 }
 
 func TestBeginOfMinute(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBeginOfMinute")
 
 	expected := time.Date(2022, 2, 15, 15, 48, 0, 0, time.Local)
@@ -123,6 +198,8 @@ func TestBeginOfMinute(t *testing.T) {
 }
 
 func TestEndOfMinute(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEndOfMinute")
 
 	expected := time.Date(2022, 2, 15, 15, 48, 59, 999999999, time.Local)
@@ -133,6 +210,8 @@ func TestEndOfMinute(t *testing.T) {
 }
 
 func TestBeginOfHour(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBeginOfHour")
 
 	expected := time.Date(2022, 2, 15, 15, 0, 0, 0, time.Local)
@@ -143,6 +222,8 @@ func TestBeginOfHour(t *testing.T) {
 }
 
 func TestEndOfHour(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEndOfHour")
 
 	expected := time.Date(2022, 2, 15, 15, 59, 59, 999999999, time.Local)
@@ -153,6 +234,8 @@ func TestEndOfHour(t *testing.T) {
 }
 
 func TestBeginOfDay(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBeginOfDay")
 
 	expected := time.Date(2022, 2, 15, 0, 0, 0, 0, time.Local)
@@ -163,6 +246,8 @@ func TestBeginOfDay(t *testing.T) {
 }
 
 func TestEndOfDay(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEndOfDay")
 
 	expected := time.Date(2022, 2, 15, 23, 59, 59, 999999999, time.Local)
@@ -173,6 +258,8 @@ func TestEndOfDay(t *testing.T) {
 }
 
 func TestBeginOfWeek(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBeginOfWeek")
 
 	expected := time.Date(2022, 2, 13, 0, 0, 0, 0, time.Local)
@@ -183,6 +270,8 @@ func TestBeginOfWeek(t *testing.T) {
 }
 
 func TestEndOfWeek(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEndOfWeek")
 
 	expected := time.Date(2022, 2, 19, 23, 59, 59, 999999999, time.Local)
@@ -193,6 +282,8 @@ func TestEndOfWeek(t *testing.T) {
 }
 
 func TestBeginOfMonth(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBeginOfMonth")
 
 	expected := time.Date(2022, 2, 1, 0, 0, 0, 0, time.Local)
@@ -203,6 +294,8 @@ func TestBeginOfMonth(t *testing.T) {
 }
 
 func TestEndOfMonth(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEndOfMonth")
 
 	expected := time.Date(2022, 2, 28, 23, 59, 59, 999999999, time.Local)
@@ -213,6 +306,8 @@ func TestEndOfMonth(t *testing.T) {
 }
 
 func TestBeginOfYear(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBeginOfYear")
 
 	expected := time.Date(2022, 1, 1, 0, 0, 0, 0, time.Local)
@@ -223,6 +318,8 @@ func TestBeginOfYear(t *testing.T) {
 }
 
 func TestEndOfYear(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEndOfYear")
 
 	expected := time.Date(2022, 12, 31, 23, 59, 59, 999999999, time.Local)
@@ -231,3 +328,85 @@ func TestEndOfYear(t *testing.T) {
 
 	assert.Equal(expected, actual)
 }
+
+func TestIsLeapYear(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestEndOfYear")
+
+	result1 := IsLeapYear(2000)
+	result2 := IsLeapYear(2001)
+
+	assert.Equal(true, result1)
+	assert.Equal(false, result2)
+}
+
+func TestDayOfYear(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestDayOfYear")
+	date1 := time.Date(2023, 02, 01, 1, 1, 1, 0, time.Local)
+	result1 := DayOfYear(date1)
+	assert.Equal(31, result1)
+
+	date2 := time.Date(2023, 01, 02, 1, 1, 1, 0, time.Local)
+	result2 := DayOfYear(date2)
+	assert.Equal(1, result2)
+
+	date3 := time.Date(2023, 01, 01, 1, 1, 1, 0, time.Local)
+	result3 := DayOfYear(date3)
+	assert.Equal(0, result3)
+}
+
+func TestIsWeekend(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestIsWeekend")
+
+	date := time.Date(2023, 06, 03, 0, 0, 0, 0, time.Local)
+	result := IsWeekend(date)
+	assert.Equal(true, result)
+
+	date1 := time.Date(2023, 06, 04, 0, 0, 0, 0, time.Local)
+	result1 := IsWeekend(date1)
+	assert.Equal(true, result1)
+
+	date2 := time.Date(2023, 06, 02, 0, 0, 0, 0, time.Local)
+	result2 := IsWeekend(date2)
+	assert.Equal(false, result2)
+}
+
+func TestNowDateOrTime(t *testing.T) {
+	t.Parallel()
+
+	formats := []string{
+		"yyyy-mm-dd hh:mm:ss",
+		"yyyy-mm-dd",
+		"dd-mm-yy hh:mm:ss",
+		"yyyy/mm/dd hh:mm:ss",
+		"hh:mm:ss",
+		"yyyy/mm",
+		"yyyy-mm-dd hh",
+	}
+
+	for i := 0; i < len(formats); i++ {
+		result := NowDateOrTime(formats[i], "UTC")
+		t.Log(result)
+	}
+}
+
+func TestTimestamp(t *testing.T) {
+	t.Parallel()
+
+	ts1 := Timestamp()
+	t.Log(ts1)
+
+	ts2 := TimestampMilli()
+	t.Log(ts2)
+
+	ts3 := TimestampMicro()
+	t.Log(ts3)
+
+	ts4 := TimestampNano()
+	t.Log(ts4)
+}

docs/algorithm.md

@@ -1,17 +1,19 @@
 # Algorithm
+
 Package algorithm implements some basic algorithm. eg. sort, search.
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Source
 
-- [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/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)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/algorithm"
@@ -21,28 +23,26 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## Index
-- [BubbleSort](#BubbleSort)
-- [InsertionSort](#InsertionSort)
-- [SelectionSort](#SelectionSort)
-- [ShellSort](#ShellSort)
-- [QuickSort](#QuickSort)
-- [HeapSort](#HeapSort)
-- [MergeSort](#MergeSort)
-- [CountSort](#CountSort)
-- [BinarySearch](#BinarySearch)
-- [BinaryIterativeSearch](#BinaryIterativeSearch)
-
-- [LinearSearch](#LinearSearch)
-- [LRUCache](#LRUCache)
 
+-   [BubbleSort](#BubbleSort)
+-   [InsertionSort](#InsertionSort)
+-   [SelectionSort](#SelectionSort)
+-   [ShellSort](#ShellSort)
+-   [QuickSort](#QuickSort)
+-   [HeapSort](#HeapSort)
+-   [MergeSort](#MergeSort)
+-   [CountSort](#CountSort)
+-   [BinarySearch](#BinarySearch)
+-   [BinaryIterativeSearch](#BinaryIterativeSearch)
+-   [LinearSearch](#LinearSearch)
+-   [LRUCache](#LRUCache)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
-
-
 ### <span id="BubbleSort">BubbleSort</span>
+
 <p>Sort slice with bubble sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
 <b>Signature:</b>
@@ -50,6 +50,7 @@ import (
 ```go
 func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -60,34 +61,36 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.BubbleSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.BubbleSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="InsertionSort">InsertionSort</span>
+
 <p>Sort slice with insertion sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
 <b>Signature:</b>
@@ -95,6 +98,7 @@ func main() {
 ```go
 func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -105,54 +109,51 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
+type people struct {
+    Name string
+    Age  int
+}
+
+// PeopleAageComparator sort people slice by age field
+type peopleAgeComparator struct{}
+
+// Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
+func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
+    p1, _ := v1.(people)
+    p2, _ := v2.(people)
+
+    //ascending order
+    if p1.Age < p2.Age {
+        return -1
+    } else if p1.Age > p2.Age {
+        return 1
+    }
+
+    return 0
+}
+
 func main() {
-    type people struct {
-        Name string
-        Age  int
-    }
-
-    // PeopleAageComparator sort people slice by age field
-    type peopleAgeComparator struct{}
-
-    // Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
-    func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
-        p1, _ := v1.(people)
-        p2, _ := v2.(people)
-
-        //ascending order
-        if p1.Age < p2.Age {
-            return -1
-        } else if p1.Age > p2.Age {
-            return 1
-        }
-        return 0
-
-        //decending order
-        // if p1.Age > p2.Age {
-        // 	return -1
-        // } else if p1.Age < p2.Age {
-        // 	return 1
-        // }
-    }
-
-    var peoples = []people{
+    peoples := []people{
         {Name: "a", Age: 20},
         {Name: "b", Age: 10},
         {Name: "c", Age: 17},
         {Name: "d", Age: 8},
         {Name: "e", Age: 28},
     }
+
     comparator := &peopleAgeComparator{}
+
     algorithm.InsertionSort(peoples, comparator)
 
-    fmt.Println(peoples) //[{d 8} {b 10} {c 17} {a 20} {e 28}]
+    fmt.Println(peoples)
+
+    // Output:
+    // [{d 8} {b 10} {c 17} {a 20} {e 28}]
 }
 ```
 
-
-
-
 ### <span id="SelectionSort">SelectionSort</span>
+
 <p>Sort slice with selection sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
 <b>Signature:</b>
@@ -160,6 +161,7 @@ func main() {
 ```go
 func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -170,34 +172,36 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.SelectionSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.SelectionSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="ShellSort">ShellSort</span>
+
 <p>Sort slice with shell sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
 <b>Signature:</b>
@@ -205,6 +209,7 @@ func main() {
 ```go
 func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -215,34 +220,36 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.ShellSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.ShellSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="QuickSort">QuickSort</span>
+
 <p>Sort slice with quick sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
 <b>Signature:</b>
@@ -250,6 +257,7 @@ func main() {
 ```go
 func QuickSort[T any](slice []T comparator lancetconstraints.Comparator)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -260,34 +268,36 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.QuickSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.QuickSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="HeapSort">HeapSort</span>
+
 <p>Sort slice with heap sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
 <b>Signature:</b>
@@ -295,6 +305,7 @@ func main() {
 ```go
 func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -305,34 +316,36 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.HeapSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.HeapSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="MergeSort">MergeSort</span>
+
 <p>Sort slice with merge sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
 <b>Signature:</b>
@@ -340,6 +353,7 @@ func main() {
 ```go
 func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -350,33 +364,36 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.MergeSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.MergeSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
 ### <span id="CountSort">CountSort</span>
+
 <p>Sort slice with count sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
 <b>Signature:</b>
@@ -384,6 +401,7 @@ func main() {
 ```go
 func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -394,34 +412,37 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+type intComparator struct{}
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
+
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.CountSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    sortedNums := algorithm.CountSort(numbers, comparator)
+
+    fmt.Println(sortedNums)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="BinarySearch">BinarySearch</span>
+
 <p>BinarySearch search for target within a sorted slice, recursive call itself. If a target is found, the index of the target is returned. Else the function return -1.</p>
 
 <b>Signature:</b>
@@ -429,6 +450,7 @@ func main() {
 ```go
 func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
 ```
+
 <b>Example:</b>
 
 ```go
@@ -439,35 +461,39 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
+func main() {
+    numbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
     comparator := &intComparator{}
-    foundIndex := algorithm.BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
-    fmt.Println(foundIndex) //4
 
-    notFoundIndex := algorithm.BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator)
-    fmt.Println(notFoundIndex) //-1
+    result1 := algorithm.BinarySearch(numbers, 5, 0, len(numbers)-1, comparator)
+    result2 := algorithm.BinarySearch(numbers, 9, 0, len(numbers)-1, comparator)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 4
+    // -1
 }
 ```
 
-
-
 ### <span id="BinaryIterativeSearch">BinaryIterativeSearch</span>
+
 <p>BinaryIterativeSearch search for target within a sorted slice, recursive call itself. If a target is found, the index of the target is returned. Else the function return -1.</p>
 
 <b>Signature:</b>
@@ -475,6 +501,7 @@ func main() {
 ```go
 func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
 ```
+
 <b>Example:</b>
 
 ```go
@@ -485,43 +512,47 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
+func main() {
+    numbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
     comparator := &intComparator{}
-    foundIndex := algorithm.BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
-    fmt.Println(foundIndex) //4
 
-    notFoundIndex := algorithm.BinaryIterativeSearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator)
-    fmt.Println(notFoundIndex) //-1
+    result1 := algorithm.BinaryIterativeSearch(numbers, 5, 0, len(numbers)-1, comparator)
+    result2 := algorithm.BinaryIterativeSearch(numbers, 9, 0, len(numbers)-1, comparator)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 4
+    // -1
 }
 ```
 
-
-
-
 ### <span id="LinearSearch">LinearSearch</span>
-<p>LinearSearch Simple linear search algorithm that iterates over all elements of an slice. If a target is found, the index of the target is returned. Else the function return -1.</p>
+
+<p>return the index of target in slice base on equal function.If a target is found, the index of the target is returned. Else the function return -1.</p>
 
 <b>Signature:</b>
 
 ```go
-func LinearSearch[T any](slice []T, target T, comparator lancetconstraints.Comparator) int
+func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
 ```
+
 <b>Example:</b>
 
 ```go
@@ -533,35 +564,26 @@ import (
 )
 
 func main() {
-    type intComparator struct{}
+    numbers := []int{3, 4, 5, 3, 2, 1}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
-
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    equalFunc := func(a, b int) bool {
+        return a == b
     }
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
-    comparator := &intComparator{}
-    foundIndex := algorithm.LinearSearch(intSlice, 5, comparator)
-    fmt.Println(foundIndex) //2
+    result1 := algorithm.LinearSearch(numbers, 3, equalFunc)
+    result2 := algorithm.LinearSearch(numbers, 6, equalFunc)
 
-    notFoundIndex := algorithm.LinearSearch(sortedNumbers, 0, comparator)
-    fmt.Println(notFoundIndex) //-1
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 0
+    // -1
 }
 ```
 
-
-
-
 ### <span id="LRUCache">LRUCache</span>
+
 <p>LRUCache implements mem cache with lru.</p>
 
 <b>Signature:</b>
@@ -570,7 +592,10 @@ func main() {
 func NewLRUCache[K comparable, V any](capacity int) *LRUCache[K, V]
 func (l *LRUCache[K, V]) Get(key K) (V, bool)
 func (l *LRUCache[K, V]) Put(key K, value V)
+func (l *LRUCache[K, V]) Delete(key K) bool
+func (l *LRUCache[K, V]) Len() int
 ```
+
 <b>Example:</b>
 
 ```go
@@ -587,9 +612,25 @@ func main() {
     cache.Put(1, 1)
     cache.Put(2, 2)
 
-    _, ok := cache.Get(0) // ok -> false
+    result1, ok1 := cache.Get(1)
+    result2, ok2 := cache.Get(2)
+    result3, ok3 := cache.Get(3)
 
-    v, ok := cache.Get(1) // v->1, ok->true
+    fmt.Println(result1, ok1)
+    fmt.Println(result2, ok2)
+    fmt.Println(result3, ok3)
 
+    fmt.Println(cache.Len())
+
+    ok := cache.Delete(2)
+    fmt.Println(ok)
+
+
+    // Output:
+    // 1 true
+    // 2 true
+    // 0 false
+    // 2
+    // true
 }
-```
+```

docs/algorithm_zh-CN.md

@@ -1,17 +1,19 @@
 # Algorithm
-algorithm算法包实现一些基本算法，sort，search，lrucache。
+
+algorithm 算法包实现一些基本算法，sort，search，lrucache。
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码
 
-- [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/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)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 用法
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/algorithm"
@@ -22,36 +24,34 @@ import (
 
 ## 目录
 
-- [BubbleSort](#BubbleSort)
-- [InsertionSort](#InsertionSort)
-- [SelectionSort](#SelectionSort)
-- [ShellSort](#ShellSort)
-- [QuickSort](#QuickSort)
-- [HeapSort](#HeapSort)
-- [MergeSort](#MergeSort)
-
-- [CountSort](#CountSort)
-- [BinarySearch](#BinarySearch)
-- [BinaryIterativeSearch](#BinaryIterativeSearch)
-- [LinearSearch](#LinearSearch)
-- [LRUCache](#LRUCache)
-
+-   [BubbleSort](#BubbleSort)
+-   [InsertionSort](#InsertionSort)
+-   [SelectionSort](#SelectionSort)
+-   [ShellSort](#ShellSort)
+-   [QuickSort](#QuickSort)
+-   [HeapSort](#HeapSort)
+-   [MergeSort](#MergeSort)
+-   [CountSort](#CountSort)
+-   [BinarySearch](#BinarySearch)
+-   [BinaryIterativeSearch](#BinaryIterativeSearch)
+-   [LinearSearch](#LinearSearch)
+-   [LRUCache](#LRUCache)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
-
-
 ### <span id="BubbleSort">BubbleSort</span>
-<p>冒泡排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<p>冒泡排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
 func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -61,42 +61,45 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.BubbleSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.BubbleSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="InsertionSort">InsertionSort</span>
-<p>插入排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<p>插入排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
 func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -106,62 +109,60 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
+type people struct {
+    Name string
+    Age  int
+}
+
+// PeopleAageComparator sort people slice by age field
+type peopleAgeComparator struct{}
+
+// Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
+func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
+    p1, _ := v1.(people)
+    p2, _ := v2.(people)
+
+    //ascending order
+    if p1.Age < p2.Age {
+        return -1
+    } else if p1.Age > p2.Age {
+        return 1
+    }
+
+    return 0
+}
+
 func main() {
-    type people struct {
-        Name string
-        Age  int
-    }
-
-    // PeopleAageComparator sort people slice by age field
-    type peopleAgeComparator struct{}
-
-    // Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
-    func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
-        p1, _ := v1.(people)
-        p2, _ := v2.(people)
-
-        //ascending order
-        if p1.Age < p2.Age {
-            return -1
-        } else if p1.Age > p2.Age {
-            return 1
-        }
-        return 0
-
-        //decending order
-        // if p1.Age > p2.Age {
-        // 	return -1
-        // } else if p1.Age < p2.Age {
-        // 	return 1
-        // }
-    }
-
-    var peoples = []people{
+    peoples := []people{
         {Name: "a", Age: 20},
         {Name: "b", Age: 10},
         {Name: "c", Age: 17},
         {Name: "d", Age: 8},
         {Name: "e", Age: 28},
     }
+
     comparator := &peopleAgeComparator{}
+
     algorithm.InsertionSort(peoples, comparator)
 
-    fmt.Println(intSlice) //[{d 8} {b 10} {c 17} {a 20} {e 28}]
+    fmt.Println(peoples)
+
+    // Output:
+    // [{d 8} {b 10} {c 17} {a 20} {e 28}]
 }
 ```
 
-
-
-
 ### <span id="SelectionSort">SelectionSort</span>
-<p>选择排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<p>选择排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
 func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -171,42 +172,45 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.SelectionSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.SelectionSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="ShellSort">ShellSort</span>
-<p>希尔排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<p>希尔排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -216,42 +220,45 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.ShellSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.ShellSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="QuickSort">QuickSort</span>
-<p>快速排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<p>快速排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func QuickSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func QuickSort[T any](slice []T comparator lancetconstraints.Comparator)
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -261,42 +268,45 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.QuickSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.QuickSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="HeapSort">HeapSort</span>
-<p>堆排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<p>堆排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -306,42 +316,45 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.HeapSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.HeapSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="MergeSort">MergeSort</span>
-<p>归并排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<p>归并排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
 func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -351,41 +364,45 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    algorithm.MergeSort(intSlice, comparator)
 
-    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+    algorithm.MergeSort(numbers, comparator)
+
+    fmt.Println(numbers)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
 ### <span id="CountSort">CountSort</span>
-<p>计数排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<p>计数排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
 func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -395,42 +412,46 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+type intComparator struct{}
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
+
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+func main() {
+    numbers := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.CountSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    sortedNums := algorithm.CountSort(numbers, comparator)
+
+    fmt.Println(sortedNums)
+
+    // Output:
+    // [1 2 3 4 5 6]
 }
 ```
 
-
-
-
 ### <span id="BinarySearch">BinarySearch</span>
-<p>二分递归查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<p>二分递归查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
 func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -440,43 +461,48 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
+func main() {
+    numbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
     comparator := &intComparator{}
-    foundIndex := algorithm.BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
-    fmt.Println(foundIndex) //4
 
-    notFoundIndex := algorithm.BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator)
-    fmt.Println(notFoundIndex) //-1
+    result1 := algorithm.BinarySearch(numbers, 5, 0, len(numbers)-1, comparator)
+    result2 := algorithm.BinarySearch(numbers, 9, 0, len(numbers)-1, comparator)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 4
+    // -1
 }
 ```
 
-
-
 ### <span id="BinaryIterativeSearch">BinaryIterativeSearch</span>
-<p>二分迭代查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<p>二分迭代查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
 func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -486,44 +512,48 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
+type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
+func (c *intComparator) Compare(v1 any, v2 any) int {
+    val1, _ := v1.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    //ascending order
+    if val1 < val2 {
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
-    var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
+func main() {
+    numbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
     comparator := &intComparator{}
-    foundIndex := algorithm.BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
-    fmt.Println(foundIndex) //4
 
-    notFoundIndex := algorithm.BinaryIterativeSearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator)
-    fmt.Println(notFoundIndex) //-1
+    result1 := algorithm.BinaryIterativeSearch(numbers, 5, 0, len(numbers)-1, comparator)
+    result2 := algorithm.BinaryIterativeSearch(numbers, 9, 0, len(numbers)-1, comparator)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 4
+    // -1
 }
 ```
 
-
-
-
 ### <span id="LinearSearch">LinearSearch</span>
-<p>线性查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<p>基于传入的相等函数线性查找元素，返回元素索引，未找到元素返回-1。</p>
 
 <b>函数签名:</b>
 
 ```go
-func LinearSearch[T any](slice []T, target T, comparator lancetconstraints.Comparator) int
+func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -534,36 +564,27 @@ import (
 )
 
 func main() {
-    type intComparator struct{}
+    numbers := []int{3, 4, 5, 3, 2, 1}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
-
-        //ascending order
-        if val1 < val2 {
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
+    equalFunc := func(a, b int) bool {
+        return a == b
     }
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
-    comparator := &intComparator{}
-    foundIndex := algorithm.LinearSearch(intSlice, 5, comparator)
-    fmt.Println(foundIndex) //2
+    result1 := algorithm.LinearSearch(numbers, 3, equalFunc)
+    result2 := algorithm.LinearSearch(numbers, 6, equalFunc)
 
-    notFoundIndex := algorithm.LinearSearch(sortedNumbers, 0, comparator)
-    fmt.Println(notFoundIndex) //-1
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 0
+    // -1
 }
 ```
 
-
-
-
 ### <span id="LRUCache">LRUCache</span>
-<p>lru实现缓存</p>
+
+<p>lru算法实现缓存。</p>
 
 <b>函数签名:</b>
 
@@ -571,8 +592,11 @@ func main() {
 func NewLRUCache[K comparable, V any](capacity int) *LRUCache[K, V]
 func (l *LRUCache[K, V]) Get(key K) (V, bool)
 func (l *LRUCache[K, V]) Put(key K, value V)
+func (l *LRUCache[K, V]) Delete(key K) bool
+func (l *LRUCache[K, V]) Len() int
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -588,9 +612,25 @@ func main() {
     cache.Put(1, 1)
     cache.Put(2, 2)
 
-    _, ok := cache.Get(0) // ok -> false
+    result1, ok1 := cache.Get(1)
+    result2, ok2 := cache.Get(2)
+    result3, ok3 := cache.Get(3)
 
-    v, ok := cache.Get(1) // v->1, ok->true
+    fmt.Println(result1, ok1)
+    fmt.Println(result2, ok2)
+    fmt.Println(result3, ok3)
 
+    fmt.Println(cache.Len())
+
+    ok := cache.Delete(2)
+    fmt.Println(ok)
+
+
+    // Output:
+    // 1 true
+    // 2 true
+    // 0 false
+    // 2
+    // true
 }
-```
+```

docs/compare.md

@@ -0,0 +1,374 @@
+# Compare
+
+Package compare provides a lightweight comparison function on any type.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+-   [https://github.com/duke-git/lancet/blob/main/compare/compare.go](https://github.com/duke-git/lancet/blob/main/compare/compare.go)
+
+-   [https://github.com/duke-git/lancet/blob/main/compare/compare_internal.go](https://github.com/duke-git/lancet/blob/main/compare/compare_internal.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/condition"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+-   [Equal](#Equal)
+-   [EqualValue](#EqualValue)
+-   [LessThan](#LessThan)
+-   [GreaterThan](#GreaterThan)
+-   [LessOrEqual](#LessOrEqual)
+-   [GreaterOrEqual](#GreaterOrEqual)
+-   [InDelta](#InDelta)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### <span id="Equal">Equal</span>
+
+<p>Checks if two values are equal or not. (check both type and value)</p>
+
+<b>Signature:</b>
+
+```go
+func Equal(left, right any) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.Equal(1, 1)
+    result2 := compare.Equal("1", "1")
+    result3 := compare.Equal([]int{1, 2, 3}, []int{1, 2, 3})
+    result4 := compare.Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"})
+
+    result5 := compare.Equal(1, "1")
+    result6 := compare.Equal(1, int64(1))
+    result7 := compare.Equal([]int{1, 2}, []int{1, 2, 3})
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+    fmt.Println(result7)
+
+    // Output:
+    // true
+    // true
+    // true
+    // true
+    // false
+    // false
+    // false
+}
+```
+
+### <span id="EqualValue">EqualValue</span>
+
+<p>Checks if two values are equal or not. (check value only)</p>
+
+<b>Signature:</b>
+
+```go
+func EqualValue(left, right any) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.EqualValue(1, 1)
+    result2 := compare.EqualValue(int(1), int64(1))
+    result3 := compare.EqualValue(1, "1")
+    result4 := compare.EqualValue(1, "2")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // true
+    // false
+}
+```
+
+### <span id="LessThan">LessThan</span>
+
+<p>Checks if value `left` less than value `right`.</p>
+
+<b>Signature:</b>
+
+```go
+func LessThan(left, right any) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.LessThan(1, 2)
+    result2 := compare.LessThan(1.1, 2.2)
+    result3 := compare.LessThan("a", "b")
+
+    time1 := time.Now()
+    time2 := time1.Add(time.Second)
+    result4 := compare.LessThan(time1, time2)
+
+    result5 := compare.LessThan(2, 1)
+    result6 := compare.LessThan(1, int64(2))
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // true
+    // true
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="GreaterThan">GreaterThan</span>
+
+<p>Checks if value `left` greater than value `right`.</p>
+
+<b>Signature:</b>
+
+```go
+func GreaterThan(left, right any) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.GreaterThan(2, 1)
+    result2 := compare.GreaterThan(2.2, 1.1)
+    result3 := compare.GreaterThan("b", "a")
+
+    time1 := time.Now()
+    time2 := time1.Add(time.Second)
+    result4 := compare.GreaterThan(time2, time1)
+
+    result5 := compare.GreaterThan(1, 2)
+    result6 := compare.GreaterThan(int64(2), 1)
+    result7 := compare.GreaterThan("b", "c")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+    fmt.Println(result7)
+
+    // Output:
+    // true
+    // true
+    // true
+    // true
+    // false
+    // false
+    // false
+}
+```
+
+### <span id="LessOrEqual">LessOrEqual</span>
+
+<p>Checks if value `left` less than or equal than value `right`.</p>
+
+<b>Signature:</b>
+
+```go
+func LessOrEqual(left, right any) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.LessOrEqual(1, 1)
+    result2 := compare.LessOrEqual(1.1, 2.2)
+    result3 := compare.LessOrEqual("a", "b")
+
+    time1 := time.Now()
+    time2 := time1.Add(time.Second)
+    result4 := compare.LessOrEqual(time1, time2)
+
+    result5 := compare.LessOrEqual(2, 1)
+    result6 := compare.LessOrEqual(1, int64(2))
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // true
+    // true
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="GreaterOrEqual">GreaterOrEqual</span>
+
+<p>Checks if value `left` less greater or equal than value `right`.</p>
+
+<b>Signature:</b>
+
+```go
+func GreaterOrEqual(left, right any) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.GreaterOrEqual(1, 1)
+    result2 := compare.GreaterOrEqual(2.2, 1.1)
+    result3 := compare.GreaterOrEqual("b", "b")
+
+    time1 := time.Now()
+    time2 := time1.Add(time.Second)
+    result4 := compare.GreaterOrEqual(time2, time1)
+
+    result5 := compare.GreaterOrEqual(1, 2)
+    result6 := compare.GreaterOrEqual(int64(2), 1)
+    result7 := compare.GreaterOrEqual("b", "c")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+    fmt.Println(result7)
+
+    // Output:
+    // true
+    // true
+    // true
+    // true
+    // false
+    // false
+    // false
+}
+```
+
+### <span id="InDelta">InDelta</span>
+
+<p>Checks if two values are equal or not within a delta.</p>
+
+<b>Signature:</b>
+
+```go
+func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := InDelta(1, 1, 0)
+    result2 := InDelta(1, 2, 0)
+
+    result3 := InDelta(2.0/3.0, 0.66667, 0.001)
+    result4 := InDelta(2.0/3.0, 0.0, 0.001)
+
+    result5 := InDelta(float64(74.96)-float64(20.48), 54.48, 0)
+    result6 := InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // true
+    // false
+    // true
+    // false
+    // false
+    // true
+}
+```

docs/compare_zh-CN.md

@@ -0,0 +1,375 @@
+# Compare
+
+compare包提供几个轻量级的类型比较函数。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/compare/compare.go](https://github.com/duke-git/lancet/blob/main/compare/compare.go)
+
+-   [https://github.com/duke-git/lancet/blob/main/compare/compare_internal.go](https://github.com/duke-git/lancet/blob/main/compare/compare_internal.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/condition"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [Equal](#Equal)
+-   [EqualValue](#EqualValue)
+-   [LessThan](#LessThan)
+-   [GreaterThan](#GreaterThan)
+-   [LessOrEqual](#LessOrEqual)
+-   [GreaterOrEqual](#GreaterOrEqual)
+-   [InDelta](#InDelta)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### <span id="Equal">Equal</span>
+
+<p>检查两个值是否相等(检查类型和值)</p>
+
+<b>函数签名:</b>
+
+```go
+func Equal(left, right any) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.Equal(1, 1)
+    result2 := compare.Equal("1", "1")
+    result3 := compare.Equal([]int{1, 2, 3}, []int{1, 2, 3})
+    result4 := compare.Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"})
+
+    result5 := compare.Equal(1, "1")
+    result6 := compare.Equal(1, int64(1))
+    result7 := compare.Equal([]int{1, 2}, []int{1, 2, 3})
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+    fmt.Println(result7)
+
+    // Output:
+    // true
+    // true
+    // true
+    // true
+    // false
+    // false
+    // false
+}
+```
+
+### <span id="EqualValue">EqualValue</span>
+
+<p>检查两个值是否相等(只检查值)</p>
+
+<b>函数签名:</b>
+
+```go
+func EqualValue(left, right any) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.EqualValue(1, 1)
+    result2 := compare.EqualValue(int(1), int64(1))
+    result3 := compare.EqualValue(1, "1")
+    result4 := compare.EqualValue(1, "2")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // true
+    // false
+}
+```
+
+### <span id="LessThan">LessThan</span>
+
+<p>验证参数`left`的值是否小于参数`right`的值。</p>
+
+<b>函数签名:</b>
+
+```go
+func LessThan(left, right any) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.LessThan(1, 2)
+    result2 := compare.LessThan(1.1, 2.2)
+    result3 := compare.LessThan("a", "b")
+
+    time1 := time.Now()
+    time2 := time1.Add(time.Second)
+    result4 := compare.LessThan(time1, time2)
+
+    result5 := compare.LessThan(2, 1)
+    result6 := compare.LessThan(1, int64(2))
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // true
+    // true
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="GreaterThan">GreaterThan</span>
+
+<p>验证参数`left`的值是否大于参数`right`的值。</p>
+
+<b>函数签名:</b>
+
+```go
+func GreaterThan(left, right any) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.GreaterThan(2, 1)
+    result2 := compare.GreaterThan(2.2, 1.1)
+    result3 := compare.GreaterThan("b", "a")
+
+    time1 := time.Now()
+    time2 := time1.Add(time.Second)
+    result4 := compare.GreaterThan(time2, time1)
+
+    result5 := compare.GreaterThan(1, 2)
+    result6 := compare.GreaterThan(int64(2), 1)
+    result7 := compare.GreaterThan("b", "c")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+    fmt.Println(result7)
+
+    // Output:
+    // true
+    // true
+    // true
+    // true
+    // false
+    // false
+    // false
+}
+```
+
+### <span id="LessOrEqual">LessOrEqual</span>
+
+<p>验证参数`left`的值是否小于或等于参数`right`的值。</p>
+
+<b>函数签名:</b>
+
+```go
+func LessOrEqual(left, right any) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.LessOrEqual(1, 1)
+    result2 := compare.LessOrEqual(1.1, 2.2)
+    result3 := compare.LessOrEqual("a", "b")
+
+    time1 := time.Now()
+    time2 := time1.Add(time.Second)
+    result4 := compare.LessOrEqual(time1, time2)
+
+    result5 := compare.LessOrEqual(2, 1)
+    result6 := compare.LessOrEqual(1, int64(2))
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // true
+    // true
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="GreaterOrEqual">GreaterOrEqual</span>
+
+<p>验证参数`left`的值是否大于或参数`right`的值。</p>
+
+<b>函数签名:</b>
+
+```go
+func GreaterOrEqual(left, right any) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := compare.GreaterOrEqual(1, 1)
+    result2 := compare.GreaterOrEqual(2.2, 1.1)
+    result3 := compare.GreaterOrEqual("b", "b")
+
+    time1 := time.Now()
+    time2 := time1.Add(time.Second)
+    result4 := compare.GreaterOrEqual(time2, time1)
+
+    result5 := compare.GreaterOrEqual(1, 2)
+    result6 := compare.GreaterOrEqual(int64(2), 1)
+    result7 := compare.GreaterOrEqual("b", "c")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+    fmt.Println(result7)
+
+    // Output:
+    // true
+    // true
+    // true
+    // true
+    // false
+    // false
+    // false
+}
+```
+
+### <span id="InDelta">InDelta</span>
+
+<p>检查增量内两个值是否相等。</p>
+
+<b>函数签名:</b>
+
+```go
+func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := InDelta(1, 1, 0)
+    result2 := InDelta(1, 2, 0)
+
+    result3 := InDelta(2.0/3.0, 0.66667, 0.001)
+    result4 := InDelta(2.0/3.0, 0.0, 0.001)
+
+    result5 := InDelta(float64(74.96)-float64(20.48), 54.48, 0)
+    result6 := InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // true
+    // false
+    // true
+    // false
+    // false
+    // true
+}
+```

docs/concurrency.md

@@ -1,5 +1,5 @@
 # Concurrency
-Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel, async.
+Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel.
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -38,13 +38,13 @@ import (
 
 ## Channel
 ### <span id="NewChannel">NewChannel</span>
-<p>return a Channel pointer instance.</p>
+<p>Create a Channel pointer instance.</p>
 
 <b>Signature:</b>
 
 ```go
-type Channel struct {}
-func NewChannel() *Channel
+type Channel[T any] struct
+func NewChannel[T any]() *Channel[T]
 ```
 <b>Example:</b>
 
@@ -57,12 +57,10 @@ import (
 )
 
 func main() {
-    c := concurrency.NewChannel()
+    c := concurrency.NewChannel[int]()
 }
 ```
 
-
-
 ### <span id="Bridge">Bridge</span>
 
 <p>Link multiple channels into one channel until cancel the context.</p>
@@ -70,7 +68,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func (c *Channel) Bridge(ctx context.Context, chanStream <-chan <-chan any) <-chan any
+func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T
 ```
 <b>Example:</b>
 
@@ -84,42 +82,45 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel()
-	genVals := func() <-chan <-chan any {
-		chanStream := make(chan (<-chan any))
-		go func() {
-			defer close(chanStream)
-			for i := 0; i < 10; i++ {
-				stream := make(chan any, 1)
-				stream <- i
-				close(stream)
-				chanStream <- stream
-			}
-		}()
-		return chanStream
-	}
+    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
+    }
 
-	index := 0
-	for val := range c.Bridge(ctx, genVals()) {
-		fmt.Printf("%v ", val) //0 1 2 3 4 5 6 7 8 9
-	}
+    for v := range c.Bridge(ctx, genVals()) {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 3
+    // 4
+    // 5
 }
 ```
 
-
-
-
 ### <span id="FanIn">FanIn</span>
 
-<p>merge multiple channels into one channel until cancel the context.</p>
+<p>Merge multiple channels into one channel until cancel the context.</p>
 
 <b>Signature:</b>
 
 ```go
-func (c *Channel) FanIn(ctx context.Context, channels ...<-chan any) <-chan any
+func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T
 ```
 <b>Example:</b>
 
@@ -133,33 +134,32 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel()
-	channels := make([]<-chan any, 3)
+    c := concurrency.NewChannel[int]()
+    channels := make([]<-chan int, 2)
 
-	for i := 0; i < 3; i++ {
-		channels[i] = c.Take(ctx, c.Repeat(ctx, i), 3)
-	}
+    for i := 0; i < 2; i++ {
+        channels[i] = c.Take(ctx, c.Repeat(ctx, i), 2)
+    }
 
-	mergedChannel := c.FanIn(ctx, channels...)
+    chs := c.FanIn(ctx, channels...)
 
-	for val := range mergedChannel {
-		fmt.Println("\t%d\n", val) //1,2,1,0,0,1,0,2,2 (order not for sure)
-	}
+    for v := range chs {
+        fmt.Println(v) //1 1 0 0 or 0 0 1 1
+    }
 }
 ```
 
-
 ### <span id="Repeat">Repeat</span>
 
-<p>Return a chan, put param `values` into the chan repeatly until cancel the context.</p>
+<p>Create channel, put values into the channel repeatly until cancel the context.</p>
 
 <b>Signature:</b>
 
 ```go
-func (c *Channel) Repeat(ctx context.Context, values ...any) <-chan any
+func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T
 ```
 <b>Example:</b>
 
@@ -173,29 +173,70 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 5)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
 
-	for v := range intStream {
-	fmt.Println(v) //1, 2, 1, 2, 1
-	}
+    for v := range intStream {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 1
+    // 2
 }
 ```
 
+### <span id="Generate">Generate</span>
 
+<p>Creates a channel, then put values into the channel.</p>
 
+<b>Signature:</b>
+
+```go
+func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T
+```
+<b>Example:</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="RepeatFn">RepeatFn</span>
 
-<p>Return a chan, excutes fn repeatly, and put the result into retruned chan until cancel context.</p>
+<p>Create a channel, excutes fn repeatly, and put the result into the channel, until close context.</p>
 
 <b>Signature:</b>
 
 ```go
-func (c *Channel) RepeatFn(ctx context.Context, fn func() any) <-chan any
+func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T
 ```
 <b>Example:</b>
 
@@ -209,24 +250,27 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	fn := func() any {
-		s := "a"
-		return s
-	}
-	c := concurrency.NewChannel()
-	dataStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
+    fn := func() string {
+        return "hello"
+    }
 
-	for v := range dataStream {
-		fmt.Println(v) //a, a, a
-	}
+    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>Read one or more channels into one channel, will close when any readin channel is closed.</p>
@@ -234,7 +278,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func (c *Channel) Or(channels ...<-chan any) <-chan any
+func (c *Channel[T]) Or(channels ...<-chan T) <-chan T
 ```
 <b>Example:</b>
 
@@ -248,33 +292,28 @@ import (
 )
 
 func main() {
-	sig := func(after time.Duration) <-chan any {
-		c := make(chan interface{})
-		go func() {
-			defer close(c)
-			time.Sleep(after)
-		}()
-		return c
-	}
+    sig := func(after time.Duration) <-chan any {
+        c := make(chan any)
+        go func() {
+            defer close(c)
+            time.Sleep(after)
+        }()
+        return c
+    }
 
-	start := time.Now()
+    start := time.Now()
 
-	c := concurrency.NewChannel()
-	<-c.Or(
-		sig(1*time.Second),
-		sig(2*time.Second),
-		sig(3*time.Second),
-		sig(4*time.Second),
-		sig(5*time.Second),
-	)
+    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
+    fmt.Println("done after %v", time.Since(start)) //1.003s
 }
 ```
 
-
-
-
 ### <span id="OrDone">OrDone</span>
 
 <p>Read a channel into another channel, will close until cancel context.</p>
@@ -282,7 +321,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func (c *Channel) OrDone(ctx context.Context, channel <-chan any) <-chan any
+func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T
 ```
 <b>Example:</b>
 
@@ -296,29 +335,31 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
 
-	for val := range c.OrDone(ctx, intStream) {
-		fmt.Println(val)  //1
-	}
+    for v := range c.OrDone(ctx, intStream) {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 1
+    // 1
 }
 ```
 
-
-
-
 ### <span id="Take">Take</span>
 
-<p>Return a chan whose values are tahken from another chan until cancel context.</p>
+<p>Create a channel whose values are taken from another channel with limit number.</p>
 
 <b>Signature:</b>
 
 ```go
-func (c *Channel) Take(ctx context.Context, valueStream <-chan any, number int) <-chan any
+func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T
 ```
 <b>Example:</b>
 
@@ -332,36 +373,39 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	numbers := make(chan any, 5)
-	numbers <- 1
-	numbers <- 2
-	numbers <- 3
-	numbers <- 4
-	numbers <- 5
-	defer close(numbers)
+    numbers := make(chan int, 5)
+    numbers <- 1
+    numbers <- 2
+    numbers <- 3
+    numbers <- 4
+    numbers <- 5
+    defer close(numbers)
 
-	c := concurrency.NewChannel()
-	intStream := c.Take(ctx, numbers, 3)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, numbers, 3)
 
-	for val := range intStream {
-		fmt.Println(val) //1, 2, 3
-	}
+    for v := range intStream {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 3
 }
 ```
 
-
-
 ### <span id="Tee">Tee</span>
 
-<p>Split one chanel into two channels until cancel context.</p>
+<p>Split one chanel into two channels, until cancel the context.</p>
 
 <b>Signature:</b>
 
 ```go
-func (c *Channel) Tee(ctx context.Context, in <-chan any) (<-chan any, <-chan any)
+func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)
 ```
 <b>Example:</b>
 
@@ -375,16 +419,23 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel()
-	inStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1), 2)
 
-	out1, out2 := c.Tee(ctx, inStream)
-	for val := range out1 {
-		fmt.Println(val) //1
-		fmt.Println(<-out2) //1
-	}
+    ch1, ch2 := c.Tee(ctx, intStream)
+
+    for v := range ch1 {
+        fmt.Println(v)
+        fmt.Println(<-ch2)
+    }
+    
+    // Output:
+    // 1
+    // 1
+    // 1
+    // 1
 }
 ```

docs/concurrency_zh-CN.md

@@ -1,5 +1,5 @@
 # Concurrency
-并发包包含一些支持并发编程的功能。例如：goroutine, channel, async等。
+并发包包含一些支持并发编程的功能。例如：goroutine, channel等。
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -38,15 +38,15 @@ import (
 
 ### Channel
 ### <span id="NewChannel">NewChannel</span>
-<p>返回一个 Channel 指针实例</p>
+<p>返回一个Channel指针实例</p>
 
 <b>函数签名:</b>
 
 ```go
-type Channel struct {}
-func NewChannel() *Channel
+type Channel[T any] struct
+func NewChannel[T any]() *Channel[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -57,22 +57,20 @@ import (
 )
 
 func main() {
-    c := concurrency.NewChannel()
+    c := concurrency.NewChannel[int]()
 }
 ```
 
-
-
 ### <span id="Bridge">Bridge</span>
 
-<p>将多个通道链接到一个通道，直到取消上下文。</p>
+<p>将多个channel链接到一个channel，直到取消上下文。</p>
 
 <b>函数签名:</b>
 
 ```go
-func (c *Channel) Bridge(ctx context.Context, chanStream <-chan <-chan any) <-chan any
+func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -85,43 +83,46 @@ import (
 
 func main() {
     ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    defer cancel()
 
-	c := concurrency.NewChannel()
-	genVals := func() <-chan <-chan any {
-		chanStream := make(chan (<-chan any))
-		go func() {
-			defer close(chanStream)
-			for i := 0; i < 10; i++ {
-				stream := make(chan any, 1)
-				stream <- i
-				close(stream)
-				chanStream <- stream
-			}
-		}()
-		return chanStream
-	}
+    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
+    }
 
-	index := 0
-	for val := range c.Bridge(ctx, genVals()) {
-		fmt.Printf("%v ", val) //0 1 2 3 4 5 6 7 8 9
-	}
+    for v := range c.Bridge(ctx, genVals()) {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 3
+    // 4
+    // 5
 }
 ```
 
-
-
-
 ### <span id="FanIn">FanIn</span>
 
-<p>将多个通道合并为一个通道，直到取消上下文</p>
+<p>将多个channel合并为一个channel，直到取消上下文。</p>
 
 <b>函数签名:</b>
 
 ```go
-func (c *Channel) FanIn(ctx context.Context, channels ...<-chan any) <-chan any
+func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -134,34 +135,71 @@ import (
 
 func main() {
     ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    defer cancel()
 
-	c := concurrency.NewChannel()
-	channels := make([]<-chan any, 3)
+    c := concurrency.NewChannel[int]()
+    channels := make([]<-chan int, 2)
 
-	for i := 0; i < 3; i++ {
-		channels[i] = c.Take(ctx, c.Repeat(ctx, i), 3)
-	}
+    for i := 0; i < 2; i++ {
+        channels[i] = c.Take(ctx, c.Repeat(ctx, i), 2)
+    }
 
-	mergedChannel := c.FanIn(ctx, channels...)
+    chs := c.FanIn(ctx, channels...)
 
-	for val := range mergedChannel {
-		fmt.Println("\t%d\n", val) //1,2,1,0,0,1,0,2,2 (order not for sure)
-	}
+    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>示例:</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>返回一个chan，将参数`values`重复放入chan，直到取消上下文。</p>
+<p>返回一个channel，将参数`values`重复放入channel，直到取消上下文。</p>
 
 <b>函数签名:</b>
 
 ```go
-func (c *Channel) Repeat(ctx context.Context, values ...any) <-chan any
+func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -174,30 +212,33 @@ import (
 
 func main() {
     ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    defer cancel()
 
-	c := concurrency.NewChannel()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 5)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
 
-	for v := range intStream {
-		fmt.Println(v) //1, 2, 1, 2, 1
-	}
+    for v := range intStream {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 1
+    // 2
 }
 ```
 
-
-
-
 ### <span id="RepeatFn">RepeatFn</span>
 
-<p>返回一个chan，重复执行函数fn，并将结果放入返回的chan，直到取消上下文。</p>
+<p>返回一个channel，重复执行函数fn，并将结果放入返回的channel，直到取消上下文。</p>
 
 <b>函数签名:</b>
 
 ```go
-func (c *Channel) RepeatFn(ctx context.Context, fn func() any) <-chan any
+func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -210,33 +251,35 @@ import (
 
 func main() {
     ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    defer cancel()
 
-	fn := func() any {
-		s := "a"
-		return s
-	}
-	c := concurrency.NewChannel()
-	dataStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
+    fn := func() string {
+        return "hello"
+    }
 
-	for v := range dataStream {
-		fmt.Println(v) //a, a, a
-	}
+    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>将一个或多个通道读取到一个通道中，当任何读取通道关闭时将结束读取。</p>
+<p>将一个或多个channel读取到一个channel中，当任何读取channel关闭时将结束读取。</p>
 
 <b>函数签名:</b>
 
 ```go
-func (c *Channel) Or(channels ...<-chan any) <-chan any
+func (c *Channel[T]) Or(channels ...<-chan T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -248,43 +291,38 @@ import (
 )
 
 func main() {
-	sig := func(after time.Duration) <-chan any {
-		c := make(chan interface{})
-		go func() {
-			defer close(c)
-			time.Sleep(after)
-		}()
-		return c
-	}
+    sig := func(after time.Duration) <-chan any {
+        c := make(chan any)
+        go func() {
+            defer close(c)
+            time.Sleep(after)
+        }()
+        return c
+    }
 
-	start := time.Now()
+    start := time.Now()
 
-	c := concurrency.NewChannel()
-	<-c.Or(
-		sig(1*time.Second),
-		sig(2*time.Second),
-		sig(3*time.Second),
-		sig(4*time.Second),
-		sig(5*time.Second),
-	)
+    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
+    fmt.Println("done after %v", time.Since(start)) //1.003s
 }
 ```
 
-
-
-
 ### <span id="OrDone">OrDone</span>
 
-<p>将一个通道读入另一个通道，直到取消上下文。</p>
+<p>将一个channel读入另一个channel，直到取消上下文。</p>
 
 <b>函数签名:</b>
 
 ```go
-func (c *Channel) OrDone(ctx context.Context, channel <-chan any) <-chan any
+func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -296,31 +334,33 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
 
-	for val := range c.OrDone(ctx, intStream) {
-		fmt.Println(val)  //1
-	}
+    for v := range c.OrDone(ctx, intStream) {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 1
+    // 1
 }
 ```
 
-
-
-
 ### <span id="Take">Take</span>
 
-<p>返回一个chan，其值从另一个chan获取，直到取消上下文。</p>
+<p>返回一个channel，其值从另一个channel获取，直到取消上下文。</p>
 
 <b>函数签名:</b>
 
 ```go
-func (c *Channel) Take(ctx context.Context, valueStream <-chan any, number int) <-chan any
+func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -332,38 +372,41 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	numbers := make(chan any, 5)
-	numbers <- 1
-	numbers <- 2
-	numbers <- 3
-	numbers <- 4
-	numbers <- 5
-	defer close(numbers)
+    numbers := make(chan int, 5)
+    numbers <- 1
+    numbers <- 2
+    numbers <- 3
+    numbers <- 4
+    numbers <- 5
+    defer close(numbers)
 
-	c := concurrency.NewChannel()
-	intStream := c.Take(ctx, numbers, 3)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, numbers, 3)
 
-	for val := range intStream {
-		fmt.Println(val) //1, 2, 3
-	}
+    for v := range intStream {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 3
 }
 ```
 
-
-
 ### <span id="Tee">Tee</span>
 
-<p>将一个通道分成两个通道，直到取消上下文。</p>
+<p>将一个channel分成两个channel，直到取消上下文。</p>
 
 <b>函数签名:</b>
 
 ```go
-func (c *Channel) Tee(ctx context.Context, in <-chan any) (<-chan any, <-chan any)
+func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -375,16 +418,22 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel()
-	inStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1), 2)
 
-	out1, out2 := c.Tee(ctx, inStream)
-	for val := range out1 {
-		fmt.Println(val) //1
-		fmt.Println(<-out2) //1
-	}
+    ch1, ch2 := c.Tee(ctx, intStream)
+
+    for v := range ch1 {
+        fmt.Println(v)
+        fmt.Println(<-ch2)
+    }
+    // Output:
+    // 1
+    // 1
+    // 1
+    // 1
 }
 ```

docs/condition.md

@@ -25,6 +25,7 @@ import (
 - [Or](#Or)
 - [Xor](#Generate)
 - [Nor](#Nor)
+- [Xnor](#Xnor)
 - [Nand](#Nand)
 - [TernaryOperator](#TernaryOperator)
 
@@ -56,41 +57,52 @@ import (
 )
 
 func main() {
-	// bool
-	fmt.Println(condition.Bool(false)) // false
-	fmt.Println(condition.Bool(true)) // true
+    // bool
+    result1 := condition.Bool(false)
+    result2 := condition.Bool(true)
+    fmt.Println(result1) // false
+    fmt.Println(result2) // true
 
-	// integer
-	fmt.Println(condition.Bool(0)) // false
-	fmt.Println(condition.Bool(1)) // true
+    // integer
+    result3 := condition.Bool(0) 
+    result4 := condition.Bool(1)
+    fmt.Println(result3) // false
+    fmt.Println(result4) // true
 
-	// float
-	fmt.Println(condition.Bool(0.0)) // false
-	fmt.Println(condition.Bool(0.1)) // true
+    // string
+    result5 := condition.Bool("")
+    result6 := condition.Bool(" ")
+    fmt.Println(result5) // false
+    fmt.Println(result6) // true
 
-	// string
-	fmt.Println(condition.Bool("")) // false
-	fmt.Println(condition.Bool(" ")) // true
-	fmt.Println(condition.Bool("0")) // true
+    // slice
+    nums := []int{}
+    result7 := condition.Bool(nums)
 
-	// slice
-	var nums [2]int
-	fmt.Println(condition.Bool(nums)) // false
-	nums = [2]int{0, 1}
-	fmt.Println(condition.Bool(nums)) // true
+    nums = append(nums, 1, 2)
+    result8 := condition.Bool(nums)
+    fmt.Println(result7) // false
+    fmt.Println(result8) // true
 
-	// map
-	fmt.Println(condition.Bool(map[string]string{})) // false
-	fmt.Println(condition.Bool(map[string]string{"a": "a"})) // true
+    // struct
+    result9 = condition.Bool(struct{}{})
+    fmt.Println(result8) // false
 
-	// struct
-	fmt.Println(condition.Bool(struct{}{})) // false
-	fmt.Println(condition.Bool(time.Now())) // true
+
+    // Output:
+    // false
+    // true
+    // false
+    // true
+    // false
+    // true
+    // false
+    // true
+    // false
 }
 ```
 
 
-
 ### <span id="And">And</span>
 <p>Returns true if both a and b are truthy.</p>
 
@@ -110,17 +122,17 @@ import (
 )
 
 func main() {
-	fmt.Println(condition.And(0, 1)) // false
-	fmt.Println(condition.And(0, "")) // false
-	fmt.Println(condition.And(0, "0")) // false
-	fmt.Println(condition.And(1, "0")) // true
+    fmt.Println(condition.And(0, 1)) // false
+    fmt.Println(condition.And(0, "")) // false
+    fmt.Println(condition.And(0, "0")) // false
+    fmt.Println(condition.And(1, "0")) // true
 }
 ```
 
 
 
 ### <span id="Or">Or</span>
-<p>Returns false iff neither a nor b is truthy.</p>
+<p>Returns false if neither a nor b is truthy.</p>
 
 <b>Signature:</b>
 
@@ -138,17 +150,17 @@ import (
 )
 
 func main() {
-	fmt.Println(condition.Or(0, "")) // false
-	fmt.Println(condition.Or(0, 1)) // true
-	fmt.Println(condition.Or(0, "0")) // true
-	fmt.Println(condition.Or(1, "0")) // true
+    fmt.Println(condition.Or(0, "")) // false
+    fmt.Println(condition.Or(0, 1)) // true
+    fmt.Println(condition.Or(0, "0")) // true
+    fmt.Println(condition.Or(1, "0")) // true
 }
 ```
 
 
 
 ### <span id="Xor">Xor</span>
-<p>Returns true iff a or b but not both is truthy.</p>
+<p>Returns true if a or b but not both is truthy.</p>
 
 <b>Signature:</b>
 
@@ -166,17 +178,17 @@ import (
 )
 
 func main() {
-	fmt.Println(condition.Xor(0, 0)) // false
-	fmt.Println(condition.Xor(0, 1)) // true
-	fmt.Println(condition.Xor(1, 0)) // true
-	fmt.Println(condition.Xor(1, 1)) // false
+    fmt.Println(condition.Xor(0, 0)) // false
+    fmt.Println(condition.Xor(0, 1)) // true
+    fmt.Println(condition.Xor(1, 0)) // true
+    fmt.Println(condition.Xor(1, 1)) // false
 }
 ```
 
 
 
 ### <span id="Nor">Nor</span>
-<p>Returns true iff neither a nor b is truthy.</p>
+<p>Returns true if neither a nor b is truthy.</p>
 
 <b>Signature:</b>
 
@@ -194,17 +206,43 @@ import (
 )
 
 func main() {
-	fmt.Println(condition.Nor(0, 0)) // true
-	fmt.Println(condition.Nor(0, 1)) // false
-	fmt.Println(condition.Nor(1, 0)) // false
-	fmt.Println(condition.Nor(1, 1)) // true
+    fmt.Println(condition.Nor(0, 0)) // true
+    fmt.Println(condition.Nor(0, 1)) // false
+    fmt.Println(condition.Nor(1, 0)) // false
+    fmt.Println(condition.Nor(1, 1)) // false
 }
 ```
 
 
+### <span id="Xnor">Xnor</span>
+<p>Returns true if both a and b or neither a nor b are truthy.</p>
+
+<b>Signature:</b>
+
+```go
+func Xnor[T, U any](a T, b U) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+    fmt.Println(condition.Xnor(0, 0)) // true
+    fmt.Println(condition.Xnor(0, 1)) // false
+    fmt.Println(condition.Xnor(1, 0)) // false
+    fmt.Println(condition.Xnor(1, 1)) // true
+}
+```
+
 
 ### <span id="Nand">Nand</span>
-<p>Returns false iff both a and b are truthy</p>
+<p>Returns false if both a and b are truthy</p>
 
 <b>Signature:</b>
 
@@ -222,10 +260,10 @@ import (
 )
 
 func main() {
-	fmt.Println(condition.Nand(0, 0)) // true
-	fmt.Println(condition.Nand(0, 1)) // true
-	fmt.Println(condition.Nand(1, 0)) // true
-	fmt.Println(condition.Nand(1, 1)) // false
+    fmt.Println(condition.Nand(0, 0)) // true
+    fmt.Println(condition.Nand(0, 1)) // true
+    fmt.Println(condition.Nand(1, 0)) // true
+    fmt.Println(condition.Nand(1, 1)) // false
 }
 ```
 
@@ -250,10 +288,18 @@ import (
 )
 
 func main() {
-	trueValue := "1"
-	falseValue := "0"
+    conditionTrue := 2 > 1
+    result1 := condition.TernaryOperator(conditionTrue, 0, 1)
 
-	fmt.Println(condition.TernaryOperator(true, trueValue, falseValue)) // "1"
+    conditionFalse := 2 > 3
+    result2 := condition.TernaryOperator(conditionFalse, 0, 1)
+    
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 0
+    // 1
 }
 ```
 

docs/condition_zh-CN.md

@@ -25,6 +25,7 @@ import (
 - [Or](#Or)
 - [Xor](#Generate)
 - [Nor](#Nor)
+- [Xnor](#Xnor)
 - [Nand](#Nand)
 - [TernaryOperator](#TernaryOperator)
 
@@ -44,7 +45,7 @@ slices和map的length大于0时，返回true，否则返回false<br/>
 ```go
 func Bool[T any](value T) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -55,41 +56,51 @@ import (
 )
 
 func main() {
-	// bool
-	fmt.Println(condition.Bool(false)) // false
-	fmt.Println(condition.Bool(true)) // true
+    // bool
+    result1 := condition.Bool(false)
+    result2 := condition.Bool(true)
+    fmt.Println(result1) // false
+    fmt.Println(result2) // true
 
-	// integer
-	fmt.Println(condition.Bool(0)) // false
-	fmt.Println(condition.Bool(1)) // true
+    // integer
+    result3 := condition.Bool(0) 
+    result4 := condition.Bool(1)
+    fmt.Println(result3) // false
+    fmt.Println(result4) // true
 
-	// float
-	fmt.Println(condition.Bool(0.0)) // false
-	fmt.Println(condition.Bool(0.1)) // true
+    // string
+    result5 := condition.Bool("")
+    result6 := condition.Bool(" ")
+    fmt.Println(result5) // false
+    fmt.Println(result6) // true
 
-	// string
-	fmt.Println(condition.Bool("")) // false
-	fmt.Println(condition.Bool(" ")) // true
-	fmt.Println(condition.Bool("0")) // true
+    // slice
+    nums := []int{}
+    result7 := condition.Bool(nums)
 
-	// slice
-	var nums [2]int
-	fmt.Println(condition.Bool(nums)) // false
-	nums = [2]int{0, 1}
-	fmt.Println(condition.Bool(nums)) // true
+    nums = append(nums, 1, 2)
+    result8 := condition.Bool(nums)
+    fmt.Println(result7) // false
+    fmt.Println(result8) // true
 
-	// map
-	fmt.Println(condition.Bool(map[string]string{})) // false
-	fmt.Println(condition.Bool(map[string]string{"a": "a"})) // true
+    // struct
+    result9 = condition.Bool(struct{}{})
+    fmt.Println(result8) // false
 
-	// struct
-	fmt.Println(condition.Bool(struct{}{})) // false
-	fmt.Println(condition.Bool(time.Now())) // true
+
+    // Output:
+    // false
+    // true
+    // false
+    // true
+    // false
+    // true
+    // false
+    // true
+    // false
 }
 ```
 
-
-
 ### <span id="And">And</span>
 <p>逻辑且操作，当切仅当a和b都为true时返回true</p>
 
@@ -98,7 +109,7 @@ func main() {
 ```go
 func And[T, U any](a T, b U) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -109,15 +120,13 @@ import (
 )
 
 func main() {
-	fmt.Println(condition.And(0, 1)) // false
-	fmt.Println(condition.And(0, "")) // false
-	fmt.Println(condition.And(0, "0")) // false
-	fmt.Println(condition.And(1, "0")) // true
+    fmt.Println(condition.And(0, 1)) // false
+    fmt.Println(condition.And(0, "")) // false
+    fmt.Println(condition.And(0, "0")) // false
+    fmt.Println(condition.And(1, "0")) // true
 }
 ```
 
-
-
 ### <span id="Or">Or</span>
 <p>逻辑或操作，当切仅当a和b都为false时返回false</p>
 
@@ -126,7 +135,7 @@ func main() {
 ```go
 func Or[T, U any](a T, b U) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -137,15 +146,13 @@ import (
 )
 
 func main() {
-	fmt.Println(condition.Or(0, "")) // false
-	fmt.Println(condition.Or(0, 1)) // true
-	fmt.Println(condition.Or(0, "0")) // true
-	fmt.Println(condition.Or(1, "0")) // true
+    fmt.Println(condition.Or(0, "")) // false
+    fmt.Println(condition.Or(0, 1)) // true
+    fmt.Println(condition.Or(0, "0")) // true
+    fmt.Println(condition.Or(1, "0")) // true
 }
 ```
 
-
-
 ### <span id="Xor">Xor</span>
 <p>逻辑异或操作，a和b相同返回false，a和b不相同返回true</p>
 
@@ -154,7 +161,7 @@ func main() {
 ```go
 func Xor[T, U any](a T, b U) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -165,15 +172,13 @@ import (
 )
 
 func main() {
-	fmt.Println(condition.Xor(0, 0)) // false
-	fmt.Println(condition.Xor(0, 1)) // true
-	fmt.Println(condition.Xor(1, 0)) // true
-	fmt.Println(condition.Xor(1, 1)) // false
+    fmt.Println(condition.Xor(0, 0)) // false
+    fmt.Println(condition.Xor(0, 1)) // true
+    fmt.Println(condition.Xor(1, 0)) // true
+    fmt.Println(condition.Xor(1, 1)) // false
 }
 ```
 
-
-
 ### <span id="Nor">Nor</span>
 <p>异或的取反操作</p>
 
@@ -182,7 +187,7 @@ func main() {
 ```go
 func Nor[T, U any](a T, b U) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -193,14 +198,38 @@ import (
 )
 
 func main() {
-	fmt.Println(condition.Nor(0, 0)) // true
-	fmt.Println(condition.Nor(0, 1)) // false
-	fmt.Println(condition.Nor(1, 0)) // false
-	fmt.Println(condition.Nor(1, 1)) // true
+    fmt.Println(condition.Nor(0, 0)) // true
+    fmt.Println(condition.Nor(0, 1)) // false
+    fmt.Println(condition.Nor(1, 0)) // false
+    fmt.Println(condition.Nor(1, 1)) // false
 }
 ```
 
+### <span id="Xnor">Xnor</span>
+<p>如果a和b都是真的或a和b均是假的，则返回true。</p>
 
+<b>函数签名:</b>
+
+```go
+func Xnor[T, U any](a T, b U) bool
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+    fmt.Println(condition.Xnor(0, 0)) // true
+    fmt.Println(condition.Xnor(0, 1)) // false
+    fmt.Println(condition.Xnor(1, 0)) // false
+    fmt.Println(condition.Xnor(1, 1)) // true
+}
+```
 
 ### <span id="Nand">Nand</span>
 <p>如果a和b都为真，返回false，否则返回true</p>
@@ -210,7 +239,7 @@ func main() {
 ```go
 func Nand[T, U any](a T, b U) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -221,15 +250,13 @@ import (
 )
 
 func main() {
-	fmt.Println(condition.Nand(0, 0)) // true
-	fmt.Println(condition.Nand(0, 1)) // true
-	fmt.Println(condition.Nand(1, 0)) // true
-	fmt.Println(condition.Nand(1, 1)) // false
+    fmt.Println(condition.Nand(0, 0)) // true
+    fmt.Println(condition.Nand(0, 1)) // true
+    fmt.Println(condition.Nand(1, 0)) // true
+    fmt.Println(condition.Nand(1, 1)) // false
 }
 ```
 
-
-
 ### <span id="TernaryOperator">TernaryOperator</span>
 <p>三元运算符</p>
 
@@ -238,7 +265,7 @@ func main() {
 ```go
 func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -249,10 +276,18 @@ import (
 )
 
 func main() {
-	trueValue := "1"
-	falseValue := "0"
+    conditionTrue := 2 > 1
+    result1 := condition.TernaryOperator(conditionTrue, 0, 1)
 
-	fmt.Println(condition.TernaryOperator(true, trueValue, falseValue)) // "1"
+    conditionFalse := 2 > 3
+    result2 := condition.TernaryOperator(conditionFalse, 0, 1)
+    
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 0
+    // 1
 }
 ```
 

docs/convertor.md

@@ -1,15 +1,17 @@
 # Convertor
+
 Package convertor contains some functions for data type convertion.
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Source:
 
-- [https://github.com/duke-git/lancet/blob/main/convertor/convertor.go](https://github.com/duke-git/lancet/blob/main/convertor/convertor.go)
+-   [https://github.com/duke-git/lancet/blob/main/convertor/convertor.go](https://github.com/duke-git/lancet/blob/main/convertor/convertor.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/convertor"
@@ -19,31 +21,35 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## Index
-- [ColorHexToRGB](#ColorHexToRGB)
-- [ColorRGBToHex](#ColorRGBToHex)
-- [ToBool](#ToBool)
-- [ToBytes](#ToBytes)
-- [ToChar](#ToChar)
-- [ToChannel](#ToChannel)
 
-- [ToFloat](#ToFloat)
-- [ToInt](#ToInt)
-- [ToJson](#ToJson)
-- [ToMap](#ToMap)
-- [ToPointer](#ToPointer)
-- [ToString](#ToString)
-- [StructToMap](#StructToMap)
-- [MapToSlice](#MapToSlice)
-- [EncodeByte](#EncodeByte)
-- [DecodeByte](#DecodeByte)
+-   [ColorHexToRGB](#ColorHexToRGB)
+-   [ColorRGBToHex](#ColorRGBToHex)
+-   [ToBool](#ToBool)
+-   [ToBytes](#ToBytes)
+-   [ToChar](#ToChar)
+-   [ToChannel](#ToChannel)
+-   [ToFloat](#ToFloat)
+-   [ToInt](#ToInt)
+-   [ToJson](#ToJson)
+-   [ToMap](#ToMap)
+-   [ToPointer](#ToPointer)
+-   [ToString](#ToString)
+-   [StructToMap](#StructToMap)
+-   [MapToSlice](#MapToSlice)
+-   [EncodeByte](#EncodeByte)
+-   [DecodeByte](#DecodeByte)
+-   [DeepClone](#DeepClone)
+-   [CopyProperties](#CopyProperties)
+-   [ToInterface](#ToInterface)
+-   [Utf8ToGbk](#Utf8ToGbk)
+-   [GbkToUtf8](#GbkToUtf8)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
-
-
 ### <span id="ColorHexToRGB">ColorHexToRGB</span>
+
 <p>Convert color hex to color rgb.</p>
 
 <b>Signature:</b>
@@ -51,6 +57,7 @@ import (
 ```go
 func ColorHexToRGB(colorHex string) (red, green, blue int)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -64,12 +71,14 @@ import (
 func main() {
     colorHex := "#003366"
     r, g, b := convertor.ColorHexToRGB(colorHex)
-    fmt.Println(r, g, b) //0,51,102
+
+    fmt.Println(r, g, b)
+
+    // Output:
+    // 0 51 102
 }
 ```
 
-
-
 ### <span id="ColorRGBToHex">ColorRGBToHex</span>
 
 <p>Convert color rgb to color hex.</p>
@@ -79,6 +88,7 @@ func main() {
 ```go
 func ColorRGBToHex(red, green, blue int) string
 ```
+
 <b>Example:</b>
 
 ```go
@@ -93,23 +103,25 @@ func main() {
     r := 0
     g := 51
     b := 102
-    colorHex := convertor.ColorRGBToHex(r, g, b)
+    colorHex := ColorRGBToHex(r, g, b)
 
-    fmt.Println(colorHex) //#003366
+    fmt.Println(colorHex)
+
+    // Output:
+    // #003366
 }
 ```
 
-
-
 ### <span id="ToBool">ToBool</span>
 
-<p>Convert string to a boolean value. Use strconv.ParseBool</p>
+<p>Convert string to bool. Use strconv.ParseBool.</p>
 
 <b>Signature:</b>
 
 ```go
 func ToBool(s string) (bool, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -121,31 +133,36 @@ import (
 )
 
 func main() {
-    v1, _ := convertor.ToBool("1")
-    fmt.Println(v1) //true
+    cases := []string{"1", "true", "True", "false", "False", "0", "123", "0.0", "abc"}
 
-    v2, _ := convertor.ToBool("true")
-    fmt.Println(v2) //true
+    for i := 0; i < len(cases); i++ {
+        result, _ := convertor.ToBool(cases[i])
+        fmt.Println(result)
+    }
 
-    v3, _ := convertor.ToBool("True")
-    fmt.Println(v3) //true
-
-    v4, _ := convertor.ToBool("123")
-    fmt.Println(v4) //false
+    // Output:
+    // true
+    // true
+    // true
+    // false
+    // false
+    // false
+    // false
+    // false
+    // false
 }
 ```
 
-
-
 ### <span id="ToBytes">ToBytes</span>
 
-<p>Convert interface to byte slice.</p>
+<p>Convert value to byte slice.</p>
 
 <b>Signature:</b>
 
 ```go
 func ToBytes(data any) ([]byte, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -157,16 +174,18 @@ import (
 )
 
 func main() {
-    bytesData, err := convertor.ToBytes("0")
+    bytesData, err := convertor.ToBytes("abc")
     if err != nil {
         fmt.Println(err)
     }
-    fmt.Println(bytesData) //[]bytes{3, 4, 0, 0}
+
+    fmt.Println(bytesData)
+
+    // Output:
+    // [97 98 99]
 }
 ```
 
-
-
 ### <span id="ToChar">ToChar</span>
 
 <p>Convert string to char slice.</p>
@@ -176,6 +195,7 @@ func main() {
 ```go
 func ToChar(s string) []string
 ```
+
 <b>Example:</b>
 
 ```go
@@ -187,27 +207,31 @@ import (
 )
 
 func main() {
-    chars := convertor.ToChar("")
-    fmt.Println(chars) //[]string{""}
+    result1 := convertor.ToChar("")
+    result2 := convertor.ToChar("abc")
+    result3 := convertor.ToChar("1 2#3")
 
-    chars = convertor.ToChar("abc")
-    fmt.Println(chars) //[]string{"a", "b", "c"}
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
 
-    chars = convertor.ToChar("1 2#3")
-    fmt.Println(chars) //[]string{"1", " ", "2", "#", "3"}
+    // Output:
+    // []
+    // [a b c]
+    // [1   2 # 3]
 }
 ```
 
-
 ### <span id="ToChannel">ToChannel</span>
 
-<p>Convert a collection of elements to a read-only channels.</p>
+<p>Convert a collection of elements to a read-only channel.</p>
 
 <b>Signature:</b>
 
 ```go
 func ToChannel[T any](array []T) <-chan T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -220,32 +244,31 @@ import (
 
 func main() {
     ch := convertor.ToChannel([]int{1, 2, 3})
+    result1 := <-ch
+    result2 := <-ch
+    result3 := <-ch
 
-    val1, _ := <-ch
-    fmt.Println(val1) //1
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
 
-    val2, _ := <-ch
-    fmt.Println(val2) //2
-
-    val3, _ := <-ch
-    fmt.Println(val3) //3
-
-    _, ok := <-ch
-    fmt.Println(ok) //false
+    // Output:
+    // 1
+    // 2
+    // 3
 }
 ```
 
-
-
 ### <span id="ToFloat">ToFloat</span>
 
-<p>Convert interface to a float64 value. If param is a invalid floatable, will return 0 and error. </p>
+<p>Convert value to a float64 value. If param is a invalid floatable, will return 0.0 and error. </p>
 
 <b>Signature:</b>
 
 ```go
 func ToFloat(value any) (float64, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -257,28 +280,40 @@ import (
 )
 
 func main() {
-    v, err := convertor.ToFloat("")
-    if err != nil {
-        fmt.Println(err) //strconv.ParseFloat: parsing "": invalid syntax
-    }
-    fmt.Println(v) //0
+    result1, _ := convertor.ToFloat("")
+    result2, err := convertor.ToFloat("abc")
+    result3, _ := convertor.ToFloat("-1")
+    result4, _ := convertor.ToFloat("-.11")
+    result5, _ := convertor.ToFloat("1.23e3")
+    result6, _ := convertor.ToFloat(true)
 
-    v, _ = convertor.ToFloat("-.11")
-    fmt.Println(v) //-0.11
+    fmt.Println(result1)
+    fmt.Println(result2, err)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // 0
+    // 0 strconv.ParseFloat: parsing "": invalid syntax
+    // -1
+    // -0.11
+    // 1230
+    // 0
 }
 ```
 
-
-
 ### <span id="ToInt">ToInt</span>
 
-<p>Convert interface to a int64 value. If param is a invalid intable, will return 0 and error. </p>
+<p>Convert value to a int64 value. If param is a invalid intable, will return 0 and error. </p>
 
 <b>Signature:</b>
 
 ```go
 func ToInt(value any) (int64, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -290,19 +325,27 @@ import (
 )
 
 func main() {
-    v, err := convertor.ToInt("")
-    if err != nil {
-        fmt.Println(err) //strconv.ParseInt: parsing "": invalid syntax
-    }
-    fmt.Println(v) //0
+    result1, _ := convertor.ToInt("123")
+    result2, _ := convertor.ToInt("-123")
+    result3, _ := convertor.ToInt(float64(12.3))
+    result4, err := convertor.ToInt("abc")
+    result5, _ := convertor.ToInt(true)
 
-    v, _ = convertor.ToFloat(1.12)
-    fmt.Println(v) //1
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4, err)
+    fmt.Println(result5)
+
+    // Output:
+    // 123
+    // -123
+    // 12
+    // 0 strconv.ParseInt: parsing "": invalid syntax
+    // 0
 }
 ```
 
-
-
 ### <span id="ToJson">ToJson</span>
 
 <p>Convert interface to json string. If param can't be converted, will return "" and error. </p>
@@ -312,6 +355,7 @@ func main() {
 ```go
 func ToJson(value any) (string, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -323,23 +367,30 @@ import (
 )
 
 func main() {
-    var aMap = map[string]int{"a": 1, "b": 2, "c": 3}
-    jsonStr, _ := convertor.ToJson(aMap)
-    fmt.Printf("%q", jsonStr) //"{\"a\":1,\"b\":2,\"c\":3}"
+    aMap := map[string]int{"a": 1, "b": 2, "c": 3}
+    result, err := ToJson(aMap)
+
+    if err != nil {
+        fmt.Printf("%v", err)
+    }
+
+    fmt.Println(result)
+
+    // Output:
+    // {"a":1,"b":2,"c":3}
 }
 ```
 
-
-
 ### <span id="ToMap">ToMap</span>
 
-<p>Convert a slice or an array of structs to a map based on iteratee function. </p>
+<p>Convert a slice of structs to a map based on iteratee function. </p>
 
 <b>Signature:</b>
 
 ```go
 func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
 ```
+
 <b>Example:</b>
 
 ```go
@@ -359,16 +410,18 @@ func main() {
         {name: "Hello", code: 100},
         {name: "Hi", code: 101},
     }
+
     result := convertor.ToMap(messages, func(msg Message) (int, string) {
         return msg.code, msg.name
     })
 
-    fmt.Println(result) //{100: "Hello", 101: "Hi"}
+    fmt.Println(result)
+
+    // Output:
+    // map[100:Hello 101:Hi]
 }
 ```
 
-
-
 ### <span id="ToPointer">ToPointer</span>
 
 <p>Returns a pointer to passed value. </p>
@@ -378,6 +431,7 @@ func main() {
 ```go
 func ToPointer[T any](value T) *T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -390,11 +444,60 @@ import (
 
 func main() {
     result := convertor.ToPointer(123)
-    fmt.Println(*result) //123
+    fmt.Println(*result)
+
+    // Output:
+    // 123
 }
 ```
 
+### <span id="ToString">ToString</span>
 
+<p>ToString convert value to string, for number, string, []byte, will convert to string. For other type (slice, map, array, struct) will call json.Marshal</p>
+
+<b>Signature:</b>
+
+```go
+func ToString(value any) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    result1 := convertor.ToString("")
+    result2 := convertor.ToString(nil)
+    result3 := convertor.ToString(0)
+    result4 := convertor.ToString(1.23)
+    result5 := convertor.ToString(true)
+    result6 := convertor.ToString(false)
+    result7 := convertor.ToString([]int{1, 2, 3})
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+    fmt.Println(result7)
+
+    // Output:
+    //
+    //
+    // 0
+    // 1.23
+    // true
+    // false
+    // [1,2,3]
+}
+```
 
 ### <span id="StructToMap">StructToMap</span>
 
@@ -405,6 +508,7 @@ func main() {
 ```go
 func StructToMap(value any) (map[string]any, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -426,12 +530,13 @@ func main() {
     }
     pm, _ := convertor.StructToMap(p)
 
-    fmt.Printf("type: %T, value: %s", pm, pm) //type: map[string]interface {}, value: map[name:test]
+    fmt.Println(pm)
+
+    // Output:
+    // map[name:test]
 }
 ```
 
-
-
 ### <span id="MapToSlice">MapToSlice</span>
 
 <p>Convert a map to a slice based on iteratee function.</p>
@@ -441,6 +546,7 @@ func main() {
 ```go
 func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -461,7 +567,6 @@ func main() {
 }
 ```
 
-
 ### <span id="EncodeByte">EncodeByte</span>
 
 <p>Encode data to byte slice.</p>
@@ -471,6 +576,7 @@ func main() {
 ```go
 func EncodeByte(data any) ([]byte, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -483,12 +589,13 @@ import (
 
 func main() {
     byteData, _ := convertor.EncodeByte("abc")
-    fmt.Println(byteData) //[]byte{6, 12, 0, 3, 97, 98, 99}
+    fmt.Println(byteData)
+
+    // Output:
+    // [6 12 0 3 97 98 99]
 }
 ```
 
-
-
 ### <span id="DecodeByte">DecodeByte</span>
 
 <p>Decode byte data to target object. target should be a pointer instance.</p>
@@ -498,6 +605,7 @@ func main() {
 ```go
 func DecodeByte(data []byte, target any) error
 ```
+
 <b>Example:</b>
 
 ```go
@@ -510,8 +618,261 @@ import (
 
 func main() {
     var result string
-	byteData := []byte{6, 12, 0, 3, 97, 98, 99}
-	convertor.DecodeByte(byteData, &result)
-    fmt.Println(result) //"abc"
+    byteData := []byte{6, 12, 0, 3, 97, 98, 99}
+
+    err := convertor.DecodeByte(byteData, &result)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(result)
+
+    // Output:
+    // abc
+}
+```
+
+### <span id="DeepClone">DeepClone</span>
+
+<p>Creates a deep copy of passed item, can't clone unexported field of struct.</p>
+
+<b>Signature:</b>
+
+```go
+func DeepClone[T any](src T) T
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    type Struct struct {
+        Str        string
+        Int        int
+        Float      float64
+        Bool       bool
+        Nil        interface{}
+        unexported string
+    }
+
+    cases := []interface{}{
+        true,
+        1,
+        0.1,
+        map[string]int{
+            "a": 1,
+            "b": 2,
+        },
+        &Struct{
+            Str:   "test",
+            Int:   1,
+            Float: 0.1,
+            Bool:  true,
+            Nil:   nil,
+            // unexported: "can't be cloned",
+        },
+    }
+
+    for _, item := range cases {
+        cloned := convertor.DeepClone(item)
+
+        isPointerEqual := &cloned == &item
+        fmt.Println(cloned, isPointerEqual)
+    }
+
+    // Output:
+    // true false
+    // 1 false
+    // 0.1 false
+    // map[a:1 b:2] false
+    // &{test 1 0.1 true <nil> } false
+}
+```
+
+### <span id="CopyProperties">CopyProperties</span>
+
+<p>Copies each field from the source struct into the destination struct. Use json.Marshal/Unmarshal, so json tag should be set for fields of dst and src struct.</p>
+
+<b>Signature:</b>
+
+```go
+func CopyProperties[T, U any](dst T, src U) (err error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    type Disk struct {
+        Name    string  `json:"name"`
+        Total   string  `json:"total"`
+        Used    string  `json:"used"`
+        Percent float64 `json:"percent"`
+    }
+
+    type DiskVO struct {
+        Name    string  `json:"name"`
+        Total   string  `json:"total"`
+        Used    string  `json:"used"`
+        Percent float64 `json:"percent"`
+    }
+
+    type Indicator struct {
+        Id      string    `json:"id"`
+        Ip      string    `json:"ip"`
+        UpTime  string    `json:"upTime"`
+        LoadAvg string    `json:"loadAvg"`
+        Cpu     int       `json:"cpu"`
+        Disk    []Disk    `json:"disk"`
+        Stop    chan bool `json:"-"`
+    }
+
+    type IndicatorVO struct {
+        Id      string   `json:"id"`
+        Ip      string   `json:"ip"`
+        UpTime  string   `json:"upTime"`
+        LoadAvg string   `json:"loadAvg"`
+        Cpu     int64    `json:"cpu"`
+        Disk    []DiskVO `json:"disk"`
+    }
+
+    indicator := &Indicator{Id: "001", Ip: "127.0.0.1", Cpu: 1, Disk: []Disk{
+        {Name: "disk-001", Total: "100", Used: "1", Percent: 10},
+        {Name: "disk-002", Total: "200", Used: "1", Percent: 20},
+        {Name: "disk-003", Total: "300", Used: "1", Percent: 30},
+    }}
+
+    indicatorVO := IndicatorVO{}
+
+    err := convertor.CopyProperties(&indicatorVO, indicator)
+
+    if err != nil {
+        return
+    }
+
+    fmt.Println(indicatorVO.Id)
+    fmt.Println(indicatorVO.Ip)
+    fmt.Println(len(indicatorVO.Disk))
+
+    // Output:
+    // 001
+    // 127.0.0.1
+    // 3
+}
+```
+
+### <span id="ToInterface">ToInterface</span>
+
+<p>Converts reflect value to its interface type.</p>
+
+<b>Signature:</b>
+
+```go
+func ToInterface(v reflect.Value) (value interface{}, ok bool)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    val := reflect.ValueOf("abc")
+    iVal, ok := convertor.ToInterface(val)
+
+    fmt.Printf("%T\n", iVal)
+    fmt.Printf("%v\n", iVal)
+    fmt.Println(ok)
+
+    // Output:
+    // string
+    // abc
+    // true    
+}
+```
+
+### <span id="Utf8ToGbk">Utf8ToGbk</span>
+
+<p>Converts utf8 encoding data to GBK encoding data.</p>
+
+<b>Signature:</b>
+
+```go
+func Utf8ToGbk(bs []byte) ([]byte, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    utf8Data := []byte("hello")
+    gbkData, _ := convertor.Utf8ToGbk(utf8Data)
+
+    fmt.Println(utf8.Valid(utf8Data))
+    fmt.Println(validator.IsGBK(gbkData))
+
+    // Output:
+    // true
+    // true   
+}
+```
+
+### <span id="GbkToUtf8">GbkToUtf8</span>
+
+<p>Converts GBK encoding data to utf8 encoding data.</p>
+
+<b>Signature:</b>
+
+```go
+func GbkToUtf8(bs []byte) ([]byte, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    gbkData, _ := convertor.Utf8ToGbk([]byte("hello"))
+    utf8Data, _ := convertor.GbkToUtf8(gbkData)
+
+    fmt.Println(utf8.Valid(utf8Data))
+    fmt.Println(string(utf8Data))
+
+    // Output:
+    // true
+    // hello   
 }
 ```

docs/convertor_zh-CN.md

@@ -1,11 +1,12 @@
 # Convertor
-convertor转换器包支持一些常见的数据类型转换
+
+convertor 转换器包支持一些常见的数据类型转换
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码:
 
-- [https://github.com/duke-git/lancet/blob/main/convertor/convertor.go](https://github.com/duke-git/lancet/blob/main/convertor/convertor.go)
+-   [https://github.com/duke-git/lancet/blob/main/convertor/convertor.go](https://github.com/duke-git/lancet/blob/main/convertor/convertor.go)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -21,39 +22,43 @@ import (
 
 ## 目录
 
-- [ColorHexToRGB](#ColorHexToRGB)
-- [ColorRGBToHex](#ColorRGBToHex)
-- [ToBool](#ToBool)
-- [ToBytes](#ToBytes)
-- [ToChar](#ToChar)
-- [ToChannel](#ToChannel)
-
-- [ToFloat](#ToFloat)
-- [ToInt](#ToInt)
-- [ToJson](#ToJson)
-- [ToMap](#ToMap)
-- [ToPointer](#ToPointer)
-- [ToString](#ToString)
-- [StructToMap](#StructToMap)
-- [MapToSlice](#MapToSlice)
-- [EncodeByte](#EncodeByte)
-- [DecodeByte](#DecodeByte)
+-   [ColorHexToRGB](#ColorHexToRGB)
+-   [ColorRGBToHex](#ColorRGBToHex)
+-   [ToBool](#ToBool)
+-   [ToBytes](#ToBytes)
+-   [ToChar](#ToChar)
+-   [ToChannel](#ToChannel)
+-   [ToFloat](#ToFloat)
+-   [ToInt](#ToInt)
+-   [ToJson](#ToJson)
+-   [ToMap](#ToMap)
+-   [ToPointer](#ToPointer)
+-   [ToString](#ToString)
+-   [StructToMap](#StructToMap)
+-   [MapToSlice](#MapToSlice)
+-   [EncodeByte](#EncodeByte)
+-   [DecodeByte](#DecodeByte)
+-   [DeepClone](#DeepClone)
+-   [CopyProperties](#CopyProperties)
+-   [ToInterface](#ToInterface)
+-   [Utf8ToGbk](#Utf8ToGbk)
+-   [GbkToUtf8](#GbkToUtf8)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
-
-
 ### <span id="ColorHexToRGB">ColorHexToRGB</span>
-<p>颜色值十六进制转rgb</p>
+
+<p>颜色值十六进制转rgb。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ColorHexToRGB(colorHex string) (red, green, blue int)
 ```
-<b>列子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -66,22 +71,25 @@ import (
 func main() {
     colorHex := "#003366"
     r, g, b := convertor.ColorHexToRGB(colorHex)
-    fmt.Println(r, g, b) //0,51,102
+
+    fmt.Println(r, g, b)
+
+    // Output:
+    // 0 51 102
 }
 ```
 
-
-
 ### <span id="ColorRGBToHex">ColorRGBToHex</span>
 
-<p>颜色值rgb转十六进制</p>
+<p>颜色值rgb转十六进制。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ColorRGBToHex(red, green, blue int) string
 ```
-<b>列子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -95,24 +103,26 @@ func main() {
     r := 0
     g := 51
     b := 102
-    colorHex := convertor.ColorRGBToHex(r, g, b)
+    colorHex := ColorRGBToHex(r, g, b)
 
-    fmt.Println(colorHex) //#003366
+    fmt.Println(colorHex)
+
+    // Output:
+    // #003366
 }
 ```
 
-
-
 ### <span id="ToBool">ToBool</span>
 
-<p>字符串转布尔类型，使用strconv.ParseBool</p>
+<p>字符串转布尔类型，使用strconv.ParseBool。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToBool(s string) (bool, error)
 ```
-<b>列子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -123,32 +133,37 @@ import (
 )
 
 func main() {
-    v1, _ := convertor.ToBool("1")
-    fmt.Println(v1) //true
+    cases := []string{"1", "true", "True", "false", "False", "0", "123", "0.0", "abc"}
 
-    v2, _ := convertor.ToBool("true")
-    fmt.Println(v2) //true
+    for i := 0; i < len(cases); i++ {
+        result, _ := convertor.ToBool(cases[i])
+        fmt.Println(result)
+    }
 
-    v3, _ := convertor.ToBool("True")
-    fmt.Println(v3) //true
-
-    v4, _ := convertor.ToBool("123")
-    fmt.Println(v4) //false
+    // Output:
+    // true
+    // true
+    // true
+    // false
+    // false
+    // false
+    // false
+    // false
+    // false
 }
 ```
 
-
-
 ### <span id="ToBytes">ToBytes</span>
 
-<p>interface转字节切片.</p>
+<p>Interface转字节切片。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToBytes(data any) ([]byte, error)
 ```
-<b>列子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -159,26 +174,29 @@ import (
 )
 
 func main() {
-    bytesData, err := convertor.ToBytes("0")
+    bytesData, err := convertor.ToBytes("abc")
     if err != nil {
         fmt.Println(err)
     }
-    fmt.Println(bytesData) //[]bytes{3, 4, 0, 0}
+
+    fmt.Println(bytesData)
+
+    // Output:
+    // [97 98 99]
 }
 ```
 
-
-
 ### <span id="ToChar">ToChar</span>
 
-<p>字符串转字符切片</p>
+<p>字符串转字符切片。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToChar(s string) []string
 ```
-<b>列子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -189,29 +207,32 @@ import (
 )
 
 func main() {
-    chars := convertor.ToChar("")
-    fmt.Println(chars) //[]string{""}
+    result1 := convertor.ToChar("")
+    result2 := convertor.ToChar("abc")
+    result3 := convertor.ToChar("1 2#3")
 
-    chars = convertor.ToChar("abc")
-    fmt.Println(chars) //[]string{"a", "b", "c"}
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
 
-    chars = convertor.ToChar("1 2#3")
-    fmt.Println(chars) //[]string{"1", " ", "2", "#", "3"}
+    // Output:
+    // []
+    // [a b c]
+    // [1   2 # 3]
 }
 ```
 
-
-
 ### <span id="ToChannel">ToChannel</span>
 
-<p>将切片转为只读channel</p>
+<p>将切片转为只读channel。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToChannel[T any](array []T) <-chan T
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -223,33 +244,32 @@ import (
 
 func main() {
     ch := convertor.ToChannel([]int{1, 2, 3})
+    result1 := <-ch
+    result2 := <-ch
+    result3 := <-ch
 
-    val1, _ := <-ch
-    fmt.Println(val1) //1
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
 
-    val2, _ := <-ch
-    fmt.Println(val2) //2
-
-    val3, _ := <-ch
-    fmt.Println(val3) //3
-
-    _, ok := <-ch
-    fmt.Println(ok) //false
+    // Output:
+    // 1
+    // 2
+    // 3
 }
 ```
 
-
-
 ### <span id="ToFloat">ToFloat</span>
 
-<p>将interface转成float64类型，如果参数无法转换，会返回0和error</p>
+<p>将interface转成float64类型，如果参数无法转换，会返回0和error。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToFloat(value any) (float64, error)
 ```
-<b>列子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -260,29 +280,41 @@ import (
 )
 
 func main() {
-    v, err := convertor.ToFloat("")
-    if err != nil {
-        fmt.Println(err) //strconv.ParseFloat: parsing "": invalid syntax
-    }
-    fmt.Println(v) //0
+    result1, _ := convertor.ToFloat("")
+    result2, err := convertor.ToFloat("abc")
+    result3, _ := convertor.ToFloat("-1")
+    result4, _ := convertor.ToFloat("-.11")
+    result5, _ := convertor.ToFloat("1.23e3")
+    result6, _ := convertor.ToFloat(true)
 
-    v, _ = convertor.ToFloat("-.11")
-    fmt.Println(v) //-0.11
+    fmt.Println(result1)
+    fmt.Println(result2, err)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // 0
+    // 0 strconv.ParseFloat: parsing "": invalid syntax
+    // -1
+    // -0.11
+    // 1230
+    // 0
 }
 ```
 
-
-
 ### <span id="ToInt">ToInt</span>
 
-<p>将interface转成int64类型，如果参数无法转换，会返回0和error</p>
+<p>将interface转成int64类型，如果参数无法转换，会返回0和error。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToInt(value any) (int64, error)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -293,29 +325,38 @@ import (
 )
 
 func main() {
-    v, err := convertor.ToInt("")
-    if err != nil {
-        fmt.Println(err) //strconv.ParseInt: parsing "": invalid syntax
-    }
-    fmt.Println(v) //0
+    result1, _ := convertor.ToInt("123")
+    result2, _ := convertor.ToInt("-123")
+    result3, _ := convertor.ToInt(float64(12.3))
+    result4, err := convertor.ToInt("abc")
+    result5, _ := convertor.ToInt(true)
 
-    v, _ = convertor.ToFloat(1.12)
-    fmt.Println(v) //1
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4, err)
+    fmt.Println(result5)
+
+    // Output:
+    // 123
+    // -123
+    // 12
+    // 0 strconv.ParseInt: parsing "": invalid syntax
+    // 0
 }
 ```
 
-
-
 ### <span id="ToJson">ToJson</span>
 
-<p>将interface转成json字符串，如果参数无法转换，会返回""和error</p>
+<p>将interface转成json字符串，如果参数无法转换，会返回""和error。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToJson(value any) (string, error)
 ```
-<b>列子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -326,24 +367,31 @@ import (
 )
 
 func main() {
-    var aMap = map[string]int{"a": 1, "b": 2, "c": 3}
-    jsonStr, _ := convertor.ToJson(aMap)
-    fmt.Printf("%q", jsonStr) //"{\"a\":1,\"b\":2,\"c\":3}"
+    aMap := map[string]int{"a": 1, "b": 2, "c": 3}
+    result, err := ToJson(aMap)
+
+    if err != nil {
+        fmt.Printf("%v", err)
+    }
+
+    fmt.Println(result)
+
+    // Output:
+    // {"a":1,"b":2,"c":3}
 }
 ```
 
-
-
 ### <span id="ToMap">ToMap</span>
 
-<p>将切片转为map</p>
+<p>将切片转为map。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -362,26 +410,29 @@ func main() {
         {name: "Hello", code: 100},
         {name: "Hi", code: 101},
     }
+
     result := convertor.ToMap(messages, func(msg Message) (int, string) {
         return msg.code, msg.name
     })
 
-    fmt.Println(result) //{100: "Hello", 101: "Hi"}
+    fmt.Println(result)
+
+    // Output:
+    // map[100:Hello 101:Hi]
 }
 ```
 
-
-
 ### <span id="ToPointer">ToPointer</span>
 
-<p>返回传入值的指针</p>
+<p>返回传入值的指针。</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToPointer[T any](value T) *T
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -393,22 +444,24 @@ import (
 
 func main() {
     result := convertor.ToPointer(123)
-    fmt.Println(*result) //123
+    fmt.Println(*result)
+
+    // Output:
+    // 123
 }
 ```
 
-
-
 ### <span id="ToString">ToString</span>
 
-<p>将interface转成字符串</p>
+<p>将值转换为字符串，对于数字、字符串、[]byte，将转换为字符串。 对于其他类型（切片、映射、数组、结构体）将调用 json.Marshal</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToString(value any) string
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -419,24 +472,44 @@ import (
 )
 
 func main() {
-    fmt.Printf("%q", convertor.ToString(1)) //"1"
-    fmt.Printf("%q", convertor.ToString(1.1)) //"1.1"
-    fmt.Printf("%q", convertor.ToString([]int{1, 2, 3})) //"[1,2,3]"
+    result1 := convertor.ToString("")
+    result2 := convertor.ToString(nil)
+    result3 := convertor.ToString(0)
+    result4 := convertor.ToString(1.23)
+    result5 := convertor.ToString(true)
+    result6 := convertor.ToString(false)
+    result7 := convertor.ToString([]int{1, 2, 3})
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+    fmt.Println(result7)
+
+    // Output:
+    //
+    //
+    // 0
+    // 1.23
+    // true
+    // false
+    // [1,2,3]
 }
 ```
 
-
-
 ### <span id="StructToMap">StructToMap</span>
 
-<p>将struct转成map，只会转换struct中可导出的字段。struct中导出字段需要设置json tag标记</p>
+<p>将struct转成map，只会转换struct中可导出的字段。struct中导出字段需要设置json tag标记。</p>
 
 <b>函数签名:</b>
 
 ```go
 func StructToMap(value any) (map[string]any, error)
 ```
-<b>列子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -457,22 +530,24 @@ func main() {
     }
     pm, _ := convertor.StructToMap(p)
 
-    fmt.Printf("type: %T, value: %s", pm, pm) //type: map[string]interface {}, value: map[name:test]
+    fmt.Println(pm)
+
+    // Output:
+    // map[name:test]
 }
 ```
 
-
-
 ### <span id="MapToSlice">MapToSlice</span>
 
-<p>map中key和value执行函数iteratee后，转为切片</p>
+<p>map中key和value执行函数iteratee后，转为切片。</p>
 
 <b>函数签名:</b>
 
 ```go
 func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -492,18 +567,17 @@ func main() {
 }
 ```
 
-
-
 ### <span id="EncodeByte">EncodeByte</span>
 
-<p>将data编码成字节切片</p>
+<p>将data编码成字节切片。</p>
 
 <b>函数签名:</b>
 
 ```go
 func EncodeByte(data any) ([]byte, error)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -515,22 +589,24 @@ import (
 
 func main() {
     byteData, _ := convertor.EncodeByte("abc")
-    fmt.Println(byteData) //[]byte{6, 12, 0, 3, 97, 98, 99}
+    fmt.Println(byteData)
+
+    // Output:
+    // [6 12 0 3 97 98 99]
 }
 ```
 
-
-
 ### <span id="DecodeByte">DecodeByte</span>
 
-<p>解码字节切片到目标对象，目标对象需要传入一个指针实例子</p>
+<p>解码字节切片到目标对象，目标对象需要传入一个指针实例。</p>
 
 <b>函数签名:</b>
 
 ```go
 func DecodeByte(data []byte, target any) error
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -542,8 +618,261 @@ import (
 
 func main() {
     var result string
-	byteData := []byte{6, 12, 0, 3, 97, 98, 99}
-	convertor.DecodeByte(byteData, &result)
-    fmt.Println(result) //"abc"
+    byteData := []byte{6, 12, 0, 3, 97, 98, 99}
+
+    err := convertor.DecodeByte(byteData, &result)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(result)
+
+    // Output:
+    // abc
 }
-```
+```
+
+### <span id="DeepClone">DeepClone</span>
+
+<p>创建一个传入值的深拷贝, 无法克隆结构体的非导出字段。</p>
+
+<b>函数签名:</b>
+
+```go
+func DeepClone[T any](src T) T
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    type Struct struct {
+        Str        string
+        Int        int
+        Float      float64
+        Bool       bool
+        Nil        interface{}
+        unexported string
+    }
+
+    cases := []interface{}{
+        true,
+        1,
+        0.1,
+        map[string]int{
+            "a": 1,
+            "b": 2,
+        },
+        &Struct{
+            Str:   "test",
+            Int:   1,
+            Float: 0.1,
+            Bool:  true,
+            Nil:   nil,
+            // unexported: "can't be cloned",
+        },
+    }
+
+    for _, item := range cases {
+        cloned := convertor.DeepClone(item)
+
+        isPointerEqual := &cloned == &item
+        fmt.Println(cloned, isPointerEqual)
+    }
+
+    // Output:
+    // true false
+    // 1 false
+    // 0.1 false
+    // map[a:1 b:2] false
+    // &{test 1 0.1 true <nil> } false
+}
+```
+
+### <span id="CopyProperties">CopyProperties</span>
+
+<p>拷贝不同结构体之间的同名字段。使用json.Marshal序列化，需要设置dst和src struct字段的json tag。</p>
+
+<b>函数签名:</b>
+
+```go
+func CopyProperties[T, U any](dst T, src U) (err error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    type Disk struct {
+        Name    string  `json:"name"`
+        Total   string  `json:"total"`
+        Used    string  `json:"used"`
+        Percent float64 `json:"percent"`
+    }
+
+    type DiskVO struct {
+        Name    string  `json:"name"`
+        Total   string  `json:"total"`
+        Used    string  `json:"used"`
+        Percent float64 `json:"percent"`
+    }
+
+    type Indicator struct {
+        Id      string    `json:"id"`
+        Ip      string    `json:"ip"`
+        UpTime  string    `json:"upTime"`
+        LoadAvg string    `json:"loadAvg"`
+        Cpu     int       `json:"cpu"`
+        Disk    []Disk    `json:"disk"`
+        Stop    chan bool `json:"-"`
+    }
+
+    type IndicatorVO struct {
+        Id      string   `json:"id"`
+        Ip      string   `json:"ip"`
+        UpTime  string   `json:"upTime"`
+        LoadAvg string   `json:"loadAvg"`
+        Cpu     int64    `json:"cpu"`
+        Disk    []DiskVO `json:"disk"`
+    }
+
+    indicator := &Indicator{Id: "001", Ip: "127.0.0.1", Cpu: 1, Disk: []Disk{
+        {Name: "disk-001", Total: "100", Used: "1", Percent: 10},
+        {Name: "disk-002", Total: "200", Used: "1", Percent: 20},
+        {Name: "disk-003", Total: "300", Used: "1", Percent: 30},
+    }}
+
+    indicatorVO := IndicatorVO{}
+
+    err := convertor.CopyProperties(&indicatorVO, indicator)
+
+    if err != nil {
+        return
+    }
+
+    fmt.Println(indicatorVO.Id)
+    fmt.Println(indicatorVO.Ip)
+    fmt.Println(len(indicatorVO.Disk))
+
+    // Output:
+    // 001
+    // 127.0.0.1
+    // 3
+}
+```
+
+### <span id="ToInterface">ToInterface</span>
+
+<p>将反射值转换成对应的interface类型。</p>
+
+<b>函数签名:</b>
+
+```go
+func ToInterface(v reflect.Value) (value interface{}, ok bool)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    val := reflect.ValueOf("abc")
+    iVal, ok := convertor.ToInterface(val)
+
+    fmt.Printf("%T\n", iVal)
+    fmt.Printf("%v\n", iVal)
+    fmt.Println(ok)
+
+    // Output:
+    // string
+    // abc
+    // true
+}
+```
+
+### <span id="Utf8ToGbk">Utf8ToGbk</span>
+
+<p>utf8编码转GBK编码。</p>
+
+<b>函数签名:</b>
+
+```go
+func Utf8ToGbk(bs []byte) ([]byte, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    utf8Data := []byte("hello")
+    gbkData, _ := convertor.Utf8ToGbk(utf8Data)
+
+    fmt.Println(utf8.Valid(utf8Data))
+    fmt.Println(validator.IsGBK(gbkData))
+
+    // Output:
+    // true
+    // true
+}
+```
+
+### <span id="GbkToUtf8">GbkToUtf8</span>
+
+<p>GBK编码转utf8编码。</p>
+
+<b>函数签名:</b>
+
+```go
+func GbkToUtf8(bs []byte) ([]byte, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    gbkData, _ := convertor.Utf8ToGbk([]byte("hello"))
+    utf8Data, _ := convertor.GbkToUtf8(gbkData)
+
+    fmt.Println(utf8.Valid(utf8Data))
+    fmt.Println(string(utf8Data))
+
+    // Output:
+    // true
+    // hello
+}
+```

docs/datastructure/copyonwritelist.md

@@ -0,0 +1,470 @@
+# CopyOnWriteList
+
+CopyOnWriteList is a thread-safe list implementation that uses go slicing as its base. When writing, a new slice is copied and assigned to the original slice when writing is complete. When reading, the original slice is read directly.
+
+## 源码
+
+-   [https://github.com/duke-git/lancet/blob/main/datastructure/list/copyonwritelist.go](https://github.com/duke-git/lancet/blob/main /datastructure/list/copyonwritelist.go)
+
+## 用法
+
+```go
+import (
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [NewCopyOnWriteList](#NewCopyOnWriteList)
+-   [Size](#Size)
+-   [Get](#Get)
+-   [Set](#Set)
+-   [Remove](#Remove)
+-   [IndexOf](#IndexOf)
+-   [LastIndexOf](#LastIndexOf)
+-   [IsEmpty](#IsEmpty)
+-   [Contain](#Contain)
+-   [ValueOf](#ValueOf)
+-   [Add](#Add)
+-   [AddAll](#AddAll)
+-   [AddByIndex](#AddByIndex)
+-   [DeleteAt](#DeleteAt)
+-   [DeleteIf](#DeleteIf)
+-   [DeleteBy](#DeleteBy)
+-   [DeleteRange](#DeleteRange)
+-   [Equal](#Equal)
+
+## Documentation
+
+### NewCopyOnWriteList
+
+Returns a CopyOnWriteList with empty slices.
+
+```go
+type CopyOnWriteList[T any] struct {
+    data []T
+    lock sync.
+}
+
+func NewCopyOnWriteList() *CopyOnWriteList
+
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l)
+}
+```
+
+### Size
+
+Returns the length of the CopyOnWriteList.
+
+```go
+func (l *CopyOnWriteList[T]) Size() int
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Size())
+}
+
+```
+
+### Get
+
+Returns the element at the specified position in the list
+
+```go
+func (c *CopyOnWriteList[T]) Get(index int) *T
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Get(2))
+}
+
+```
+
+### Set
+
+Replaces the element at the specified position in this list with the specified element.
+
+```go
+func (c *CopyOnWriteList[T]) Set(index int, e T) (oldValue *T, ok bool)
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Set(2, 4))
+}
+
+```
+
+### Remove
+
+### IndexOf
+
+Returns the index of the value in the list, or -1 if not found.
+
+```go
+func (c *CopyOnWriteList[T]) IndexOf(e T) int
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.IndexOf(1))
+}
+
+```
+
+### LastIndexOf
+
+Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain that element.
+
+```go
+func (c *CopyOnWriteList[T]) LastIndexOf(e T) int
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,1})
+    fmt.Println(l.LastIndexOf(1))
+}
+
+```
+
+### IsEmpty
+
+Returns true if this list does not contain any elements.
+
+```go
+func (c *CopyOnWriteList[T]) IsEmpty() bool
+```
+
+#### Example
+
+```go
+package main
+
+import (
+"fmt"
+"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{})
+    fmt.Println(l.IsEmpty())
+}
+```
+
+### Contain
+
+Determines if a CopyOnWriteList contains an element.
+
+```go
+func (c *CopyOnWriteList[T]) Contain(e T) bool
+```
+
+#### Example
+
+```go
+package main
+
+import (
+"fmt"
+"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+l := list.NewCopyOnWriteList([]int{1,2,3})
+fmt.Println(l.Contain(1))
+}
+```
+
+### ValueOf
+
+Returns a pointer to the value at the index in the list
+
+```go
+func (c *CopyOnWriteList[T]) ValueOf(index int) []T
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.ValueOf(2))
+}
+
+```
+
+### Add
+
+Appends the specified element to the end of the list.
+
+```go
+func (c *CopyOnWriteList[T]) Add(e T) bool
+```
+
+#### Example
+
+```go
+
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	l.Add(4)
+	fmt.Println(l.getList())
+}
+
+```
+
+### AddAll
+
+Appends all the elements of the specified collection to the end of this list
+
+```go
+func (c *CopyOnWriteList[T]) AddAll(e []T) bool
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    l.AddAll([]int{4,5,6})
+    fmt.Println(l.getList())
+}
+
+```
+
+### AddByIndex
+
+Inserts the specified element into the list at the specified position.
+
+```go
+func (c *CopyOnWriteList[T]) AddByIndex(index int, e T) bool
+```
+
+#### Example
+
+```go
+package main
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.AddByIndex(2, 6)
+    fmt.Println(l.getList())
+}
+
+```
+
+### DeleteAt
+
+Removes the element at the specified position in this list.
+
+```go
+func (c *CopyOnWriteList[T]) DeleteAt(index int) (oldValue *T, ok bool)
+```
+
+#### Example
+
+```go
+package main
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteAt(2)
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteIf
+
+Removes the first occurrence of the specified element from this list (if it exists).
+
+```go
+func (c *CopyOnWriteList[T]) DeleteIf(func(T) bool) (oldValue *T, ok bool)
+```
+
+#### Example
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteIf(func(i int) bool {
+        return i == 2
+    })
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteBy
+
+Deletes the first occurrence of the specified element from this list (if it exists).
+
+```go
+func (c *CopyOnWriteList[T]) DeleteBy(e T) (*T bool)
+```
+
+#### Example
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteBy(2)
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteRange
+
+Deletes all elements from this list with indexes between fromIndex (included) and toIndex (not included).
+(leftCloseRightOpen)
+
+```go
+func (c *CopyOnWriteList[T]) DeleteRange(start int, end int)
+```
+
+#### Example
+
+```go
+package main
+import (
+"fmt"
+"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    list.DeleteRange(2, 5)
+    fmt.Println(l.getList())
+}
+```
+
+### Equal
+
+Returns true if the specified object is equal to this list
+
+```go
+func (c *CopyOnWriteList[T]) Equal(e []T) bool
+```
+
+#### Example
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    fmt.Println(l.Equal([]int{1,2,3,4,5,6,7,8,9}))
+}
+```

docs/datastructure/copyonwritelist_zh-CN.md

@@ -0,0 +1,471 @@
+# CopyOnWriteList
+
+CopyOnWriteList 是一个线程安全的 List 实现，底层使用 go 切片。写入时，会复制一份新的切片，写入完成后，再将新的切片赋值给原来的切片。读取时，直接读取原来的切片。
+
+## 源码
+
+-   [https://github.com/duke-git/lancet/blob/main/datastructure/list/copyonwritelist.go](https://github.com/duke-git/lancet/blob/main/datastructure/list/copyonwritelist.go)
+
+## 用法
+
+```go
+import (
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [NewCopyOnWriteList](#NewCopyOnWriteList)
+-   [Size](#Size)
+-   [Get](#Get)
+-   [Set](#Set)
+-   [Remove](#Remove)
+-   [IndexOf](#IndexOf)
+-   [LastIndexOf](#LastIndexOf)
+-   [IsEmpty](#IsEmpty)
+-   [Contain](#Contain)
+-   [ValueOf](#ValueOf)
+-   [Add](#Add)
+-   [AddAll](#AddAll)
+-   [AddByIndex](#AddByIndex)
+-   [DeleteAt](#DeleteAt)
+-   [DeleteIf](#DeleteIf)
+-   [DeleteBy](#DeleteBy)
+-   [DeleteRange](#DeleteRange)
+-   [Equal](#Equal)
+
+## 文档
+
+### NewCopyOnWriteList
+
+返回一个具有空切片的 CopyOnWriteList。
+
+```go
+type CopyOnWriteList[T any] struct {
+    data []T
+    lock sync.Locker
+}
+
+func NewCopyOnWriteList() *CopyOnWriteList
+
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l)
+}
+
+```
+
+### Size
+
+返回 CopyOnWriteList 的长度。
+
+```go
+func (l *CopyOnWriteList[T]) Size() int
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Size())
+}
+
+```
+
+### Get
+
+返回列表中指定位置的元素
+
+```go
+func (c *CopyOnWriteList[T]) Get(index int) *T
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	fmt.Println(l.Get(2))
+}
+
+```
+
+### Set
+
+将此列表中指定位置的元素替换为指定元素。
+
+```go
+func (c *CopyOnWriteList[T]) Set(index int, e T) (oldValue *T, ok bool)
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Set(2, 4))
+}
+
+```
+
+### Remove
+
+### IndexOf
+
+返回列表中值的索引，如果没有找到返回-1。
+
+```go
+func (c *CopyOnWriteList[T]) IndexOf(e T) int
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.IndexOf(1))
+}
+
+```
+
+### LastIndexOf
+
+返回指定元素在此列表中最后出现的索引，如果此列表不包含该元素，则返回-1。
+
+```go
+func (c *CopyOnWriteList[T]) LastIndexOf(e T) int
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3,1})
+	fmt.Println(l.LastIndexOf(1))
+}
+
+```
+
+### IsEmpty
+
+如果此列表不包含任何元素，则返回 true。
+
+```go
+func (c *CopyOnWriteList[T]) IsEmpty() bool
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{})
+	fmt.Println(l.IsEmpty())
+}
+```
+
+### Contain
+
+判断 CopyOnWriteList 是否包含某个元素
+
+```go
+func (c *CopyOnWriteList[T]) Contain(e T) bool
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Contain(1))
+}
+```
+
+### ValueOf
+
+返回列表中索引处的值指针
+
+```go
+func (c *CopyOnWriteList[T]) ValueOf(index int) []T
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.ValueOf(2))
+}
+
+```
+
+### Add
+
+将指定的元素追加到此列表的末尾。
+
+```go
+func (c *CopyOnWriteList[T]) Add(e T) bool
+```
+
+#### 示例
+
+```go
+
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	l.Add(4)
+	fmt.Println(l.getList())
+}
+
+```
+
+### AddAll
+
+将指定集合中的所有元素追加到此列表的末尾
+
+```go
+func (c *CopyOnWriteList[T]) AddAll(e []T) bool
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    l.AddAll([]int{4,5,6})
+    fmt.Println(l.getList())
+}
+
+```
+
+### AddByIndex
+
+将指定元素插入此列表中的指定位置。
+
+```go
+func (c *CopyOnWriteList[T]) AddByIndex(index int, e T) bool
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	list.AddByIndex(2, 6)
+	fmt.Println(l.getList())
+}
+
+```
+
+### DeleteAt
+
+移除此列表中指定位置的元素。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteAt(index int) (oldValue *T, ok bool)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	list.DeleteAt(2)
+	fmt.Println(l.getList())
+}
+```
+
+### DeleteIf
+
+从此列表中删除第一个出现的指定元素(如果该元素存在)。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteIf(f func(T) bool) (oldValue *T, ok bool)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteIf(func(i int) bool {
+        return i == 2
+    })
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteBy
+
+从此列表中删除第一个出现的指定元素(如果该元素存在)。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteBy(e T) (*T bool)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteBy(2)
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteRange
+
+从该列表中删除索引介于 fromIndex(包含)和 toIndex(不包含)之间的所有元素。
+(左闭右开)。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteRange(start int, end int)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    list.DeleteRange(2, 5)
+    fmt.Println(l.getList())
+}
+```
+
+### Equal
+
+如果指定的对象等于此列表，则返回 true。
+
+```go
+func (c *CopyOnWriteList[T]) Equal(e []T) bool
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    fmt.Println(l.Equal([]int{1,2,3,4,5,6,7,8,9}))
+}
+```

docs/datastructure/hashmap_zh-CN.md

@@ -46,7 +46,7 @@ import (
 func NewHashMap() *HashMap
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -72,7 +72,7 @@ func main() {
 func NewHashMapWithCapacity(size, capacity uint64) *HashMap
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -98,7 +98,7 @@ func main() {
 func (hm *HashMap) Get(key any) any
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -126,7 +126,7 @@ func main() {
 func (hm *HashMap) Put(key any, value any) any
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -155,7 +155,7 @@ func main() {
 func (hm *HashMap) Delete(key any)
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -187,7 +187,7 @@ func main() {
 func (hm *HashMap) Contains(key any) bool
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -217,7 +217,7 @@ func main() {
 func (hm *HashMap) Iterate(iteratee func(key, value any))
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -252,7 +252,7 @@ func main() {
 func (hm *HashMap) Keys() []any
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -284,7 +284,7 @@ func main() {
 func (hm *HashMap) Values() []any
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main

docs/datastructure/heap_zh-CN.md

@@ -48,7 +48,7 @@ type MaxHeap[T any] struct {
 }
 func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -89,7 +89,7 @@ func main() {
 ```go
 func (h *MaxHeap[T]) Push(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -136,7 +136,7 @@ func main() {
 ```go
 func (h *MaxHeap[T]) Pop() (T, bool)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -184,7 +184,7 @@ func main() {
 ```go
 func (h *MaxHeap[T]) Peek() (T, bool)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -232,7 +232,7 @@ func main() {
 ```go
 func (h *MaxHeap[T]) Data() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -277,7 +277,7 @@ func main() {
 ```go
 func (h *MaxHeap[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -323,7 +323,7 @@ func main() {
 ```go
 func (h *MaxHeap[T]) PrintStructure()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main

docs/datastructure/link.md

@@ -132,12 +132,12 @@ func main() {
 
 
 ### <span id="SinglyLink_InsertAt">InsertAt</span>
-<p>Insert value into singly linklist at index, index shoud be great or equal 0 and less or equal number of link nodes</p>
+<p>Insert value into singly linklist at index, param `index` should between [0, len(SinglyLink)], if index do not meet the conditions, do nothing</p>
 
 <b>Signature:</b>
 
 ```go
-func (link *SinglyLink[T]) InsertAt(index int, value T) error
+func (link *SinglyLink[T]) InsertAt(index int, value T)
 ```
 <b>Example:</b>
 
@@ -152,6 +152,8 @@ import (
 func main() {
     lk := link.NewSinglyLink[int]()
 
+    lk.InsertAt(1, 1) //do nothing
+    
     lk.InsertAt(0, 1)
     lk.InsertAt(1, 2)
     lk.InsertAt(2, 3)
@@ -228,12 +230,12 @@ func main() {
 
 
 ### <span id="SinglyLink_DeleteAt">DeleteAt</span>
-<p>Delete value at specific index, index shoud be great or equal 0 and less or less than number of link nodes - 1</p>
+<p>Delete value at specific index, param `index` should be [0, len(SinglyLink)-1]</p>
 
 <b>Signature:</b>
 
 ```go
-func (link *SinglyLink[T]) DeleteAt(index int) error
+func (link *SinglyLink[T]) DeleteAt(index int)
 ```
 <b>Example:</b>
 
@@ -253,9 +255,8 @@ func main() {
     lk.InsertAtTail(3)
     lk.InsertAtTail(4)
 
-    err := lk.DeleteAt(3)
+    lk.DeleteAt(3)
 
-    fmt.Println(err) //nil
     fmt.Println(lk.Values()) //[]int{1, 2, 3}
 }
 ```
@@ -268,7 +269,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func (link *SinglyLink[T]) DeleteAtHead() error
+func (link *SinglyLink[T]) DeleteAtHead()
 ```
 <b>Example:</b>
 
@@ -288,9 +289,8 @@ func main() {
     lk.InsertAtTail(3)
     lk.InsertAtTail(4)
 
-    err := lk.DeleteAtHead()
+    lk.DeleteAtHead()
     
-    fmt.Println(err) //nil
     fmt.Println(lk.Values()) //[]int{2, 3, 4}
 }
 ```
@@ -304,7 +304,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func (link *SinglyLink[T]) DeleteAtTail() error
+func (link *SinglyLink[T]) DeleteAtTail()
 ```
 <b>Example:</b>
 
@@ -323,9 +323,8 @@ func main() {
     lk.InsertAtTail(2)
     lk.InsertAtTail(3)
 
-    err := lk.DeleteAtTail()
+    lk.DeleteAtTail()
     
-    fmt.Println(err) //nil
     fmt.Println(lk.Values()) //[]int{1, 2}
 }
 ```
@@ -628,12 +627,12 @@ func main() {
 
 
 ### <span id="DoublyLink_InsertAt">InsertAt</span>
-<p>Insert value into doubly linklist at index, index shoud be great or equal 0 and less or equal number of link nodes</p>
+<p>Insert value into doubly linklist at index, param `index` should between [0, len(DoublyLink)], if index do not meet the conditions, do nothing</p>
 
 <b>Signature:</b>
 
 ```go
-func (link *DoublyLink[T]) InsertAt(index int, value T) error
+func (link *DoublyLink[T]) InsertAt(index int, value T)
 ```
 <b>Example:</b>
 
@@ -648,6 +647,8 @@ import (
 func main() {
     lk := link.NewDoublyLink[int]()
 
+    lk.InsertAt(1, 1) //do nothing
+
     lk.InsertAt(0, 1)
     lk.InsertAt(1, 2)
     lk.InsertAt(2, 3)
@@ -724,12 +725,12 @@ func main() {
 
 
 ### <span id="DoublyLink_DeleteAt">DeleteAt</span>
-<p>Delete value at specific index, index shoud be great or equal 0 and less or less than number of link nodes - 1</p>
+<p>Delete value at specific index, param `index` should be [0, len(DoublyLink)-1]</p>
 
 <b>Signature:</b>
 
 ```go
-func (link *DoublyLink[T]) DeleteAt(index int) error
+func (link *DoublyLink[T]) DeleteAt(index int)
 ```
 <b>Example:</b>
 
@@ -749,9 +750,8 @@ func main() {
     lk.InsertAtTail(3)
     lk.InsertAtTail(4)
 
-    err := lk.DeleteAt(3)
+    lk.DeleteAt(3)
 
-    fmt.Println(err) //nil
     fmt.Println(lk.Values()) //[]int{1, 2, 3}
 }
 ```
@@ -764,7 +764,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func (link *DoublyLink[T]) DeleteAtHead() error
+func (link *DoublyLink[T]) DeleteAtHead()
 ```
 <b>Example:</b>
 
@@ -784,9 +784,8 @@ func main() {
     lk.InsertAtTail(3)
     lk.InsertAtTail(4)
 
-    err := lk.DeleteAtHead()
+    lk.DeleteAtHead()
     
-    fmt.Println(err) //nil
     fmt.Println(lk.Values()) //[]int{2, 3, 4}
 }
 ```

docs/datastructure/link_zh-CN.md

@@ -81,7 +81,7 @@ type SinglyLink[T any] struct {
 }
 func NewSinglyLink[T any]() *SinglyLink[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -107,7 +107,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) Values() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -132,14 +132,14 @@ func main() {
 
 
 ### <span id="SinglyLink_InsertAt">InsertAt</span>
-<p>将值插入到索引处的链表中，索引应大于或等于 0 且小于或等于链表节点数</p>
+<p>将值插入到索引处的链表中，索引应大于或等于0且小于或等于链表节点数</p>
 
 <b>函数签名:</b>
 
 ```go
-func (link *SinglyLink[T]) InsertAt(index int, value T) error
+func (link *SinglyLink[T]) InsertAt(index int, value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -152,6 +152,8 @@ import (
 func main() {
     lk := link.NewSinglyLink[int]()
 
+    lk.InsertAt(1, 1) //do nothing
+
     lk.InsertAt(0, 1)
     lk.InsertAt(1, 2)
     lk.InsertAt(2, 3)
@@ -172,7 +174,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) InsertAtHead(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -204,7 +206,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) InsertAtTail(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -228,14 +230,14 @@ func main() {
 
 
 ### <span id="SinglyLink_DeleteAt">DeleteAt</span>
-<p>删除特定索引处的值，索引应大于或等于0且小于或等于链接节点数 - 1</p>
+<p>删除特定索引处的值，索引应大于或等于0且小于或等于链接节点数-1</p>
 
 <b>函数签名:</b>
 
 ```go
-func (link *SinglyLink[T]) DeleteAt(index int) error
+func (link *SinglyLink[T]) DeleteAt(index int)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -253,9 +255,8 @@ func main() {
     lk.InsertAtTail(3)
     lk.InsertAtTail(4)
 
-    err := lk.DeleteAt(3)
+    lk.DeleteAt(3)
 
-    fmt.Println(err) //nil
     fmt.Println(lk.Values()) //[]int{1, 2, 3}
 }
 ```
@@ -268,9 +269,9 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func (link *SinglyLink[T]) DeleteAtHead() error
+func (link *SinglyLink[T]) DeleteAtHead()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -288,9 +289,8 @@ func main() {
     lk.InsertAtTail(3)
     lk.InsertAtTail(4)
 
-    err := lk.DeleteAtHead()
+    lk.DeleteAtHead()
     
-    fmt.Println(err) //nil
     fmt.Println(lk.Values()) //[]int{2, 3, 4}
 }
 ```
@@ -304,9 +304,9 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func (link *SinglyLink[T]) DeleteAtTail() error
+func (link *SinglyLink[T]) DeleteAtTail()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -323,9 +323,8 @@ func main() {
     lk.InsertAtTail(2)
     lk.InsertAtTail(3)
 
-    err := lk.DeleteAtTail()
+    lk.DeleteAtTail()
     
-    fmt.Println(err) //nil
     fmt.Println(lk.Values()) //[]int{1, 2}
 }
 ```
@@ -340,7 +339,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) DeleteValue(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -374,7 +373,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) Reverse()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -406,7 +405,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) GetMiddleNode() *datastructure.LinkNode[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -438,7 +437,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -469,7 +468,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -501,7 +500,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -534,7 +533,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -577,7 +576,7 @@ type DoublyLink[T any] struct {
 }
 func NewDoublyLink[T any]() *DoublyLink[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -603,7 +602,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) Values() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -628,14 +627,14 @@ func main() {
 
 
 ### <span id="DoublyLink_InsertAt">InsertAt</span>
-<p>将值插入到索引处的链表中，索引应大于或等于 0 且小于或等于链表节点数</p>
+<p>将值插入到索引处的链表中，索引应大于或等于0且小于或等于链表节点数</p>
 
 <b>函数签名:</b>
 
 ```go
-func (link *DoublyLink[T]) InsertAt(index int, value T) error
+func (link *DoublyLink[T]) InsertAt(index int, value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -648,6 +647,8 @@ import (
 func main() {
     lk := link.NewDoublyLink[int]()
 
+    lk.InsertAt(1, 1) //do nothing
+
     lk.InsertAt(0, 1)
     lk.InsertAt(1, 2)
     lk.InsertAt(2, 3)
@@ -668,7 +669,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) InsertAtHead(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -700,7 +701,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) InsertAtTail(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -724,14 +725,14 @@ func main() {
 
 
 ### <span id="DoublyLink_DeleteAt">DeleteAt</span>
-<p>删除特定索引处的值，索引应大于或等于0且小于或等于链接节点数 - 1</p>
+<p>删除特定索引处的值，索引应大于或等于0且小于或等于链接节点数-1</p>
 
 <b>函数签名:</b>
 
 ```go
-func (link *DoublyLink[T]) DeleteAt(index int) error
+func (link *DoublyLink[T]) DeleteAt(index int)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -749,9 +750,8 @@ func main() {
     lk.InsertAtTail(3)
     lk.InsertAtTail(4)
 
-    err := lk.DeleteAt(3)
+    lk.DeleteAt(3)
 
-    fmt.Println(err) //nil
     fmt.Println(lk.Values()) //[]int{1, 2, 3}
 }
 ```
@@ -764,9 +764,9 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func (link *DoublyLink[T]) DeleteAtHead() error
+func (link *DoublyLink[T]) DeleteAtHead()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -784,9 +784,8 @@ func main() {
     lk.InsertAtTail(3)
     lk.InsertAtTail(4)
 
-    err := lk.DeleteAtHead()
+    lk.DeleteAtHead()
     
-    fmt.Println(err) //nil
     fmt.Println(lk.Values()) //[]int{2, 3, 4}
 }
 ```
@@ -800,9 +799,9 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func (link *DoublyLink[T]) DeleteAtTail() error
+func (link *DoublyLink[T]) DeleteAtTail()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -819,9 +818,8 @@ func main() {
     lk.InsertAtTail(2)
     lk.InsertAtTail(3)
 
-    err := lk.DeleteAtTail()
+    lk.DeleteAtTail()
     
-    fmt.Println(err) //nil
     fmt.Println(lk.Values()) //[]int{1, 2}
 }
 ```
@@ -837,7 +835,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) Reverse()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -869,7 +867,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) GetMiddleNode() *datastructure.LinkNode[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -901,7 +899,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -932,7 +930,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -964,7 +962,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -997,7 +995,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main

docs/datastructure/list.md

@@ -47,6 +47,13 @@ import (
 - [Unique](#Unique)
 - [Union](#Union)
 - [Intersection](#Intersection)
+- [Difference](#Difference)
+- [SymmetricDifference](#SymmetricDifference)
+- [RetainAll](#RetainAll)
+- [DeleteAll](#DeleteAll)
+- [ForEach](#ForEach)
+- [Iterator](#Iterator)
+- [ListToMap](#ListToMap)
 - [SubList](#SubList)
 - [DeleteIf](#DeleteIf)
 
@@ -62,7 +69,7 @@ NewList function return a list pointer</p>
 
 ```go
 type List[T any] struct {
-	data []T
+    data []T
 }
 func NewList[T any](data []T) *List[T]
 ```
@@ -671,8 +678,8 @@ import (
 )
 
 func main() {
-	data := make([]int, 0, 100)
-	
+    data := make([]int, 0, 100)
+    
     li := list.NewList(data)
 
     fmt.Println(li.Cap()) // 100
@@ -828,6 +835,233 @@ func main() {
 
 
 
+### <span id="Difference">Difference</span>
+<p>Return a list whose element in the original list, not in the given list.</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Difference(other *List[T]) *List[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list1 := NewList([]int{1, 2, 3})
+    list2 := NewList([]int{1, 2, 4})
+
+    list3 := list1.Intersection(list2)
+
+    fmt.Println(list3.Data()) //3
+}
+```
+
+
+### <span id="SymmetricDifference">SymmetricDifference</span>
+<p>Oppoiste operation of intersection function.</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) SymmetricDifference(other *List[T]) *List[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list1 := NewList([]int{1, 2, 3})
+    list2 := NewList([]int{1, 2, 4})
+
+    list3 := list1.Intersection(list2)
+
+    fmt.Println(list3.Data()) //3, 4
+}
+```
+
+
+### <span id="RetainAll">RetainAll</span>
+<p>Retains only the elements in this list that are contained in the given list.</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) RetainAll(list *List[T]) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list := NewList([]int{1, 2, 3, 4})
+    list1 := NewList([]int{1, 2, 3, 4})
+    list2 := NewList([]int{1, 2, 3, 4})
+
+    retain := NewList([]int{1, 2})
+    retain1 := NewList([]int{2, 3})
+    retain2 := NewList([]int{1, 2, 5})
+
+    list.RetainAll(retain)
+    list1.RetainAll(retain1)
+    list2.RetainAll(retain2)
+
+    fmt.Println(list.Data()) //1, 2
+    fmt.Println(list1.Data()) //2, 3
+    fmt.Println(list2.Data()) //1, 2
+}
+```
+
+
+### <span id="DeleteAll">DeleteAll</span>
+<p>Removes from this list all of its elements that are contained in the given list.</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) DeleteAll(list *List[T]) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list := NewList([]int{1, 2, 3, 4})
+    list1 := NewList([]int{1, 2, 3, 4})
+    list2 := NewList([]int{1, 2, 3, 4})
+
+    del := NewList([]int{1})
+    del1 := NewList([]int{2, 3})
+    del2 := NewList([]int{1, 2, 5})
+
+    list.DeleteAll(del)
+    list1.DeleteAll(del1)
+    list2.DeleteAll(del2)
+
+    fmt.Println(list.Data()) //2,3,4
+    fmt.Println(list1.Data()) //1,4
+    fmt.Println(list2.Data()) //3,4
+}
+```
+
+
+### <span id="ForEach">ForEach</span>
+<p>Performs the given action for each element of the list.</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) ForEach(consumer func(T))
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list := NewList([]int{1, 2, 3, 4})
+
+    result := make([]int, 0)
+    list.ForEach(func(i int) {
+        result = append(result, i)
+    })
+
+    fmt.Println(result.Data()) //1,2,3,4
+}
+```
+
+
+### <span id="Iterator">Iterator</span>
+<p>Returns an iterator over the elements in this list in proper sequence.</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Iterator() iterator.Iterator[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list := NewList([]int{1, 2, 3, 4})
+
+    iterator := list.Iterator()
+
+    result := make([]int, 0)
+    for iterator.HasNext() {
+        item, _ := iterator.Next()
+        result = append(result, item)
+    }
+
+    fmt.Println(result.Data()) //1,2,3,4
+}
+```
+
+
+### <span id="ListToMap">ListToMap</span>
+<p>Converts a list to a map based on iteratee function.</p>
+
+<b>Signature:</b>
+
+```go
+func ListToMap[T any, K comparable, V any](list *List[T], iteratee func(T) (K, V)) map[K]V
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list := NewList([]int{1, 2, 3, 4})
+
+    result := ListToMap(list, func(n int) (int, bool) {
+        return n, n > 1
+    })
+
+    fmt.Println(result) //map[int]bool{1: false, 2: true, 3: true, 4: true}
+}
+```
 
 ### <span id="SubList">SubList</span>
 <p>SubList returns a sub list of the original list between the specified fromIndex, inclusive, and toIndex, exclusive.</p>
@@ -876,9 +1110,9 @@ import (
 )
 
 func main() {
-	l := list.NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})
+    l := list.NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})
 
-	fmt.Println(l.DeleteIf(func(a int) bool { return a == 1 })) // 12 
-	fmt.Println(l.Data()) // []int{2, 3, 4}
+    fmt.Println(l.DeleteIf(func(a int) bool { return a == 1 })) // 12 
+    fmt.Println(l.Data()) // []int{2, 3, 4}
 }
 ```

docs/datastructure/list_zh-CN.md

@@ -34,7 +34,6 @@ import (
 - [PopLast](#PopLast)
 - [DeleteAt](#DeleteAt)
 - [InsertAt](#InsertAt)
-
 - [UpdateAt](#UpdateAt)
 - [Equal](#Equal)
 - [IsEmpty](#IsEmpty)
@@ -48,6 +47,13 @@ import (
 - [Unique](#Unique)
 - [Union](#Union)
 - [Intersection](#Intersection)
+- [Difference](#Difference)
+- [SymmetricDifference](#SymmetricDifference)
+- [RetainAll](#RetainAll)
+- [DeleteAll](#DeleteAll)
+- [ForEach](#ForEach)
+- [Iterator](#Iterator)
+- [ListToMap](#ListToMap)
 - [SubList](#SubList)
 - [DeleteIf](#DeleteIf)
 
@@ -62,11 +68,11 @@ import (
 
 ```go
 type List[T any] struct {
-	data []T
+    data []T
 }
 func NewList[T any](data []T) *List[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -92,7 +98,7 @@ func main() {
 ```go
 func (l *List[T]) Contain(value T) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -121,7 +127,7 @@ func main() {
 ```go
 func (l *List[T]) Data() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -150,7 +156,7 @@ func main() {
 ```go
 func (l *List[T]) ValueOf(index int) (*T, bool)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -180,7 +186,7 @@ func main() {
 ```go
 func (l *List[T]) IndexOf(value T) int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -207,7 +213,7 @@ func main() {
 ```go
 func (l *List[T]) LastIndexOf(value T) int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -233,7 +239,7 @@ func main() {
 ```go
 func (l *List[T]) IndexOfFunc(f func(T) bool) int 
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -259,7 +265,7 @@ func main() {
 ```go
 func (l *List[T]) LastIndexOfFunc(f func(T) bool) int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -287,7 +293,7 @@ func main() {
 ```go
 func (l *List[T]) Push(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -316,7 +322,7 @@ func main() {
 ```go
 func (l *List[T]) PopFirst() (*T, bool)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -348,7 +354,7 @@ func main() {
 ```go
 func (l *List[T]) PopLast() (*T, bool)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -379,7 +385,7 @@ func main() {
 ```go
 func (l *List[T]) DeleteAt(index int)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -417,7 +423,7 @@ func main() {
 ```go
 func (l *List[T]) InsertAt(index int, value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -454,7 +460,7 @@ func main() {
 ```go
 func (l *List[T]) UpdateAt(index int, value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -487,7 +493,7 @@ func main() {
 ```go
 func (l *List[T]) Equal(other *List[T]) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -517,7 +523,7 @@ func main() {
 ```go
 func (l *List[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -547,7 +553,7 @@ func main() {
 ```go
 func (l *List[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -575,7 +581,7 @@ func main() {
 ```go
 func (l *List[T]) Clone() *List[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -604,7 +610,7 @@ func main() {
 ```go
 func (l *List[T]) Merge(other *List[T]) *List[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -633,7 +639,7 @@ func main() {
 ```go
 func (l *List[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -660,7 +666,7 @@ func main() {
 ```go
 func (l *List[T]) Cap() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -671,8 +677,8 @@ import (
 )
 
 func main() {
-	data := make([]int, 0, 100)
-	
+    data := make([]int, 0, 100)
+    
     li := list.NewList(data)
 
     fmt.Println(li.Cap()) // 100
@@ -689,7 +695,7 @@ func main() {
 ```go
 func (l *List[T]) Swap(i, j int)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -718,7 +724,7 @@ func main() {
 ```go
 func (l *List[T]) Reverse()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -747,7 +753,7 @@ func main() {
 ```go
 func (l *List[T]) Unique()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -776,7 +782,7 @@ func main() {
 ```go
 func (l *List[T]) Union(other *List[T]) *List[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -806,7 +812,7 @@ func main() {
 ```go
 func (l *List[T]) Intersection(other *List[T]) *List[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -826,16 +832,244 @@ func main() {
 ```
 
 
+### <span id="Difference">Difference</span>
+<p>差集运算。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Difference(other *List[T]) *List[T]
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list1 := NewList([]int{1, 2, 3})
+    list2 := NewList([]int{1, 2, 4})
+
+    list3 := list1.Intersection(list2)
+
+    fmt.Println(list3.Data()) //3
+}
+```
+
+
+### <span id="SymmetricDifference">SymmetricDifference</span>
+<p>对称差集运算。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) SymmetricDifference(other *List[T]) *List[T]
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list1 := NewList([]int{1, 2, 3})
+    list2 := NewList([]int{1, 2, 4})
+
+    list3 := list1.Intersection(list2)
+
+    fmt.Println(list3.Data()) //3, 4
+}
+```
+
+
+### <span id="RetainAll">RetainAll</span>
+<p>仅保留列表中包含在给定列表中的元素。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) RetainAll(list *List[T]) bool
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list := NewList([]int{1, 2, 3, 4})
+    list1 := NewList([]int{1, 2, 3, 4})
+    list2 := NewList([]int{1, 2, 3, 4})
+
+    retain := NewList([]int{1, 2})
+    retain1 := NewList([]int{2, 3})
+    retain2 := NewList([]int{1, 2, 5})
+
+    list.RetainAll(retain)
+    list1.RetainAll(retain1)
+    list2.RetainAll(retain2)
+
+    fmt.Println(list.Data()) //1, 2
+    fmt.Println(list1.Data()) //2, 3
+    fmt.Println(list2.Data()) //1, 2
+}
+```
+
+
+### <span id="DeleteAll">DeleteAll</span>
+<p>从列表中删除给定列表中包含的所有元素。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) DeleteAll(list *List[T]) bool
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list := NewList([]int{1, 2, 3, 4})
+    list1 := NewList([]int{1, 2, 3, 4})
+    list2 := NewList([]int{1, 2, 3, 4})
+
+    del := NewList([]int{1})
+    del1 := NewList([]int{2, 3})
+    del2 := NewList([]int{1, 2, 5})
+
+    list.DeleteAll(del)
+    list1.DeleteAll(del1)
+    list2.DeleteAll(del2)
+
+    fmt.Println(list.Data()) //2,3,4
+    fmt.Println(list1.Data()) //1,4
+    fmt.Println(list2.Data()) //3,4
+}
+```
+
+
+### <span id="ForEach">ForEach</span>
+<p>对列表的每个元素执行给定的操作。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) ForEach(consumer func(T))
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list := NewList([]int{1, 2, 3, 4})
+
+    result := make([]int, 0)
+    list.ForEach(func(i int) {
+        result = append(result, i)
+    })
+
+    fmt.Println(result.Data()) //1,2,3,4
+}
+```
+
+
+### <span id="Iterator">Iterator</span>
+<p>按顺序返回列表中元素的迭代器。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Iterator() iterator.Iterator[T]
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list := NewList([]int{1, 2, 3, 4})
+
+    iterator := list.Iterator()
+
+    result := make([]int, 0)
+    for iterator.HasNext() {
+        item, _ := iterator.Next()
+        result = append(result, item)
+    }
+
+    fmt.Println(result.Data()) //1,2,3,4
+}
+```
+
+
+### <span id="ListToMap">ListToMap</span>
+<p>基于iteratee函数将列表转换为映射map。</p>
+
+<b>函数签名:</b>
+
+```go
+func ListToMap[T any, K comparable, V any](list *List[T], iteratee func(T) (K, V)) map[K]V
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    list := NewList([]int{1, 2, 3, 4})
+
+    result := ListToMap(list, func(n int) (int, bool) {
+        return n, n > 1
+    })
+
+    fmt.Println(result) //map[int]bool{1: false, 2: true, 3: true, 4: true}
+}
+```
+
 
 ### <span id="SubList">SubList</span>
-<p>SubList returns a sub list of the original list between the specified fromIndex, inclusive, and toIndex, exclusive.</p>
+<p>返回指定的fromIndex（包含）和toIndex（不包含）之间的原始列表的子列表。</p>
 
 <b>函数签名:</b>
 
 ```go
 func (l *List[T]) SubList(fromIndex, toIndex int) *List[T] 
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -863,7 +1097,7 @@ func main() {
 ```go
 func (l *List[T]) DeleteIf(f func(T) bool) int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -874,9 +1108,9 @@ import (
 )
 
 func main() {
-	l := list.NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})
+    l := list.NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})
 
-	fmt.Println(l.DeleteIf(func(a int) bool { return a == 1 })) // 12 
-	fmt.Println(l.Data()) // []int{2, 3, 4}
+    fmt.Println(l.DeleteIf(func(a int) bool { return a == 1 })) // 12 
+    fmt.Println(l.Data()) // []int{2, 3, 4}
 }
 ```

docs/datastructure/queue_zh-CN.md

@@ -99,7 +99,7 @@ type ArrayQueue[T any] struct {
 	size     int
 }
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -125,7 +125,7 @@ func main() {
 ```go
 func (q *ArrayQueue[T]) Data() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -152,7 +152,7 @@ func main() {
 ```go
 func (q *ArrayQueue[T]) Enqueue(item T) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -183,7 +183,7 @@ func main() {
 ```go
 func (q *ArrayQueue[T]) Dequeue() (T, bool)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -215,7 +215,7 @@ func main() {
 ```go
 func (q *ArrayQueue[T]) Front() T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -247,7 +247,7 @@ func main() {
 ```go
 func (q *ArrayQueue[T]) Back() T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -278,7 +278,7 @@ func main() {
 ```go
 func (q *ArrayQueue[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -308,7 +308,7 @@ func main() {
 ```go
 func (q *ArrayQueue[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -341,7 +341,7 @@ func main() {
 ```go
 func (q *ArrayQueue[T]) IsFull() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -373,7 +373,7 @@ func main() {
 ```go
 func (q *ArrayQueue[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -404,7 +404,7 @@ func main() {
 ```go
 func (q *ArrayQueue[T]) Contain(value T) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -448,7 +448,7 @@ type QueueNode[T any] struct {
 	Next  *QueueNode[T]
 }
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -474,7 +474,7 @@ func main() {
 ```go
 func (q *LinkedQueue[T]) Data() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -501,7 +501,7 @@ func main() {
 ```go
 func (q *LinkedQueue[T]) Enqueue(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -532,7 +532,7 @@ func main() {
 ```go
 func (q *LinkedQueue[T]) Dequeue() (T, error)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -564,7 +564,7 @@ func main() {
 ```go
 func (q *LinkedQueue[T]) Front() (*T, error)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -596,7 +596,7 @@ func main() {
 ```go
 func (q *LinkedQueue[T]) Back() (*T, error) 
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -627,7 +627,7 @@ func main() {
 ```go
 func (q *LinkedQueue[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -657,7 +657,7 @@ func main() {
 ```go
 func (q *LinkedQueue[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -690,7 +690,7 @@ func main() {
 ```go
 func (q *LinkedQueue[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -721,7 +721,7 @@ func main() {
 ```go
 func (q *LinkedQueue[T]) Contain(value T) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -763,7 +763,7 @@ type CircularQueue[T any] struct {
 	capacity  int
 }
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -789,7 +789,7 @@ func main() {
 ```go
 func (q *CircularQueue[T]) Data() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -816,7 +816,7 @@ func main() {
 ```go
 func (q *CircularQueue[T]) Enqueue(value T) error
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -847,7 +847,7 @@ func main() {
 ```go
 func (q *CircularQueue[T]) Dequeue() (*T, bool)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -880,7 +880,7 @@ func main() {
 ```go
 func (q *CircularQueue[T]) Front() T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -912,7 +912,7 @@ func main() {
 ```go
 func (q *CircularQueue[T]) Back() T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -943,7 +943,7 @@ func main() {
 ```go
 func (q *CircularQueue[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -973,7 +973,7 @@ func main() {
 ```go
 func (q *CircularQueue[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -1006,7 +1006,7 @@ func main() {
 ```go
 func (q *CircularQueue[T]) IsFull() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -1038,7 +1038,7 @@ func main() {
 ```go
 func (q *CircularQueue[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -1069,7 +1069,7 @@ func main() {
 ```go
 func (q *CircularQueue[T]) Contain(value T) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -1108,7 +1108,7 @@ type PriorityQueue[T any] struct {
 	comparator lancetconstraints.Comparator
 }
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -1134,7 +1134,7 @@ func main() {
 ```go
 func (q *PriorityQueue[T]) Data() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -1161,7 +1161,7 @@ func main() {
 ```go
 func (q *PriorityQueue[T]) Enqueue(item T) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -1207,7 +1207,7 @@ func main() {
 ```go
 func (q *PriorityQueue[T]) Dequeue() (T, bool)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -1254,7 +1254,7 @@ func main() {
 ```go
 func (q *PriorityQueue[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -1301,7 +1301,7 @@ func main() {
 ```go
 func (q *PriorityQueue[T]) IsFull() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -1348,7 +1348,7 @@ func main() {
 ```go
 func (q *PriorityQueue[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main

docs/datastructure/set.md

@@ -1,16 +1,17 @@
 # Set
+
 Set is a data container, like list, but elements of set is not duplicate.
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Source
 
-- [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)
-
+-   [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage
+
 ```go
 import (
     set "github.com/duke-git/lancet/v2/datastructure/set"
@@ -21,38 +22,41 @@ import (
 
 ## Index
 
-- [NewSet](#NewSet)
-- [Values](#Values)
-- [Add](#Add)
-- [Delete](#Delete)
-- [Contain](#Contain)
-- [ContainAll](#ContainAll)
-- [Clone](#Clone)
-- [Size](#Size)
-- [Equal](#Equal)
-- [Iterate](#Iterate)
-- [IsEmpty](#IsEmpty)
-- [Union](#Union)
-- [Intersection](#Intersection)
-
-- [SymmetricDifference](#SymmetricDifference)
-- [Minus](#Minus)
-
-
+-   [NewSet](#NewSet)
+-   [NewSetFromSlice](#NewSetFromSlice)
+-   [Values](#Values)
+-   [Add](#Add)
+-   [AddIfNotExist](#AddIfNotExist)
+-   [AddIfNotExistBy](#AddIfNotExistBy)
+-   [Delete](#Delete)
+-   [Contain](#Contain)
+-   [ContainAll](#ContainAll)
+-   [Clone](#Clone)
+-   [Size](#Size)
+-   [Equal](#Equal)
+-   [Iterate](#Iterate)
+-   [EachWithBreak](#EachWithBreak)
+-   [IsEmpty](#IsEmpty)
+-   [Union](#Union)
+-   [Intersection](#Intersection)
+-   [SymmetricDifference](#SymmetricDifference)
+-   [Minus](#Minus)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
 ### <span id="NewSet">NewSet</span>
-<p>Make a Set instance</p>
+
+<p>Create a set instance</p>
 
 <b>Signature:</b>
 
 ```go
 type Set[T comparable] map[T]bool
-func NewSet[T comparable](values ...T) Set[T]
+func NewSet[T comparable](items ...T) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -69,10 +73,34 @@ func main() {
 }
 ```
 
+### <span id="NewSetFromSlice">NewSetFromSlice</span>
 
+<p>Create a set from slice</p>
 
+<b>Signature:</b>
+
+```go
+func NewSetFromSlice[T comparable](items []T) Set[T]
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSetFromSlice([]int{1, 2, 2, 3})
+    fmt.Println(st.Values()) //1,2,3
+}
+```
 
 ### <span id="Values">Values</span>
+
 <p>Return slice of all set data</p>
 
 <b>Signature:</b>
@@ -80,6 +108,7 @@ func main() {
 ```go
 func (s Set[T]) Values() []T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -96,17 +125,16 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Add">Add</span>
-<p>Add value to set</p>
+
+<p>Add items to set</p>
 
 <b>Signature:</b>
 
 ```go
-func (s Set[T]) Add(values ...T)
+func (s Set[T]) Add(items ...T)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -125,16 +153,88 @@ func main() {
 }
 ```
 
+### <span id="AddIfNotExist">AddIfNotExist</span>
 
-
-### <span id="Delete">Delete</span>
-<p>Delete value in set</p>
+<p>AddIfNotExist checks if item exists in the set, it adds the item to set and returns true if it does not exist in the set, or else it does nothing and returns false.</p>
 
 <b>Signature:</b>
 
 ```go
-func (s Set[T]) Delete(values ...T)
+func (s Set[T]) AddIfNotExist(item T) bool
 ```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int]()
+    st.Add(1, 2, 3)
+
+    r1 := st.AddIfNotExist(1)
+    r2 := st.AddIfNotExist(4)
+
+    fmt.Println(r1) // false
+    fmt.Println(r2) // true
+    fmt.Println(st.Values()) // 1,2,3,4
+}
+```
+
+### <span id="AddIfNotExistBy">AddIfNotExistBy</span>
+
+<p>AddIfNotExistBy checks if item exists in the set and pass the `checker` function it adds the item to set and returns true if it does not exists in the set and function `checker` returns true, or else it does nothing and returns false.</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int]()
+    st.Add(1, 2)
+
+    ok := st.AddIfNotExistBy(3, func(val int) bool {
+        return val%2 != 0
+    })
+    fmt.Println(ok) // true
+
+
+    notOk := st.AddIfNotExistBy(4, func(val int) bool {
+        return val%2 != 0
+    })
+    fmt.Println(notOk) // false
+
+    fmt.Println(st.Values()) // 1, 2, 3
+}
+```
+
+### <span id="Delete">Delete</span>
+
+<p>Delete item in set</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Delete(items ...T)
+```
+
 <b>Example:</b>
 
 ```go
@@ -154,16 +254,16 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Contain">Contain</span>
-<p>Check if value is in set or not</p>
+
+<p>Check if item is in set or not</p>
 
 <b>Signature:</b>
 
 ```go
-func (s Set[T]) Contain(value T) bool
+func (s Set[T]) Contain(item T) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -183,10 +283,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="ContainAll">ContainAll</span>
+
 <p>Checks if set contains another set</p>
 
 <b>Signature:</b>
@@ -194,6 +292,7 @@ func main() {
 ```go
 func (s Set[T]) ContainAll(other Set[T]) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -206,17 +305,16 @@ import (
 
 func main() {
     set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(1, 2)
-	set3 := set.NewSet(1, 2, 3, 4)
+    set2 := set.NewSet(1, 2)
+    set3 := set.NewSet(1, 2, 3, 4)
 
     fmt.Println(set1.ContainAll(set2)) //true
     fmt.Println(set1.ContainAll(set3)) //false
 }
 ```
 
-
-
 ### <span id="Size">Size</span>
+
 <p>Get the number of elements in set</p>
 
 <b>Signature:</b>
@@ -224,6 +322,7 @@ func main() {
 ```go
 func (s Set[T]) Size() int
 ```
+
 <b>Example:</b>
 
 ```go
@@ -241,9 +340,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Clone">Clone</span>
+
 <p>Make a copy of set</p>
 
 <b>Signature:</b>
@@ -251,6 +349,7 @@ func main() {
 ```go
 func (s Set[T]) Clone() Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -270,10 +369,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Equal">Equal</span>
+
 <p>Check if two sets has same elements or not</p>
 
 <b>Signature:</b>
@@ -281,6 +378,7 @@ func main() {
 ```go
 func (s Set[T]) Equal(other Set[T]) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -301,16 +399,16 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Iterate">Iterate</span>
+
 <p>Call function by every element of set</p>
 
 <b>Signature:</b>
 
 ```go
-func (s Set[T]) Iterate(fn func(value T))
+func (s Set[T]) Iterate(fn func(item T))
 ```
+
 <b>Example:</b>
 
 ```go
@@ -324,17 +422,53 @@ import (
 func main() {
     set1 := set.NewSet(1, 2, 3)
     arr := []int{}
-    set.Iterate(func(value int) {
-        arr = append(arr, value)
+    set.Iterate(func(item int) {
+        arr = append(arr, item)
     })
 
     fmt.Println(arr) //1,2,3
 }
 ```
 
+### <span id="EachWithBreak">EachWithBreak</span>
 
+<p>Iterates over elements of a set and invokes function for each element, when iteratee return false, will break the for each loop.</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) EachWithBreak(iteratee func(item T) bool)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet(1, 2, 3, 4, 5)
+
+    var sum int
+
+    s.EachWithBreak(func(n int) bool {
+        if n > 3 {
+            return false
+        }
+        sum += n
+        return true
+    })
+
+    fmt.Println(sum) //6
+}
+```
 
 ### <span id="IsEmpty">IsEmpty</span>
+
 <p>Check if the set is empty or not</p>
 
 <b>Signature:</b>
@@ -342,6 +476,7 @@ func main() {
 ```go
 func (s Set[T]) IsEmpty() bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -361,9 +496,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Union">Union</span>
+
 <p>Create a new set contain all element of set s and other</p>
 
 <b>Signature:</b>
@@ -371,6 +505,7 @@ func main() {
 ```go
 func (s Set[T]) Union(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -390,9 +525,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Intersection">Intersection</span>
+
 <p>Create a new set whose element both be contained in set s and other</p>
 
 <b>Signature:</b>
@@ -400,6 +534,7 @@ func main() {
 ```go
 func (s Set[T]) Intersection(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -419,11 +554,8 @@ func main() {
 }
 ```
 
-
-
-
-
 ### <span id="SymmetricDifference">SymmetricDifference</span>
+
 <p>Create a new set whose element is in set1 or set2, but not in both set1 and set2</p>
 
 <b>Signature:</b>
@@ -431,6 +563,7 @@ func main() {
 ```go
 func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -443,18 +576,15 @@ import (
 
 func main() {
     set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(2, 3, 4, 5)
-	set3 := set1.SymmetricDifference(set2)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set1.SymmetricDifference(set2)
 
     fmt.Println(set3.Values()) //1,4,5
 }
 ```
 
-
-
-
-
 ### <span id="Minus">Minus</span>
+
 <p>Create an set of whose element in origin set but not in compared set</p>
 
 <b>Signature:</b>
@@ -462,6 +592,7 @@ func main() {
 ```go
 func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -474,8 +605,8 @@ import (
 
 func main() {
     set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(2, 3, 4, 5)
-	set3 := set.NewSet(2, 3)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set.NewSet(2, 3)
 
     res1 := set1.Minus(set2)
     fmt.Println(res1.Values()) //1
@@ -485,5 +616,35 @@ func main() {
 }
 ```
 
+### <span id="Pop">Pop</span>
 
+<p>Delete the top element of set then return it, if set is empty, return nil-value of T and false.</p>
 
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Pop() (v T, ok bool)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet[int]()
+    s.Add(1)
+    s.Add(2)
+    s.Add(3)
+
+    val, ok = s.Pop()
+
+    fmt.Println(val) // 3
+    fmt.Println(ok) // true
+}
+```

docs/datastructure/set_zh-CN.md

@@ -1,16 +1,17 @@
 # Set
-Set集合数据结构，类似列表。Set中元素不重复。
+
+Set 集合数据结构，类似列表。Set 中元素不重复。
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码
 
-- [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)
-
+-   [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 用法
+
 ```go
 import (
     set "github.com/duke-git/lancet/v2/datastructure/set"
@@ -21,39 +22,41 @@ import (
 
 ## 目录
 
-- [NewSet](#NewSet)
-- [Values](#Values)
-- [Add](#Add)
-- [Delete](#Delete)
-- [Contain](#Contain)
-- [ContainAll](#ContainAll)
-- [Clone](#Clone)
-- [Size](#Size)
-- [Equal](#Equal)
-- [Iterate](#Iterate)
-- [IsEmpty](#IsEmpty)
-- [Union](#Union)
-- [Intersection](#Intersection)
-
-- [SymmetricDifference](#SymmetricDifference)
-- [Minus](#Minus)
-
-
+-   [NewSet](#NewSet)
+-   [NewSetFromSlice](#NewSetFromSlice)
+-   [Values](#Values)
+-   [Add](#Add)
+-   [AddIfNotExist](#AddIfNotExist)
+-   [AddIfNotExistBy](#AddIfNotExistBy)
+-   [Delete](#Delete)
+-   [Contain](#Contain)
+-   [ContainAll](#ContainAll)
+-   [Clone](#Clone)
+-   [Size](#Size)
+-   [Equal](#Equal)
+-   [Iterate](#Iterate)
+-   [IsEmpty](#IsEmpty)
+-   [Union](#Union)
+-   [Intersection](#Intersection)
+-   [SymmetricDifference](#SymmetricDifference)
+-   [Minus](#Minus)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
 ### <span id="NewSet">NewSet</span>
+
 <p>返回Set结构体对象</p>
 
 <b>函数签名:</b>
 
 ```go
 type Set[T comparable] map[T]bool
-func NewSet[T comparable](values ...T) Set[T]
+func NewSet[T comparable](items ...T) Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -69,10 +72,34 @@ func main() {
 }
 ```
 
+### <span id="NewSetFromSlice">NewSetFromSlice</span>
 
+<p>基于切片创建集合</p>
 
+<b>函数签名:</b>
+
+```go
+func NewSetFromSlice[T comparable](items []T) Set[T]
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSetFromSlice([]int{1, 2, 2, 3})
+    fmt.Println(st.Values()) //1,2,3
+}
+```
 
 ### <span id="Values">Values</span>
+
 <p>获取集合中所有元素的切片</p>
 
 <b>函数签名:</b>
@@ -80,7 +107,8 @@ func main() {
 ```go
 func (s Set[T]) Values() []T
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -96,18 +124,17 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Add">Add</span>
+
 <p>向集合中添加元素</p>
 
 <b>函数签名:</b>
 
 ```go
-func (s Set[T]) Add(values ...T)
+func (s Set[T]) Add(items ...T)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -125,17 +152,89 @@ func main() {
 }
 ```
 
+### <span id="AddIfNotExist">AddIfNotExist</span>
 
+<p>如果集合中不存在元素，则添加该元素返回true, 如果集合中存在元素, 不做任何操作，返回false</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) AddIfNotExist(item T) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int]()
+    st.Add(1, 2, 3)
+
+    r1 := st.AddIfNotExist(1)
+    r2 := st.AddIfNotExist(4)
+
+    fmt.Println(r1) // false
+    fmt.Println(r2) // true
+    fmt.Println(st.Values()) // 1,2,3,4
+}
+```
+
+### <span id="AddIfNotExistBy">AddIfNotExistBy</span>
+
+<p>根据checker函数判断元素是否在集合中，如果集合中不存在元素且checker返回true，则添加该元素返回true, 否则不做任何操作，返回false</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int]()
+    st.Add(1, 2)
+
+    ok := st.AddIfNotExistBy(3, func(val int) bool {
+        return val%2 != 0
+    })
+    fmt.Println(ok) // true
+
+
+    notOk := st.AddIfNotExistBy(4, func(val int) bool {
+        return val%2 != 0
+    })
+    fmt.Println(notOk) // false
+
+    fmt.Println(st.Values()) // 1, 2, 3
+}
+```
 
 ### <span id="Delete">Delete</span>
+
 <p>删除集合中元素</p>
 
 <b>函数签名:</b>
 
 ```go
-func (s Set[T]) Delete(values ...T)
+func (s Set[T]) Delete(items ...T)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -154,17 +253,17 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Contain">Contain</span>
+
 <p>判断集合是否包含某个值</p>
 
 <b>函数签名:</b>
 
 ```go
-func (s Set[T]) Contain(value T) bool
+func (s Set[T]) Contain(item T) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -183,10 +282,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="ContainAll">ContainAll</span>
+
 <p>判断集合是否包含另一个集合</p>
 
 <b>函数签名:</b>
@@ -194,7 +291,8 @@ func main() {
 ```go
 func (s Set[T]) ContainAll(other Set[T]) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -206,17 +304,16 @@ import (
 
 func main() {
     set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(1, 2)
-	set3 := set.NewSet(1, 2, 3, 4)
+    set2 := set.NewSet(1, 2)
+    set3 := set.NewSet(1, 2, 3, 4)
 
     fmt.Println(set1.ContainAll(set2)) //true
     fmt.Println(set1.ContainAll(set3)) //false
 }
 ```
 
-
-
 ### <span id="Size">Size</span>
+
 <p>获取集合中元素的个数</p>
 
 <b>函数签名:</b>
@@ -224,7 +321,8 @@ func main() {
 ```go
 func (s Set[T]) Size() int
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -241,9 +339,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Clone">Clone</span>
+
 <p>克隆一个集合</p>
 
 <b>函数签名:</b>
@@ -251,7 +348,8 @@ func main() {
 ```go
 func (s Set[T]) Clone() Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -270,10 +368,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Equal">Equal</span>
+
 <p>比较两个集合是否相等，包含相同元素为相等</p>
 
 <b>函数签名:</b>
@@ -281,7 +377,8 @@ func main() {
 ```go
 func (s Set[T]) Equal(other Set[T]) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -301,17 +398,17 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Iterate">Iterate</span>
+
 <p>迭代结合，在每个元素上调用函数</p>
 
 <b>函数签名:</b>
 
 ```go
-func (s Set[T]) Iterate(fn func(value T))
+func (s Set[T]) Iterate(fn func(item T))
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -324,17 +421,53 @@ import (
 func main() {
     set1 := set.NewSet(1, 2, 3)
     arr := []int{}
-    set.Iterate(func(value int) {
-        arr = append(arr, value)
+    set.Iterate(func(item int) {
+        arr = append(arr, item)
     })
 
     fmt.Println(arr) //1,2,3
 }
 ```
 
+### <span id="EachWithBreak">EachWithBreak</span>
 
+<p>遍历集合的元素并为每个元素调用iteratee函数，当iteratee函数返回false时，终止遍历。</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) EachWithBreak(iteratee func(item T) bool)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet(1, 2, 3, 4, 5)
+
+    var sum int
+
+    s.EachWithBreak(func(n int) bool {
+        if n > 3 {
+            return false
+        }
+        sum += n
+        return true
+    })
+
+    fmt.Println(sum) //6
+}
+```
 
 ### <span id="IsEmpty">IsEmpty</span>
+
 <p>判断集合是否为空</p>
 
 <b>函数签名:</b>
@@ -342,7 +475,8 @@ func main() {
 ```go
 func (s Set[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -361,9 +495,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Union">Union</span>
+
 <p>求两个集合的并集</p>
 
 <b>函数签名:</b>
@@ -371,7 +504,8 @@ func main() {
 ```go
 func (s Set[T]) Union(other Set[T]) Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -390,9 +524,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Intersection">Intersection</span>
+
 <p>求两个集合的交集</p>
 
 <b>函数签名:</b>
@@ -400,7 +533,8 @@ func main() {
 ```go
 func (s Set[T]) Intersection(other Set[T]) Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -419,11 +553,8 @@ func main() {
 }
 ```
 
-
-
-
-
 ### <span id="SymmetricDifference">SymmetricDifference</span>
+
 <p>返回一个集合，其中元素在第一个集合或第二个集合中，且不同时存在于两个集合中</p>
 
 <b>函数签名:</b>
@@ -431,7 +562,8 @@ func main() {
 ```go
 func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -443,18 +575,15 @@ import (
 
 func main() {
     set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(2, 3, 4, 5)
-	set3 := set1.SymmetricDifference(set2)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set1.SymmetricDifference(set2)
 
     fmt.Println(set3.Values()) //1,4,5
 }
 ```
 
-
-
-
-
 ### <span id="Minus">Minus</span>
+
 <p>创建一个集合，其元素在原始集中但不在比较集中</p>
 
 <b>函数签名:</b>
@@ -462,7 +591,8 @@ func main() {
 ```go
 func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -474,8 +604,8 @@ import (
 
 func main() {
     set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(2, 3, 4, 5)
-	set3 := set.NewSet(2, 3)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set.NewSet(2, 3)
 
     res1 := set1.Minus(set2)
     fmt.Println(res1.Values()) //1
@@ -485,5 +615,35 @@ func main() {
 }
 ```
 
+### <span id="Pop">Pop</span>
 
+<p>删除并返回集合中的顶部元素</p>
 
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Pop() (v T, ok bool)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet[int]()
+    s.Add(1)
+    s.Add(2)
+    s.Add(3)
+
+    val, ok = s.Pop()
+
+    fmt.Println(val) // 3
+    fmt.Println(ok) // true
+}
+```

docs/datastructure/stack_zh-CN.md

@@ -64,7 +64,7 @@ type ArrayStack[T any] struct {
 }
 func NewArrayStack[T any]() *ArrayStack[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -91,7 +91,7 @@ func main() {
 ```go
 func (s *ArrayStack[T]) Push(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -122,7 +122,7 @@ func main() {
 ```go
 func (s *ArrayStack[T]) Pop() (*T, error)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -157,7 +157,7 @@ func main() {
 ```go
 func (s *ArrayStack[T]) Peak() (*T, error)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -192,7 +192,7 @@ func main() {
 ```go
 func (s *ArrayStack[T]) Data() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -223,7 +223,7 @@ func main() {
 ```go
 func (s *ArrayStack[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -254,7 +254,7 @@ func main() {
 ```go
 func (s *ArrayStack[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -287,7 +287,7 @@ func main() {
 ```go
 func (s *ArrayStack[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -331,7 +331,7 @@ type LinkedStack[T any] struct {
 }
 func NewLinkedStack[T any]() *LinkedStack[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -358,7 +358,7 @@ func main() {
 ```go
 func (s *LinkedStack[T]) Push(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -389,7 +389,7 @@ func main() {
 ```go
 func (s *LinkedStack[T]) Pop() (*T, error)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -424,7 +424,7 @@ func main() {
 ```go
 func (s *LinkedStack[T]) Peak() (*T, error)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -459,7 +459,7 @@ func main() {
 ```go
 func (s *LinkedStack[T]) Data() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -490,7 +490,7 @@ func main() {
 ```go
 func (s *LinkedStack[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -521,7 +521,7 @@ func main() {
 ```go
 func (s *LinkedStack[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -554,7 +554,7 @@ func main() {
 ```go
 func (s *LinkedStack[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -588,7 +588,7 @@ func main() {
 ```go
 func (s *LinkedStack[T]) Print()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main

docs/datastructure/tree.md

@@ -29,7 +29,6 @@ import (
 - [PreOrderTraverse](#BSTree_PreOrderTraverse)
 - [InOrderTraverse](#BSTree_InOrderTraverse)
 - [PostOrderTraverse](#BSTree_PostOrderTraverse)
-  
 - [LevelOrderTraverse](#BSTree_LevelOrderTraverse)
 - [Depth](#BSTree_Depth)
 - [HasSubTree](#BSTree_HasSubTree)

docs/datastructure/tree_zh-CN.md

@@ -29,7 +29,6 @@ import (
 - [PreOrderTraverse](#BSTree_PreOrderTraverse)
 - [InOrderTraverse](#BSTree_InOrderTraverse)
 - [PostOrderTraverse](#BSTree_PostOrderTraverse)
-  
 - [LevelOrderTraverse](#BSTree_LevelOrderTraverse)
 - [Depth](#BSTree_Depth)
 - [HasSubTree](#BSTree_HasSubTree)
@@ -63,7 +62,7 @@ type TreeNode[T any] struct {
 	Right *TreeNode[T]
 }
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -104,7 +103,7 @@ func main() {
 ```go
 func (t *BSTree[T]) Insert(data T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -150,7 +149,7 @@ func main() {
 ```go
 func (t *BSTree[T]) Delete(data T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -198,7 +197,7 @@ func main() {
 ```go
 func (t *BSTree[T]) PreOrderTraverse() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -244,7 +243,7 @@ func main() {
 ```go
 func (t *BSTree[T]) InOrderTraverse() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -290,7 +289,7 @@ func main() {
 ```go
 func (t *BSTree[T]) PostOrderTraverse() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -336,7 +335,7 @@ func main() {
 ```go
 func (t *BSTree[T]) LevelOrderTraverse() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -382,7 +381,7 @@ func main() {
 ```go
 func (t *BSTree[T]) Depth() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -428,7 +427,7 @@ func main() {
 ```go
 func (t *BSTree[T]) HasSubTree(subTree *BSTree[T]) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -480,7 +479,7 @@ func main() {
 ```go
 func (t *BSTree[T]) Print()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main