release v2.2.4

* expand BeginOfWeek、EndOfWeek

* IsWeekend func Deprecated

.gitignore

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

algorithm/lrucache_test.go

@@ -7,6 +7,7 @@ import (
 )
 
 func TestLRUCache(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestLRUCache")
 
 	cache := NewLRUCache[int, int](3)

algorithm/search.go

@@ -10,7 +10,7 @@ import "github.com/duke-git/lancet/v2/lancetconstraints"
 
 // LinearSearch return the index of target in slice base on equal function.
 // If not found return -1
-// Play: Todo
+// 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 equal(v, target) {

algorithm/search_test.go

@@ -7,6 +7,7 @@ import (
 )
 
 func TestLinearSearch(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestLinearSearch")
 
 	numbers := []int{3, 4, 5, 3, 2, 1}
@@ -19,6 +20,7 @@ func TestLinearSearch(t *testing.T) {
 }
 
 func TestBinarySearch(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestBinarySearch")
 
 	sortedNumbers := []int{1, 2, 3, 4, 5, 6, 7, 8}

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,6 +66,7 @@ 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}
@@ -75,6 +77,7 @@ func TestBubbleSortForIntSlice(t *testing.T) {
 }
 
 func TestInsertionSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestInsertionSort")
 
 	peoples := []people{
@@ -94,6 +97,7 @@ func TestInsertionSort(t *testing.T) {
 }
 
 func TestSelectionSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestSelectionSort")
 
 	peoples := []people{
@@ -113,6 +117,7 @@ func TestSelectionSort(t *testing.T) {
 }
 
 func TestShellSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestShellSort")
 
 	peoples := []people{
@@ -132,6 +137,7 @@ func TestShellSort(t *testing.T) {
 }
 
 func TestQuickSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestQuickSort")
 
 	peoples := []people{
@@ -151,6 +157,7 @@ func TestQuickSort(t *testing.T) {
 }
 
 func TestHeapSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestHeapSort")
 
 	peoples := []people{
@@ -170,6 +177,7 @@ func TestHeapSort(t *testing.T) {
 }
 
 func TestMergeSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestMergeSort")
 
 	peoples := []people{
@@ -189,6 +197,7 @@ func TestMergeSort(t *testing.T) {
 }
 
 func TestCountSort(t *testing.T) {
+	t.Parallel()
 	asssert := internal.NewAssert(t, "TestCountSort")
 
 	peoples := []people{
@@ -200,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,64 @@
+// 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"
+)
+
+// 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)
+}

compare/compare_example_test.go

@@ -0,0 +1,170 @@
+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
+}

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,140 @@
+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"))
+}

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 (
@@ -20,7 +20,7 @@ func NewChannel[T any]() *Channel[T] {
 }
 
 // Generate creates channel, then put values into the channel.
-// Play: Todo
+// Play: https://go.dev/play/p/7aB4KyMMp9A
 func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T {
 	dataStream := make(chan T)
 
@@ -40,7 +40,7 @@ func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T {
 }
 
 // Repeat create channel, put values into the channel repeatly until cancel the context.
-// Play: Todo
+// Play: https://go.dev/play/p/k5N_ALVmYjE
 func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T {
 	dataStream := make(chan T)
 
@@ -61,7 +61,7 @@ func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T {
 
 // RepeatFn create a channel, excutes fn repeatly, and put the result into the channel
 // until close context.
-// Play: Todo
+// Play: https://go.dev/play/p/4J1zAWttP85
 func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T {
 	dataStream := make(chan T)
 
@@ -79,7 +79,7 @@ func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T {
 }
 
 // Take create a channel whose values are taken from another channel with limit number.
-// Play: Todo
+// 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)
 
@@ -99,7 +99,7 @@ func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int)
 }
 
 // FanIn merge multiple channels into one channel.
-// Play: Todo
+// Play: https://go.dev/play/p/2VYFMexEvTm
 func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T {
 	out := make(chan T)
 
@@ -127,7 +127,7 @@ func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T {
 }
 
 // Tee split one chanel into two channels, until cancel the context.
-// Play: Todo
+// 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)
@@ -154,7 +154,7 @@ func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)
 }
 
 // Bridge link multiply channels into one channel.
-// Play: Todo
+// 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)
 
@@ -186,7 +186,7 @@ func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-c
 }
 
 // Or read one or more channels into one channel, will close when any readin channel is closed.
-// Play: Todo
+// Play: https://go.dev/play/p/Wqz9rwioPww
 func (c *Channel[T]) Or(channels ...<-chan T) <-chan T {
 	switch len(channels) {
 	case 0:
@@ -220,7 +220,7 @@ func (c *Channel[T]) Or(channels ...<-chan T) <-chan T {
 }
 
 // OrDone read a channel into another channel, will close until cancel context.
-// Play: Todo
+// 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)
 

concurrency/channel_test.go

@@ -9,6 +9,7 @@ import (
 )
 
 func TestGenerate(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestGenerate")
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -23,6 +24,7 @@ func TestGenerate(t *testing.T) {
 }
 
 func TestRepeat(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestRepeat")
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -39,6 +41,7 @@ func TestRepeat(t *testing.T) {
 }
 
 func TestRepeatFn(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestRepeatFn")
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -57,6 +60,7 @@ func TestRepeatFn(t *testing.T) {
 }
 
 func TestTake(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestTake")
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -79,6 +83,7 @@ func TestTake(t *testing.T) {
 }
 
 func TestFanIn(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestFanIn")
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -101,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 {
@@ -127,6 +133,7 @@ func TestOr(t *testing.T) {
 }
 
 func TestOrDone(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestOrDone")
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -141,6 +148,7 @@ func TestOrDone(t *testing.T) {
 }
 
 func TestTee(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestTee")
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -159,6 +167,7 @@ func TestTee(t *testing.T) {
 }
 
 func TestBridge(t *testing.T) {
+	t.Parallel()
 	assert := internal.NewAssert(t, "TestBridge")
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -181,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_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,12 +9,17 @@ 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 boolean.
@@ -234,31 +239,7 @@ func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K
 // 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 map to slice based on iteratee function.
@@ -324,3 +305,92 @@ func DecodeByte(data []byte, target any) error {
 	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

@@ -2,7 +2,11 @@ package convertor
 
 import (
 	"fmt"
+	"reflect"
 	"strconv"
+	"unicode/utf8"
+
+	"github.com/duke-git/lancet/v2/validator"
 )
 
 func ExampleToBool() {
@@ -252,3 +256,138 @@ func ExampleDecodeByte() {
 	// 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,6 +29,8 @@ func TestToChar(t *testing.T) {
 }
 
 func TestToChannel(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToChannel")
 
 	ch := ToChannel([]int{1, 2, 3})
@@ -36,6 +43,8 @@ func TestToChannel(t *testing.T) {
 }
 
 func TestToBool(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToBool")
 
 	cases := []string{"1", "true", "True", "false", "False", "0", "123", "0.0", "abc"}
@@ -48,6 +57,8 @@ func TestToBool(t *testing.T) {
 }
 
 func TestToBytes(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToBytes")
 
 	cases := []any{
@@ -74,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,
@@ -90,6 +103,8 @@ func TestToInt(t *testing.T) {
 }
 
 func TestToFloat(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToFloat")
 
 	cases := []any{
@@ -108,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)
@@ -143,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}
@@ -158,6 +177,8 @@ func TestToJson(t *testing.T) {
 }
 
 func TestToMap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToMap")
 
 	type Message struct {
@@ -177,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}
@@ -208,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)
@@ -218,6 +263,8 @@ func TestColorHexToRGB(t *testing.T) {
 }
 
 func TestColorRGBToHex(t *testing.T) {
+	t.Parallel()
+
 	r := 0
 	g := 51
 	b := 102
@@ -229,6 +276,8 @@ func TestColorRGBToHex(t *testing.T) {
 }
 
 func TestToPointer(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToPointer")
 	result := ToPointer(123)
 
@@ -236,6 +285,8 @@ func TestToPointer(t *testing.T) {
 }
 
 func TestEncodeByte(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEncodeByte")
 
 	byteData, _ := EncodeByte("abc")
@@ -245,6 +296,8 @@ func TestEncodeByte(t *testing.T) {
 }
 
 func TestDecodeByte(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDecodeByte")
 
 	var obj string
@@ -253,3 +306,157 @@ func TestDecodeByte(t *testing.T) {
 	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/basic.go

@@ -40,6 +40,30 @@ func Md5String(s string) string {
 	return hex.EncodeToString(h.Sum(nil))
 }
 
+// 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/CkN9hYKGeAy
+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 {
@@ -74,56 +98,112 @@ func Md5File(filename string) (string, error) {
 
 // HmacMd5 return the hmac hash of string use md5.
 // Play: https://go.dev/play/p/uef0q1fz53I
-func HmacMd5(data, key string) string {
+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.
 // Play: https://go.dev/play/p/1UI4oQ4WXKM
-func HmacSha1(data, key string) string {
+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("")))
 }
 
+// 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(data, key string) string {
+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("")))
 }
 
+// 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(data, key string) string {
+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("")))
 }
 
+// HmacSha512WithBase64 return the hmac hash of string use sha512 with base64.
+// Play: https://go.dev/play/p/61wBBOKO-GH
+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(data string) string {
+func Sha1(str string) string {
 	sha1 := sha1.New()
-	sha1.Write([]byte(data))
+	sha1.Write([]byte(str))
 	return hex.EncodeToString(sha1.Sum([]byte("")))
 }
 
+// Sha1WithBase64 return the sha1 value (SHA-1 hash algorithm) of base64 string.
+// Play: todo
+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(data string) string {
+func Sha256(str string) string {
 	sha256 := sha256.New()
-	sha256.Write([]byte(data))
+	sha256.Write([]byte(str))
 	return hex.EncodeToString(sha256.Sum([]byte("")))
 }
 
+// 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(data string) string {
+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

@@ -23,6 +23,11 @@ import (
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/jT5irszHx-j
 func AesEcbEncrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 16 && size != 24 && size != 32 {
+		panic("key length shoud be 16 or 24 or 32")
+	}
+
 	length := (len(data) + aes.BlockSize) / aes.BlockSize
 	plain := make([]byte, length*aes.BlockSize)
 
@@ -34,7 +39,7 @@ func AesEcbEncrypt(data, key []byte) []byte {
 	}
 
 	encrypted := make([]byte, len(plain))
-	cipher, _ := aes.NewCipher(generateAesKey(key))
+	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])
@@ -47,7 +52,11 @@ func AesEcbEncrypt(data, key []byte) []byte {
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/jT5irszHx-j
 func AesEcbDecrypt(encrypted, key []byte) []byte {
-	cipher, _ := aes.NewCipher(generateAesKey(key))
+	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() {

cryptor/crypto_example_test.go

@@ -322,89 +322,165 @@ func ExampleHmacMd5() {
 	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 ExampleMd5String() {
+func ExampleHmacSha512WithBase64() {
 	str := "hello"
+	key := "12345"
 
-	md5Str := Md5String(str)
+	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() {
-	str := "hello"
-
-	result := Sha1(str)
-
+	result := Sha1("hello")
 	fmt.Println(result)
 
 	// Output:
 	// aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
 }
 
+func ExampleSha1WithBase64() {
+	result := Sha1WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
+}
+
 func ExampleSha256() {
-	str := "hello"
-
-	result := Sha256(str)
-
+	result := Sha256("hello")
 	fmt.Println(result)
 
 	// Output:
 	// 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
 }
 
+func ExampleSha256WithBase64() {
+	result := Sha256WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
+}
+
 func ExampleSha512() {
-	str := "hello"
-
-	result := Sha512(str)
-
+	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

@@ -7,6 +7,8 @@ import (
 )
 
 func TestAesEcbEncrypt(t *testing.T) {
+	t.Parallel()
+
 	data := "hello world"
 	key := "abcdefghijklmnop"
 
@@ -18,6 +20,8 @@ func TestAesEcbEncrypt(t *testing.T) {
 }
 
 func TestAesCbcEncrypt(t *testing.T) {
+	t.Parallel()
+
 	data := "hello world"
 	key := "abcdefghijklmnop"
 
@@ -29,6 +33,8 @@ func TestAesCbcEncrypt(t *testing.T) {
 }
 
 func TestAesCtrCrypt(t *testing.T) {
+	t.Parallel()
+
 	data := "hello world"
 	key := "abcdefghijklmnop"
 
@@ -40,6 +46,8 @@ func TestAesCtrCrypt(t *testing.T) {
 }
 
 func TestAesCfbEncrypt(t *testing.T) {
+	t.Parallel()
+
 	data := "hello world"
 	key := "abcdefghijklmnop"
 
@@ -51,6 +59,8 @@ func TestAesCfbEncrypt(t *testing.T) {
 }
 
 func TestAesOfbEncrypt(t *testing.T) {
+	t.Parallel()
+
 	data := "hello world"
 	key := "abcdefghijklmnop"
 
@@ -62,6 +72,8 @@ func TestAesOfbEncrypt(t *testing.T) {
 }
 
 func TestDesEcbEncrypt(t *testing.T) {
+	t.Parallel()
+
 	data := "hello world"
 	key := "abcdefgh"
 
@@ -73,6 +85,8 @@ func TestDesEcbEncrypt(t *testing.T) {
 }
 
 func TestDesCbcEncrypt(t *testing.T) {
+	t.Parallel()
+
 	data := "hello world"
 	key := "abcdefgh"
 
@@ -84,6 +98,8 @@ func TestDesCbcEncrypt(t *testing.T) {
 }
 
 func TestDesCtrCrypt(t *testing.T) {
+	t.Parallel()
+
 	data := "hello world"
 	key := "abcdefgh"
 
@@ -95,6 +111,8 @@ func TestDesCtrCrypt(t *testing.T) {
 }
 
 func TestDesCfbEncrypt(t *testing.T) {
+	t.Parallel()
+
 	data := "hello world"
 	key := "abcdefgh"
 
@@ -106,6 +124,8 @@ func TestDesCfbEncrypt(t *testing.T) {
 }
 
 func TestDesOfbEncrypt(t *testing.T) {
+	t.Parallel()
+
 	data := "hello world"
 	key := "abcdefgh"
 
@@ -117,6 +137,8 @@ func TestDesOfbEncrypt(t *testing.T) {
 }
 
 func TestRsaEncrypt(t *testing.T) {
+	t.Parallel()
+
 	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
 	if err != nil {
 		t.FailNow()

datastructure/hashmap/hashmap.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. hashmap structure.
 package datastructure
 
 import (
@@ -17,7 +17,7 @@ type mapNode struct {
 	next  *mapNode
 }
 
-//HashMap implements a hash map
+// HashMap implements a hash map
 type HashMap struct {
 	capacity uint64
 	size     uint64

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,7 +70,6 @@ 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))

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 (

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}
@@ -33,6 +35,8 @@ func TestMaxHeap_BuildMaxHeap(t *testing.T) {
 }
 
 func TestMaxHeap_Push(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMaxHeap_Push")
 
 	heap := NewMaxHeap[int](&intComparator{})
@@ -51,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{})
@@ -70,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,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. Link structure contains SinglyLink and DoublyLink.
 package datastructure
 
 import (

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,12 +41,12 @@ func TestDoublyLink_InsertAtTail(t *testing.T) {
 }
 
 func TestDoublyLink_InsertAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_InsertAt")
 
 	link := NewDoublyLink[int]()
-
 	link.InsertAt(1, 1) //do nothing
-
 	link.InsertAt(0, 1)
 	link.InsertAt(1, 2)
 	link.InsertAt(2, 4)
@@ -55,6 +59,8 @@ func TestDoublyLink_InsertAt(t *testing.T) {
 }
 
 func TestDoublyLink_DeleteAtHead(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAtHead")
 
 	link := NewDoublyLink[int]()
@@ -74,6 +80,8 @@ func TestDoublyLink_DeleteAtHead(t *testing.T) {
 }
 
 func TestDoublyLink_DeleteAtTail(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAtTail")
 
 	link := NewDoublyLink[int]()
@@ -93,6 +101,8 @@ func TestDoublyLink_DeleteAtTail(t *testing.T) {
 }
 
 func TestDoublyLink_DeleteAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAt")
 
 	link := NewDoublyLink[int]()
@@ -116,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]()
@@ -130,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]()
@@ -149,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,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. Link structure contains SinglyLink and DoublyLink.
 package datastructure
 
 import (

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,6 +41,8 @@ func TestSinglyLink_InsertAtTail(t *testing.T) {
 }
 
 func TestSinglyLink_InsertAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_InsertAt")
 
 	link := NewSinglyLink[int]()
@@ -57,6 +63,8 @@ func TestSinglyLink_InsertAt(t *testing.T) {
 }
 
 func TestSinglyLink_DeleteAtHead(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAtHead")
 
 	link := NewSinglyLink[int]()
@@ -78,10 +86,11 @@ func TestSinglyLink_DeleteAtHead(t *testing.T) {
 }
 
 func TestSinglyLink_DeleteAtTail(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAtTail")
 
 	link := NewSinglyLink[int]()
-
 	link.InsertAtTail(1)
 	link.InsertAtTail(2)
 	link.InsertAtTail(3)
@@ -96,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)
@@ -114,10 +124,11 @@ func TestSinglyLink_DeleteValue(t *testing.T) {
 }
 
 func TestSinglyLink_DeleteAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAt")
 
 	link := NewSinglyLink[int]()
-
 	link.InsertAtTail(1)
 	link.InsertAtTail(2)
 	link.InsertAtTail(3)
@@ -136,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]()
@@ -149,6 +162,8 @@ func TestSinglyLink_Reverse(t *testing.T) {
 }
 
 func TestSinglyLink_GetMiddleNode(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSinglyLink_GetMiddleNode")
 
 	link := NewSinglyLink[int]()
@@ -163,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/list.go

@@ -1,11 +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 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.
@@ -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,15 +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()
 
-	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)
@@ -38,6 +41,8 @@ func TestArrayQueue_Dequeue(t *testing.T) {
 }
 
 func TestArrayQueue_Front(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayQueue_Front")
 
 	queue := NewArrayQueue[int](4)
@@ -52,6 +57,8 @@ func TestArrayQueue_Front(t *testing.T) {
 }
 
 func TestArrayQueue_Back(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayQueue_Back")
 
 	queue := NewArrayQueue[int](4)
@@ -66,6 +73,8 @@ func TestArrayQueue_Back(t *testing.T) {
 }
 
 func TestArrayQueue_Contain(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestArrayQueue_Contain")
 
 	queue := NewArrayQueue[int](4)
@@ -78,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)
@@ -95,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,6 +7,8 @@ import (
 )
 
 func TestCircularQueue_Enqueue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Enqueue")
 
 	queue := NewCircularQueue[int](6)
@@ -34,6 +36,8 @@ func TestCircularQueue_Enqueue(t *testing.T) {
 }
 
 func TestCircularQueue_Dequeue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_DeQueue")
 
 	queue := NewCircularQueue[int](4)
@@ -60,6 +64,8 @@ func TestCircularQueue_Dequeue(t *testing.T) {
 }
 
 func TestCircularQueue_Front(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Front")
 
 	queue := NewCircularQueue[int](6)
@@ -80,6 +86,8 @@ func TestCircularQueue_Front(t *testing.T) {
 }
 
 func TestCircularQueue_Back(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Back")
 
 	queue := NewCircularQueue[int](3)
@@ -103,6 +111,8 @@ func TestCircularQueue_Back(t *testing.T) {
 }
 
 func TestCircularQueue_Contain(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Contain")
 
 	queue := NewCircularQueue[int](2)
@@ -114,6 +124,8 @@ func TestCircularQueue_Contain(t *testing.T) {
 }
 
 func TestCircularQueue_Clear(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Clear")
 
 	queue := NewCircularQueue[int](3)
@@ -132,6 +144,8 @@ func TestCircularQueue_Clear(t *testing.T) {
 }
 
 func TestCircularQueue_Data(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCircularQueue_Data")
 
 	queue := NewCircularQueue[int](3)

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]()
@@ -19,6 +21,8 @@ func TestLinkedQueue_Enqueue(t *testing.T) {
 }
 
 func TestLinkedQueue_Dequeue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLinkedQueue_DeQueue")
 
 	queue := NewLinkedQueue[int]()
@@ -35,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]()
@@ -51,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]()
@@ -67,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]()
@@ -82,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,6 +20,8 @@ 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{}
@@ -45,6 +47,8 @@ func TestPriorityQueue_Enqueue(t *testing.T) {
 }
 
 func TestPriorityQueue_Dequeue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPriorityQueue_Dequeue")
 
 	comparator := &intComparator{}

datastructure/set/set.go

@@ -1,6 +1,10 @@
+// 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
@@ -171,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

@@ -7,6 +7,8 @@ import (
 )
 
 func TestSet_NewSetFromSlice(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_NewSetFromSlice")
 
 	s1 := NewSetFromSlice([]int{1, 2, 2, 3})
@@ -20,17 +22,21 @@ func TestSet_NewSetFromSlice(t *testing.T) {
 }
 
 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]()
@@ -42,6 +48,8 @@ func TestSet_AddIfNotExist(t *testing.T) {
 }
 
 func TestSet_AddIfNotExistBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_AddIfNotExistBy")
 
 	set := NewSet[int]()
@@ -63,6 +71,8 @@ func TestSet_AddIfNotExistBy(t *testing.T) {
 }
 
 func TestSet_Contain(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSet_Contain")
 
 	set := NewSet[int]()
@@ -73,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)
@@ -84,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)
@@ -94,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)
@@ -117,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)
@@ -129,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]()
@@ -136,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)
@@ -143,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)
@@ -152,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)
@@ -183,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)
@@ -192,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,15 +16,16 @@ func TestLinkedStack_Push(t *testing.T) {
 	stack.Push(2)
 	stack.Push(3)
 
-	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]()
@@ -37,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]()
@@ -57,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,16 +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)
-}
-
 func TestBSTree_PreOrderTraverse(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBSTree_PreOrderTraverse")
 
 	bstree := NewBSTree(6, &intComparator{})
@@ -40,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{})
@@ -55,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{})
@@ -70,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{})
@@ -85,11 +81,12 @@ func TestBSTree_LevelOrderTraverse(t *testing.T) {
 	bstree.Insert(4)
 
 	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{})
@@ -102,18 +99,18 @@ func TestBSTree_Delete(t *testing.T) {
 	bstree.Delete(4)
 
 	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{})
@@ -127,6 +124,8 @@ func TestBSTree_Depth(t *testing.T) {
 }
 
 func TestBSTree_IsSubTree(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBSTree_IsSubTree")
 
 	superTree := NewBSTree(8, &intComparator{})

datetime/conversion_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestToUnix(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToUnix")
 
 	tm1 := NewUnixNow()
@@ -17,34 +19,37 @@ func TestToUnix(t *testing.T) {
 }
 
 func TestToFormat(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToFormat")
 
 	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,9 +52,13 @@ 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",
 	}
 }
@@ -72,6 +81,12 @@ func AddDay(t time.Time, day int64) time.Time {
 	return t.Add(24 * time.Hour * time.Duration(day))
 }
 
+// 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 {
@@ -90,6 +105,18 @@ func GetNowDateTime() string {
 	return time.Now().Format("2006-01-02 15:04:05")
 }
 
+// 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 {
@@ -106,19 +133,40 @@ func GetNightTimestamp() int64 {
 
 // FormatTimeToStr convert time to string.
 // Play: https://go.dev/play/p/_Ia7M8H_OvE
-func FormatTimeToStr(t time.Time, format string) string {
-	return t.Format(timeFormat[format])
+func FormatTimeToStr(t time.Time, 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 t.In(loc).Format(tf)
+	}
+	return t.Format(tf)
 }
 
 // FormatStrToTime convert string to time.
 // Play: https://go.dev/play/p/1h9FwdU8ql4
-func FormatStrToTime(str, format string) (time.Time, error) {
-	v, ok := timeFormat[format]
+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 found", format)
+		return time.Time{}, fmt.Errorf("format %s not support", format)
 	}
 
-	return time.Parse(v, str)
+	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.
@@ -218,3 +266,118 @@ func BeginOfYear(t time.Time) time.Time {
 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: todo
+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: todo
+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: todo
+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: todo
+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: todo
+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

@@ -57,6 +57,23 @@ func ExampleAddMinute() {
 	// -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()
 
@@ -114,15 +131,18 @@ func ExampleFormatTimeToStr() {
 	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() {
@@ -321,3 +341,70 @@ func ExampleNewUnixNow() {
 // 	// 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,44 +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 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{
@@ -96,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)
@@ -122,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)
@@ -132,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)
@@ -142,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)
@@ -152,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)
@@ -162,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)
@@ -172,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)
@@ -182,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)
@@ -192,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)
@@ -202,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)
@@ -212,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)
@@ -222,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)
@@ -230,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"
@@ -22,27 +24,25 @@ import (
 
 ## 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>
@@ -573,6 +595,7 @@ 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
@@ -588,14 +611,26 @@ func main() {
 
     cache.Put(1, 1)
     cache.Put(2, 2)
-    cache.Put(3, 3)
 
-    fmt.Println(cache.Len()) // 3
+    result1, ok1 := cache.Get(1)
+    result2, ok2 := cache.Get(2)
+    result3, ok3 := cache.Get(3)
 
-    v, ok := cache.Get(1)
-    fmt.Println(v, ok) // 1 true
+    fmt.Println(result1, ok1)
+    fmt.Println(result2, ok2)
+    fmt.Println(result3, ok3)
 
-    ok = cache.Delete(1)
-    fmt.Println(ok) // true
+    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,35 +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
@@ -60,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
@@ -105,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
@@ -170,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
@@ -215,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
@@ -260,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
@@ -305,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
@@ -350,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
@@ -394,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
@@ -439,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
@@ -485,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
@@ -533,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>
 
@@ -573,7 +595,8 @@ 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,14 +611,26 @@ func main() {
 
     cache.Put(1, 1)
     cache.Put(2, 2)
-    cache.Put(3, 3)
 
-    fmt.Println(cache.Len()) // 3
+    result1, ok1 := cache.Get(1)
+    result2, ok2 := cache.Get(2)
+    result3, ok3 := cache.Get(3)
 
-    v, ok := cache.Get(1)
-    fmt.Println(v, ok) // 1 true
+    fmt.Println(result1, ok1)
+    fmt.Println(result2, ok2)
+    fmt.Println(result3, ok3)
 
-    ok = cache.Delete(1)
-    fmt.Println(ok) // true
+    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,326 @@
+# 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)
+
+<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
+}
+```

docs/compare_zh-CN.md

@@ -0,0 +1,326 @@
+# 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)
+
+<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
+}
+```

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>
 
@@ -61,8 +61,6 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Bridge">Bridge</span>
 
 <p>Link multiple channels into one channel until cancel the context.</p>
@@ -84,39 +82,37 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	genVals := func() <-chan <-chan int {
-		out := make(chan (<-chan int))
-		go func() {
-			defer close(out)
-			for i := 1; i <= 5; i++ {
-				stream := make(chan int, 1)
-				stream <- i
-				close(stream)
-				out <- stream
-			}
-		}()
-		return out
-	}
+    c := concurrency.NewChannel[int]()
+    genVals := func() <-chan <-chan int {
+        out := make(chan (<-chan int))
+        go func() {
+            defer close(out)
+            for i := 1; i <= 5; i++ {
+                stream := make(chan int, 1)
+                stream <- i
+                close(stream)
+                out <- stream
+            }
+        }()
+        return out
+    }
 
-	for v := range c.Bridge(ctx, genVals()) {
-		fmt.Println(v)
-	}
-	// Output:
-	// 1
-	// 2
-	// 3
-	// 4
-	// 5
+    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>
@@ -138,25 +134,24 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	channels := make([]<-chan int, 2)
+    c := concurrency.NewChannel[int]()
+    channels := make([]<-chan int, 2)
 
-	for i := 0; i < 2; i++ {
-		channels[i] = c.Take(ctx, c.Repeat(ctx, i), 2)
-	}
+    for i := 0; i < 2; i++ {
+        channels[i] = c.Take(ctx, c.Repeat(ctx, i), 2)
+    }
 
-	chs := c.FanIn(ctx, channels...)
+    chs := c.FanIn(ctx, channels...)
 
-	for v := range chs {
-		fmt.Println(v) //1 1 0 0 or 0 0 1 1
-	}
+    for v := range chs {
+        fmt.Println(v) //1 1 0 0 or 0 0 1 1
+    }
 }
 ```
 
-
 ### <span id="Repeat">Repeat</span>
 
 <p>Create channel, put values into the channel repeatly until cancel the context.</p>
@@ -178,25 +173,24 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
 
-	for v := range intStream {
-		fmt.Println(v)
-	}
-	// Output:
-	// 1
-	// 2
-	// 1
-	// 2
+    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>
@@ -218,20 +212,20 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	intStream := c.Generate(ctx, 1, 2, 3)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Generate(ctx, 1, 2, 3)
 
-	fmt.Println(<-intStream)
-	fmt.Println(<-intStream)
-	fmt.Println(<-intStream)
+    fmt.Println(<-intStream)
+    fmt.Println(<-intStream)
+    fmt.Println(<-intStream)
 
-	// Output:
-	// 1
-	// 2
-	// 3
+    // Output:
+    // 1
+    // 2
+    // 3
 }
 ```
 
@@ -256,28 +250,27 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	fn := func() string {
-		return "hello"
-	}
+    fn := func() string {
+        return "hello"
+    }
 
-	c := concurrency.NewChannel[string]()
-	intStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
+    c := concurrency.NewChannel[string]()
+    intStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
 
-	for v := range intStream {
-		fmt.Println(v)
-	}
-	// Output:
-	// hello
-	// hello
-	// hello
+    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>
@@ -299,31 +292,28 @@ import (
 )
 
 func main() {
-	sig := func(after time.Duration) <-chan any {
-		c := make(chan any)
-		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[any]()
-	<-c.Or(
-		sig(1*time.Second),
-		sig(2*time.Second),
-		sig(3*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>
@@ -345,25 +335,23 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
 
-	for v := range c.OrDone(ctx, intStream) {
-		fmt.Println(v)
-	}
-	// Output:
-	// 1
-	// 1
-	// 1
+    for v := range c.OrDone(ctx, intStream) {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 1
+    // 1
 }
 ```
 
-
-
-
 ### <span id="Take">Take</span>
 
 <p>Create a channel whose values are taken from another channel with limit number.</p>
@@ -385,32 +373,31 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    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)
+    numbers := make(chan int, 5)
+    numbers <- 1
+    numbers <- 2
+    numbers <- 3
+    numbers <- 4
+    numbers <- 5
+    defer close(numbers)
 
-	c := concurrency.NewChannel[int]()
-	intStream := c.Take(ctx, numbers, 3)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, numbers, 3)
 
-	for v := range intStream {
-		fmt.Println(v)
-	}
-	// Output:
-	// 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 the context.</p>
@@ -432,22 +419,23 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1), 2)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1), 2)
 
-	ch1, ch2 := c.Tee(ctx, intStream)
+    ch1, ch2 := c.Tee(ctx, intStream)
 
-	for v := range ch1 {
-		fmt.Println(v)
-		fmt.Println(<-ch2)
-	}
-	// Output:
-	// 1
-	// 1
-	// 1
-	// 1
+    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>
 
@@ -46,7 +46,7 @@ import (
 type Channel[T any] struct
 func NewChannel[T any]() *Channel[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -61,8 +61,6 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Bridge">Bridge</span>
 
 <p>将多个channel链接到一个channel，直到取消上下文。</p>
@@ -72,7 +70,7 @@ func main() {
 ```go
 func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -84,39 +82,37 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	genVals := func() <-chan <-chan int {
-		out := make(chan (<-chan int))
-		go func() {
-			defer close(out)
-			for i := 1; i <= 5; i++ {
-				stream := make(chan int, 1)
-				stream <- i
-				close(stream)
-				out <- stream
-			}
-		}()
-		return out
-	}
+    c := concurrency.NewChannel[int]()
+    genVals := func() <-chan <-chan int {
+        out := make(chan (<-chan int))
+        go func() {
+            defer close(out)
+            for i := 1; i <= 5; i++ {
+                stream := make(chan int, 1)
+                stream <- i
+                close(stream)
+                out <- stream
+            }
+        }()
+        return out
+    }
 
-	for v := range c.Bridge(ctx, genVals()) {
-		fmt.Println(v)
-	}
-	// Output:
-	// 1
-	// 2
-	// 3
-	// 4
-	// 5
+    for v := range c.Bridge(ctx, genVals()) {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 3
+    // 4
+    // 5
 }
 ```
 
-
-
-
 ### <span id="FanIn">FanIn</span>
 
 <p>将多个channel合并为一个channel，直到取消上下文。</p>
@@ -126,7 +122,7 @@ func main() {
 ```go
 func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -138,25 +134,24 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	channels := make([]<-chan int, 2)
+    c := concurrency.NewChannel[int]()
+    channels := make([]<-chan int, 2)
 
-	for i := 0; i < 2; i++ {
-		channels[i] = c.Take(ctx, c.Repeat(ctx, i), 2)
-	}
+    for i := 0; i < 2; i++ {
+        channels[i] = c.Take(ctx, c.Repeat(ctx, i), 2)
+    }
 
-	chs := c.FanIn(ctx, channels...)
+    chs := c.FanIn(ctx, channels...)
 
-	for v := range chs {
-		fmt.Println(v) //1 1 0 0 or 0 0 1 1
-	}
+    for v := range chs {
+        fmt.Println(v) //1 1 0 0 or 0 0 1 1
+    }
 }
 ```
 
-
 ### <span id="Generate">Generate</span>
 
 <p>根据传入的值，生成channel.</p>
@@ -166,7 +161,7 @@ func main() {
 ```go
 func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -178,20 +173,20 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	intStream := c.Generate(ctx, 1, 2, 3)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Generate(ctx, 1, 2, 3)
 
-	fmt.Println(<-intStream)
-	fmt.Println(<-intStream)
-	fmt.Println(<-intStream)
+    fmt.Println(<-intStream)
+    fmt.Println(<-intStream)
+    fmt.Println(<-intStream)
 
-	// Output:
-	// 1
-	// 2
-	// 3
+    // Output:
+    // 1
+    // 2
+    // 3
 }
 ```
 
@@ -204,7 +199,7 @@ func main() {
 ```go
 func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -216,26 +211,24 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
 
-	for v := range intStream {
-		fmt.Println(v)
-	}
-	// Output:
-	// 1
-	// 2
-	// 1
-	// 2
+    for v := range intStream {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 1
+    // 2
 }
 ```
 
-
-
-
 ### <span id="RepeatFn">RepeatFn</span>
 
 <p>返回一个channel，重复执行函数fn，并将结果放入返回的channel，直到取消上下文。</p>
@@ -245,7 +238,7 @@ func main() {
 ```go
 func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -257,28 +250,26 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	fn := func() string {
-		return "hello"
-	}
+    fn := func() string {
+        return "hello"
+    }
 
-	c := concurrency.NewChannel[string]()
-	intStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
+    c := concurrency.NewChannel[string]()
+    intStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
 
-	for v := range intStream {
-		fmt.Println(v)
-	}
-	// Output:
-	// hello
-	// hello
-	// hello
+    for v := range intStream {
+        fmt.Println(v)
+    }
+    // Output:
+    // hello
+    // hello
+    // hello
 }
 ```
 
-
-
 ### <span id="Or">Or</span>
 
 <p>将一个或多个channel读取到一个channel中，当任何读取channel关闭时将结束读取。</p>
@@ -288,7 +279,7 @@ func main() {
 ```go
 func (c *Channel[T]) Or(channels ...<-chan T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -300,31 +291,28 @@ import (
 )
 
 func main() {
-	sig := func(after time.Duration) <-chan any {
-		c := make(chan any)
-		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[any]()
-	<-c.Or(
-		sig(1*time.Second),
-		sig(2*time.Second),
-		sig(3*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>将一个channel读入另一个channel，直到取消上下文。</p>
@@ -334,7 +322,7 @@ func main() {
 ```go
 func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -346,25 +334,23 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
 
-	for v := range c.OrDone(ctx, intStream) {
-		fmt.Println(v)
-	}
-	// Output:
-	// 1
-	// 1
-	// 1
+    for v := range c.OrDone(ctx, intStream) {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 1
+    // 1
 }
 ```
 
-
-
-
 ### <span id="Take">Take</span>
 
 <p>返回一个channel，其值从另一个channel获取，直到取消上下文。</p>
@@ -374,7 +360,7 @@ func main() {
 ```go
 func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -386,32 +372,31 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    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)
+    numbers := make(chan int, 5)
+    numbers <- 1
+    numbers <- 2
+    numbers <- 3
+    numbers <- 4
+    numbers <- 5
+    defer close(numbers)
 
-	c := concurrency.NewChannel[int]()
-	intStream := c.Take(ctx, numbers, 3)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, numbers, 3)
 
-	for v := range intStream {
-		fmt.Println(v)
-	}
-	// Output:
-	// 1
-	// 2
-	// 3
+    for v := range intStream {
+        fmt.Println(v)
+    }
+
+    // Output:
+    // 1
+    // 2
+    // 3
 }
 ```
 
-
-
 ### <span id="Tee">Tee</span>
 
 <p>将一个channel分成两个channel，直到取消上下文。</p>
@@ -421,7 +406,7 @@ func main() {
 ```go
 func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -433,22 +418,22 @@ import (
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
 
-	c := concurrency.NewChannel[int]()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1), 2)
+    c := concurrency.NewChannel[int]()
+    intStream := c.Take(ctx, c.Repeat(ctx, 1), 2)
 
-	ch1, ch2 := c.Tee(ctx, intStream)
+    ch1, ch2 := c.Tee(ctx, intStream)
 
-	for v := range ch1 {
-		fmt.Println(v)
-		fmt.Println(<-ch2)
-	}
-	// Output:
-	// 1
-	// 1
-	// 1
-	// 1
+    for v := range ch1 {
+        fmt.Println(v)
+        fmt.Println(<-ch2)
+    }
+    // Output:
+    // 1
+    // 1
+    // 1
+    // 1
 }
 ```

docs/condition.md

@@ -57,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>
 
@@ -111,10 +122,10 @@ 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
 }
 ```
 
@@ -139,10 +150,10 @@ 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
 }
 ```
 
@@ -167,10 +178,10 @@ 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
 }
 ```
 
@@ -195,10 +206,10 @@ 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)) // false
+    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
 }
 ```
 
@@ -222,10 +233,10 @@ import (
 )
 
 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
+    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
 }
 ```
 
@@ -249,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
 }
 ```
 
@@ -277,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

@@ -45,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
@@ -56,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>
 
@@ -99,7 +109,7 @@ func main() {
 ```go
 func And[T, U any](a T, b U) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -110,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>
 
@@ -127,7 +135,7 @@ func main() {
 ```go
 func Or[T, U any](a T, b U) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -138,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>
 
@@ -155,7 +161,7 @@ func main() {
 ```go
 func Xor[T, U any](a T, b U) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -166,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>
 
@@ -183,7 +187,7 @@ func main() {
 ```go
 func Nor[T, U any](a T, b U) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -194,15 +198,13 @@ 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)) // false
+    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>
 
@@ -211,7 +213,7 @@ func main() {
 ```go
 func Xnor[T, U any](a T, b U) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -222,10 +224,10 @@ import (
 )
 
 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
+    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
 }
 ```
 
@@ -237,7 +239,7 @@ func main() {
 ```go
 func Nand[T, U any](a T, b U) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -248,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>
 
@@ -265,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
@@ -276,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,30 +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>
@@ -50,6 +57,7 @@ import (
 ```go
 func ColorHexToRGB(colorHex string) (red, green, blue int)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -63,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>
@@ -78,6 +88,7 @@ func main() {
 ```go
 func ColorRGBToHex(red, green, blue int) string
 ```
+
 <b>Example:</b>
 
 ```go
@@ -92,14 +103,15 @@ 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 bool. Use strconv.ParseBool.</p>
@@ -109,6 +121,7 @@ func main() {
 ```go
 func ToBool(s string) (bool, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -120,22 +133,26 @@ 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 value to byte slice.</p>
@@ -145,6 +162,7 @@ func main() {
 ```go
 func ToBytes(data any) ([]byte, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -156,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>
@@ -175,6 +195,7 @@ func main() {
 ```go
 func ToChar(s string) []string
 ```
+
 <b>Example:</b>
 
 ```go
@@ -186,18 +207,21 @@ 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 channel.</p>
@@ -207,6 +231,7 @@ func main() {
 ```go
 func ToChannel[T any](array []T) <-chan T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -219,23 +244,21 @@ 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 value to a float64 value. If param is a invalid floatable, will return 0.0 and error. </p>
@@ -245,6 +268,7 @@ func main() {
 ```go
 func ToFloat(value any) (float64, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -256,19 +280,30 @@ 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 value to a int64 value. If param is a invalid intable, will return 0 and error. </p>
@@ -278,6 +313,7 @@ func main() {
 ```go
 func ToInt(value any) (int64, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -289,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>
@@ -311,6 +355,7 @@ func main() {
 ```go
 func ToJson(value any) (string, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -322,14 +367,20 @@ 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 of structs to a map based on iteratee function. </p>
@@ -339,6 +390,7 @@ func main() {
 ```go
 func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
 ```
+
 <b>Example:</b>
 
 ```go
@@ -358,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>
@@ -377,6 +431,7 @@ func main() {
 ```go
 func ToPointer[T any](value T) *T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -389,11 +444,13 @@ 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>
@@ -403,6 +460,7 @@ func main() {
 ```go
 func ToString(value any) string
 ```
+
 <b>Example:</b>
 
 ```go
@@ -414,13 +472,33 @@ 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>Convert struct to map, only convert exported field, struct field tag `json` should be set.</p>
@@ -430,6 +508,7 @@ func main() {
 ```go
 func StructToMap(value any) (map[string]any, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -451,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>
@@ -466,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
@@ -486,7 +567,6 @@ func main() {
 }
 ```
 
-
 ### <span id="EncodeByte">EncodeByte</span>
 
 <p>Encode data to byte slice.</p>
@@ -496,6 +576,7 @@ func main() {
 ```go
 func EncodeByte(data any) ([]byte, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -508,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>
@@ -523,6 +605,7 @@ func main() {
 ```go
 func DecodeByte(data []byte, target any) error
 ```
+
 <b>Example:</b>
 
 ```go
@@ -535,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,38 +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
@@ -65,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
@@ -94,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
@@ -122,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
@@ -158,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
@@ -188,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
@@ -222,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
@@ -259,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
@@ -292,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
@@ -325,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
@@ -361,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
@@ -392,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>将值转换为字符串，对于数字、字符串、[]byte，将转换为字符串。 对于其他类型（切片、映射、数组、结构）将调用 json.Marshal</p>
+<p>将值转换为字符串，对于数字、字符串、[]byte，将转换为字符串。 对于其他类型（切片、映射、数组、结构体）将调用 json.Marshal</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToString(value any) string
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -418,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
@@ -456,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
@@ -491,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
@@ -514,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
@@ -541,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/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_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
@@ -139,7 +139,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) InsertAt(index int, value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -174,7 +174,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) InsertAtHead(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -206,7 +206,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) InsertAtTail(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -237,7 +237,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) DeleteAt(index int)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -271,7 +271,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) DeleteAtHead()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -306,7 +306,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) DeleteAtTail()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -339,7 +339,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) DeleteValue(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -373,7 +373,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) Reverse()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -405,7 +405,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) GetMiddleNode() *datastructure.LinkNode[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -437,7 +437,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -468,7 +468,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -500,7 +500,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -533,7 +533,7 @@ func main() {
 ```go
 func (link *SinglyLink[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -576,7 +576,7 @@ type DoublyLink[T any] struct {
 }
 func NewDoublyLink[T any]() *DoublyLink[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -602,7 +602,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) Values() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -634,7 +634,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) InsertAt(index int, value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -669,7 +669,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) InsertAtHead(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -701,7 +701,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) InsertAtTail(value T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -732,7 +732,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) DeleteAt(index int)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -766,7 +766,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) DeleteAtHead()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -801,7 +801,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) DeleteAtTail()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -835,7 +835,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) Reverse()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -867,7 +867,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) GetMiddleNode() *datastructure.LinkNode[T]
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -899,7 +899,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) Size() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -930,7 +930,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -962,7 +962,7 @@ func main() {
 ```go
 func (link *DoublyLink[T]) Clear()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -995,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,32 +22,32 @@ import (
 
 ## Index
 
-- [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)
-
-
+-   [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>Create a set instance</p>
 
 <b>Signature:</b>
@@ -55,6 +56,7 @@ import (
 type Set[T comparable] map[T]bool
 func NewSet[T comparable](items ...T) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -71,8 +73,8 @@ func main() {
 }
 ```
 
-
 ### <span id="NewSetFromSlice">NewSetFromSlice</span>
+
 <p>Create a set from slice</p>
 
 <b>Signature:</b>
@@ -80,6 +82,7 @@ func main() {
 ```go
 func NewSetFromSlice[T comparable](items []T) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -96,9 +99,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Values">Values</span>
+
 <p>Return slice of all set data</p>
 
 <b>Signature:</b>
@@ -106,6 +108,7 @@ func main() {
 ```go
 func (s Set[T]) Values() []T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -122,10 +125,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Add">Add</span>
+
 <p>Add items to set</p>
 
 <b>Signature:</b>
@@ -133,6 +134,7 @@ func main() {
 ```go
 func (s Set[T]) Add(items ...T)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -151,8 +153,8 @@ func main() {
 }
 ```
 
-
 ### <span id="AddIfNotExist">AddIfNotExist</span>
+
 <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>
@@ -160,6 +162,7 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExist(item T) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -175,7 +178,7 @@ func main() {
     st.Add(1, 2, 3)
 
     r1 := st.AddIfNotExist(1)
-	r2 := st.AddIfNotExist(4)
+    r2 := st.AddIfNotExist(4)
 
     fmt.Println(r1) // false
     fmt.Println(r2) // true
@@ -183,8 +186,8 @@ func main() {
 }
 ```
 
-
 ### <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>
@@ -192,6 +195,7 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -206,23 +210,23 @@ func main() {
     st := set.NewSet[int]()
     st.Add(1, 2)
 
-	ok := st.AddIfNotExistBy(3, func(val int) bool {
-		return val%2 != 0
-	})
+    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
-	})
+    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>
@@ -230,6 +234,7 @@ func main() {
 ```go
 func (s Set[T]) Delete(items ...T)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -249,9 +254,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Contain">Contain</span>
+
 <p>Check if item is in set or not</p>
 
 <b>Signature:</b>
@@ -259,6 +263,7 @@ func main() {
 ```go
 func (s Set[T]) Contain(item T) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -278,10 +283,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="ContainAll">ContainAll</span>
+
 <p>Checks if set contains another set</p>
 
 <b>Signature:</b>
@@ -289,6 +292,7 @@ func main() {
 ```go
 func (s Set[T]) ContainAll(other Set[T]) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -301,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>
@@ -319,6 +322,7 @@ func main() {
 ```go
 func (s Set[T]) Size() int
 ```
+
 <b>Example:</b>
 
 ```go
@@ -336,9 +340,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Clone">Clone</span>
+
 <p>Make a copy of set</p>
 
 <b>Signature:</b>
@@ -346,6 +349,7 @@ func main() {
 ```go
 func (s Set[T]) Clone() Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -365,10 +369,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Equal">Equal</span>
+
 <p>Check if two sets has same elements or not</p>
 
 <b>Signature:</b>
@@ -376,6 +378,7 @@ func main() {
 ```go
 func (s Set[T]) Equal(other Set[T]) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -396,9 +399,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Iterate">Iterate</span>
+
 <p>Call function by every element of set</p>
 
 <b>Signature:</b>
@@ -406,6 +408,7 @@ func main() {
 ```go
 func (s Set[T]) Iterate(fn func(item T))
 ```
+
 <b>Example:</b>
 
 ```go
@@ -427,9 +430,45 @@ func main() {
 }
 ```
 
+### <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>
@@ -437,6 +476,7 @@ func main() {
 ```go
 func (s Set[T]) IsEmpty() bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -456,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>
@@ -466,6 +505,7 @@ func main() {
 ```go
 func (s Set[T]) Union(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -485,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>
@@ -495,6 +534,7 @@ func main() {
 ```go
 func (s Set[T]) Intersection(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -514,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>
@@ -526,6 +563,7 @@ func main() {
 ```go
 func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -538,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>
@@ -557,6 +592,7 @@ func main() {
 ```go
 func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -569,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
@@ -580,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,32 +22,31 @@ import (
 
 ## 目录
 
-- [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)
-
-
+-   [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>
@@ -55,7 +55,8 @@ import (
 type Set[T comparable] map[T]bool
 func NewSet[T comparable](items ...T) Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -71,9 +72,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="NewSetFromSlice">NewSetFromSlice</span>
+
 <p>基于切片创建集合</p>
 
 <b>函数签名:</b>
@@ -81,7 +81,8 @@ func main() {
 ```go
 func NewSetFromSlice[T comparable](items []T) Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -97,9 +98,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Values">Values</span>
+
 <p>获取集合中所有元素的切片</p>
 
 <b>函数签名:</b>
@@ -107,7 +107,8 @@ func main() {
 ```go
 func (s Set[T]) Values() []T
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -123,10 +124,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Add">Add</span>
+
 <p>向集合中添加元素</p>
 
 <b>函数签名:</b>
@@ -134,7 +133,8 @@ func main() {
 ```go
 func (s Set[T]) Add(items ...T)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -152,8 +152,8 @@ func main() {
 }
 ```
 
-
 ### <span id="AddIfNotExist">AddIfNotExist</span>
+
 <p>如果集合中不存在元素，则添加该元素返回true, 如果集合中存在元素, 不做任何操作，返回false</p>
 
 <b>函数签名:</b>
@@ -161,7 +161,8 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExist(item T) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -176,7 +177,7 @@ func main() {
     st.Add(1, 2, 3)
 
     r1 := st.AddIfNotExist(1)
-	r2 := st.AddIfNotExist(4)
+    r2 := st.AddIfNotExist(4)
 
     fmt.Println(r1) // false
     fmt.Println(r2) // true
@@ -184,8 +185,8 @@ func main() {
 }
 ```
 
-
 ### <span id="AddIfNotExistBy">AddIfNotExistBy</span>
+
 <p>根据checker函数判断元素是否在集合中，如果集合中不存在元素且checker返回true，则添加该元素返回true, 否则不做任何操作，返回false</p>
 
 <b>函数签名:</b>
@@ -193,7 +194,8 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -207,24 +209,23 @@ func main() {
     st := set.NewSet[int]()
     st.Add(1, 2)
 
-	ok := st.AddIfNotExistBy(3, func(val int) bool {
-		return val%2 != 0
-	})
+    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
-	})
+    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>
@@ -232,7 +233,8 @@ func main() {
 ```go
 func (s Set[T]) Delete(items ...T)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -251,9 +253,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Contain">Contain</span>
+
 <p>判断集合是否包含某个值</p>
 
 <b>函数签名:</b>
@@ -261,7 +262,8 @@ func main() {
 ```go
 func (s Set[T]) Contain(item T) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -280,10 +282,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="ContainAll">ContainAll</span>
+
 <p>判断集合是否包含另一个集合</p>
 
 <b>函数签名:</b>
@@ -291,7 +291,8 @@ func main() {
 ```go
 func (s Set[T]) ContainAll(other Set[T]) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -303,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>
@@ -321,7 +321,8 @@ func main() {
 ```go
 func (s Set[T]) Size() int
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -338,9 +339,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Clone">Clone</span>
+
 <p>克隆一个集合</p>
 
 <b>函数签名:</b>
@@ -348,7 +348,8 @@ func main() {
 ```go
 func (s Set[T]) Clone() Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -367,10 +368,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Equal">Equal</span>
+
 <p>比较两个集合是否相等，包含相同元素为相等</p>
 
 <b>函数签名:</b>
@@ -378,7 +377,8 @@ func main() {
 ```go
 func (s Set[T]) Equal(other Set[T]) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -398,9 +398,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Iterate">Iterate</span>
+
 <p>迭代结合，在每个元素上调用函数</p>
 
 <b>函数签名:</b>
@@ -408,7 +407,8 @@ func main() {
 ```go
 func (s Set[T]) Iterate(fn func(item T))
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -429,9 +429,45 @@ func main() {
 }
 ```
 
+### <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>
@@ -439,7 +475,8 @@ func main() {
 ```go
 func (s Set[T]) IsEmpty() bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -458,9 +495,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Union">Union</span>
+
 <p>求两个集合的并集</p>
 
 <b>函数签名:</b>
@@ -468,7 +504,8 @@ func main() {
 ```go
 func (s Set[T]) Union(other Set[T]) Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -487,9 +524,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Intersection">Intersection</span>
+
 <p>求两个集合的交集</p>
 
 <b>函数签名:</b>
@@ -497,7 +533,8 @@ func main() {
 ```go
 func (s Set[T]) Intersection(other Set[T]) Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -516,8 +553,8 @@ func main() {
 }
 ```
 
-
 ### <span id="SymmetricDifference">SymmetricDifference</span>
+
 <p>返回一个集合，其中元素在第一个集合或第二个集合中，且不同时存在于两个集合中</p>
 
 <b>函数签名:</b>
@@ -525,7 +562,8 @@ func main() {
 ```go
 func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -537,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>
@@ -556,7 +591,8 @@ func main() {
 ```go
 func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -568,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
@@ -579,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_zh-CN.md

@@ -62,7 +62,7 @@ type TreeNode[T any] struct {
 	Right *TreeNode[T]
 }
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -103,7 +103,7 @@ func main() {
 ```go
 func (t *BSTree[T]) Insert(data T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -149,7 +149,7 @@ func main() {
 ```go
 func (t *BSTree[T]) Delete(data T)
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -197,7 +197,7 @@ func main() {
 ```go
 func (t *BSTree[T]) PreOrderTraverse() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -243,7 +243,7 @@ func main() {
 ```go
 func (t *BSTree[T]) InOrderTraverse() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -289,7 +289,7 @@ func main() {
 ```go
 func (t *BSTree[T]) PostOrderTraverse() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -335,7 +335,7 @@ func main() {
 ```go
 func (t *BSTree[T]) LevelOrderTraverse() []T
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -381,7 +381,7 @@ func main() {
 ```go
 func (t *BSTree[T]) Depth() int
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -427,7 +427,7 @@ func main() {
 ```go
 func (t *BSTree[T]) HasSubTree(subTree *BSTree[T]) bool
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -479,7 +479,7 @@ func main() {
 ```go
 func (t *BSTree[T]) Print()
 ```
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main

docs/fileutil.md

@@ -1,15 +1,17 @@
 # Fileutil
+
 Package fileutil implements some basic functions for file operations.
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Source:
 
-- [https://github.com/duke-git/lancet/blob/main/fileutil/file.go](https://github.com/duke-git/lancet/blob/main/fileutil/file.go)
+-   [https://github.com/duke-git/lancet/blob/main/fileutil/file.go](https://github.com/duke-git/lancet/blob/main/fileutil/file.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/fileutil"
@@ -19,30 +21,39 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## Index
-- [ClearFile](#ClearFile)
-- [CreateFile](#CreateFile)
-- [CreateDir](#CreateDir)
-- [CopyFile](#CopyFile)
-- [FileMode](#FileMode)
-- [MiMeType](#MiMeType)
-- [IsExist](#IsExist)
-- [IsLink](#IsLink)
-- [IsDir](#IsDir)
-- [ListFileNames](#ListFileNames)
-- [RemoveFile](#RemoveFile)
-- [ReadFileToString](#ReadFileToString)
-- [ReadFileByLine](#ReadFileByLine)
-- [Zip](#Zip)
-- [UnZip](#UnZip)
-- [UnZip](#UnZip)
+
+-   [ClearFile](#ClearFile)
+-   [CreateFile](#CreateFile)
+-   [CreateDir](#CreateDir)
+-   [CopyFile](#CopyFile)
+-   [CurrentPath](#CurrentPath)
+-   [FileMode](#FileMode)
+-   [MiMeType](#MiMeType)
+-   [IsExist](#IsExist)
+-   [IsLink](#IsLink)
+-   [IsDir](#IsDir)
+-   [ListFileNames](#ListFileNames)
+-   [RemoveFile](#RemoveFile)
+-   [ReadFileToString](#ReadFileToString)
+-   [ReadFileByLine](#ReadFileByLine)
+-   [Zip](#Zip)
+-   [ZipAppendEntry](#ZipAppendEntry)
+-   [UnZip](#UnZip)
+-   [IsZipFile](#IsZipFile)
+-   [FileSize](#FileSize)
+-   [MTime](#MTime)
+-   [Sha](#Sha)
+-   [ReadCsvFile](#ReadCsvFile)
+-   [WriteCsvFile](#WriteCsvFile)
+-   [WriteStringToFile](#WriteStringToFile)
+-   [WriteBytesToFile](#WriteBytesToFile)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
-
-
 ### <span id="ClearFile">ClearFile</span>
+
 <p>Clear the file content, write empty string to the file.</p>
 
 <b>Signature:</b>
@@ -50,6 +61,7 @@ import (
 ```go
 func ClearFile(path string) error
 ```
+
 <b>Example:</b>
 
 ```go
@@ -69,6 +81,7 @@ func main() {
 ```
 
 ### <span id="CreateFile">CreateFile</span>
+
 <p>Create file in path. return true if create succeed.</p>
 
 <b>Signature:</b>
@@ -76,6 +89,7 @@ func main() {
 ```go
 func CreateFile(path string) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -92,16 +106,16 @@ func main() {
 }
 ```
 
-
-
 ### <span id="CreateDir">CreateDir</span>
-<p>Create directory in absolute path. param `absPath` like /a/, /a/b/.</p>
+
+<p>Create directory in absolute path. param `absPath` like /a, /a/b.</p>
 
 <b>Signature:</b>
 
 ```go
 func CreateDir(absPath string) error
 ```
+
 <b>Example:</b>
 
 ```go
@@ -113,20 +127,21 @@ import (
 )
 
 func main() {
-    err := fileutil.CreateDir("/a/")
+    err := fileutil.CreateDir("/a/b") // will create folder /a/b
     fmt.Println(err)
 }
 ```
 
-
 ### <span id="CopyFile">CopyFile</span>
+
 <p>Copy src file to dest file. If dest file exist will overwrite it.</p>
 
 <b>Signature:</b>
 
 ```go
-func CopyFile(srcFilePath string, dstFilePath string) error
+func CopyFile(srcPath string, dstPath string) error
 ```
+
 <b>Example:</b>
 
 ```go
@@ -145,9 +160,34 @@ func main() {
 }
 ```
 
+### <span id="CurrentPath">CurrentPath</span>
 
+<p>return current absolute path.</p>
+
+<b>Signature:</b>
+
+```go
+func CurrentPath() string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    absPath := CurrentPath()
+    fmt.Println(absPath)
+}
+```
 
 ### <span id="FileMode">FileMode</span>
+
 <p>Return file mode infomation.</p>
 
 <b>Signature:</b>
@@ -155,6 +195,7 @@ func main() {
 ```go
 func FileMode(path string) (fs.FileMode, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -174,9 +215,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="MiMeType">MiMeType</span>
+
 <p>Get file mime type, 'file' param's type should be string or *os.File.</p>
 
 <b>Signature:</b>
@@ -184,6 +224,7 @@ func main() {
 ```go
 func MiMeType(file any) string
 ```
+
 <b>Example:</b>
 
 ```go
@@ -205,10 +246,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="IsExist">IsExist</span>
+
 <p>Checks if a file or directory exists.</p>
 
 <b>Signature:</b>
@@ -216,6 +255,7 @@ func main() {
 ```go
 func IsExist(path string) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -233,9 +273,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="IsLink">IsLink</span>
+
 <p>Checks if a file is symbol link or not.</p>
 
 <b>Signature:</b>
@@ -243,6 +282,7 @@ func main() {
 ```go
 func IsLink(path string) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -259,16 +299,16 @@ func main() {
 }
 ```
 
-
-
 ### <span id="IsDir">IsDir</span>
+
 <p>Checks if the path is directy or not.</p>
 
 <b>Signature:</b>
 
 ```go
-func IsDir(path string) bool 
+func IsDir(path string) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -288,9 +328,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="ListFileNames">ListFileNames</span>
+
 <p>List all file names in given path.</p>
 
 <b>Signature:</b>
@@ -298,6 +337,7 @@ func main() {
 ```go
 func ListFileNames(path string) ([]string, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -314,9 +354,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="RemoveFile">RemoveFile</span>
+
 <p>Remove the file of path.</p>
 
 <b>Signature:</b>
@@ -324,6 +363,7 @@ func main() {
 ```go
 func RemoveFile(path string) error
 ```
+
 <b>Example:</b>
 
 ```go
@@ -342,8 +382,8 @@ func main() {
 }
 ```
 
-
 ### <span id="ReadFileToString">ReadFileToString</span>
+
 <p>Return string of file content.</p>
 
 <b>Signature:</b>
@@ -351,6 +391,7 @@ func main() {
 ```go
 func ReadFileToString(path string) (string, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -374,9 +415,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="ReadFileByLine">ReadFileByLine</span>
+
 <p>Read file line by line, and return slice of lines</p>
 
 <b>Signature:</b>
@@ -384,6 +424,7 @@ func main() {
 ```go
 func ReadFileByLine(path string)([]string, error)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -408,9 +449,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Zip">Zip</span>
+
 <p>Create a zip file of fpath, fpath could be a file or a directory.</p>
 
 <b>Signature:</b>
@@ -418,6 +458,7 @@ func main() {
 ```go
 func Zip(fpath string, destPath string) error
 ```
+
 <b>Example:</b>
 
 ```go
@@ -436,10 +477,36 @@ func main() {
 }
 ```
 
+### <span id="ZipAppendEntry">ZipAppendEntry</span>
 
+<p>Append a single file or directory by fpath to an existing zip file.</p>
 
+<b>Signature:</b>
+
+```go
+func ZipAppendEntry(fpath string, destPath string) error
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    err := fileutil.ZipAppendEntry("./test.txt", "./test.zip")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
 
 ### <span id="UnZip">UnZip</span>
+
 <p>Unzip the file and save it to dest path.</p>
 
 <b>Signature:</b>
@@ -447,6 +514,7 @@ func main() {
 ```go
 func UnZip(zipFile string, destPath string) error
 ```
+
 <b>Example:</b>
 
 ```go
@@ -465,7 +533,309 @@ func main() {
 }
 ```
 
+### <span id="IsZipFile">IsZipFile</span>
 
+<p>Checks if file is zip file or not.</p>
 
+<b>Signature:</b>
 
+```go
+func IsZipFile(filepath string) bool
+```
 
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    isZip := fileutil.IsZipFile("./zipfile.zip")
+    fmt.Println(isZip)
+}
+```
+
+### <span id="FileSize">FileSize</span>
+
+<p>Returns file size in bytes.</p>
+
+<b>Signature:</b>
+
+```go
+func FileSize(path string) (int64, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    size, err := fileutil.FileSize("./testdata/test.txt")
+
+    fmt.Println(size)
+    fmt.Println(err)
+
+    // Output:
+    // 20
+    // <nil>
+}
+```
+
+### <span id="MTime">MTime</span>
+
+<p>Returns file modified time(unix timestamp).</p>
+
+<b>Signature:</b>
+
+```go
+func MTime(filepath string) (int64, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    mtime, err := fileutil.MTime("./testdata/test.txt")
+
+    fmt.Println(mtime)
+    fmt.Println(err)
+
+    // Output:
+    // 1682391110
+    // <nil>
+}
+```
+
+### <span id="Sha">Sha</span>
+
+<p>returns file sha value, param `shaType` should be 1, 256 or 512.</p>
+
+<b>Signature:</b>
+
+```go
+func Sha(filepath string, shaType ...int) (string, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    sha1, err := fileutil.Sha("./testdata/test.txt", 1)
+    sha256, _ := fileutil.Sha("./testdata/test.txt", 256)
+    sha512, _ := fileutil.Sha("./testdata/test.txt", 512)
+
+    fmt.Println(sha1)
+    fmt.Println(sha256)
+    fmt.Println(sha512)
+    fmt.Println(err)
+
+    // Output:
+    // dda3cf10c5a6ff6c6659a497bf7261b287af2bc7
+    // aa6d0a3fbc3442c228d606da09e0c1dc98c69a1cac3da1909199e0266171df35
+    // d22aba2a1b7a2e2f512756255cc1c3708905646920cb1eb95e45b531ba74774dbbb89baebf1f716220eb9cf4908f1cfc5b2a01267704d9a59f59d77cab609870
+    // <nil>
+}
+```
+
+### <span id="ReadCsvFile">ReadCsvFile</span>
+
+<p>Reads file content into slice.</p>
+
+<b>Signature:</b>
+
+```go
+func ReadCsvFile(filepath string) ([][]string, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    content, err := fileutil.ReadCsvFile("./testdata/test.csv")
+
+    fmt.Println(content)
+    fmt.Println(err)
+
+    // Output:
+    // [[Bob  12  male] [Duke  14  male] [Lucy  16  female]]
+    // <nil>
+}
+```
+
+### <span id="WriteCsvFile">WriteCsvFile</span>
+
+<p>Write content to target csv file.</p>
+
+<b>Signature:</b>
+
+```go
+func WriteCsvFile(filepath string, records [][]string, append bool) error
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    fpath := "./test.csv"
+    fileutil.CreateFile(fpath)
+
+    f, _ := os.OpenFile(fpath, os.O_WRONLY|os.O_TRUNC, 0777)
+    defer f.Close()
+
+    data := [][]string{
+        {"Lili", "22", "female"},
+        {"Jim", "21", "male"},
+    }
+    err := fileutil.WriteCsvFile(fpath, data, false)
+
+    if err != nil {
+        return
+    }
+
+    content, err := fileutil.ReadCsvFile(fpath)
+
+    if err != nil {
+        return
+    }
+    fmt.Println(content)
+
+    // Output:
+    // [[Lili 22 female] [Jim 21 male]]
+}
+```
+
+### <span id="WriteBytesToFile">WriteBytesToFile</span>
+
+<p>Writes bytes to target file.</p>
+
+<b>Signature:</b>
+
+```go
+func WriteBytesToFile(filepath string, content []byte) error
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    filepath := "./bytes.txt"
+
+    file, err := os.Create(filepath)
+    if err != nil {
+        return
+    }
+
+    defer file.Close()
+
+    err = fileutil.WriteBytesToFile(filepath, []byte("hello"))
+    if err != nil {
+        return
+    }
+
+    content, err := fileutil.ReadFileToString(filepath)
+    if err != nil {
+        return
+    }
+
+    os.Remove(filepath)
+
+    fmt.Println(content)
+
+    // Output:
+    // hello
+}
+```
+
+### <span id="WriteStringToFile">WriteStringToFile</span>
+
+<p>Writes string to target file.</p>
+
+<b>Signature:</b>
+
+```go
+func WriteStringToFile(filepath string, content string, append bool) error
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    filepath := "./test.txt"
+
+    file, err := os.Create(filepath)
+    if err != nil {
+        return
+    }
+
+    defer file.Close()
+
+    err = fileutil.WriteStringToFile(filepath, "hello", true)
+    if err != nil {
+        return
+    }
+
+    content, err := fileutil.ReadFileToString(filepath)
+    if err != nil {
+        return
+    }
+
+    os.Remove(filepath)
+
+    fmt.Println(content)
+
+    // Output:
+    // hello
+}
+```

docs/fileutil_zh-CN.md

@@ -1,15 +1,17 @@
 # Fileutil
-fileutil包支持文件基本操作。
+
+fileutil 包支持文件基本操作。
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码:
 
-- [https://github.com/duke-git/lancet/blob/main/fileutil/file.go](https://github.com/duke-git/lancet/blob/main/fileutil/file.go)
+-   [https://github.com/duke-git/lancet/blob/main/fileutil/file.go](https://github.com/duke-git/lancet/blob/main/fileutil/file.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 用法:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/fileutil"
@@ -19,29 +21,39 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## 目录
-- [ClearFile](#ClearFile)
-- [CreateFile](#CreateFile)
-- [CreateDir](#CreateDir)
-- [CopyFile](#CopyFile)
-- [FileMode](#FileMode)
-- [MiMeType](#MiMeType)
-- [IsExist](#IsExist)
-- [IsLink](#IsLink)
-- [IsDir](#IsDir)
-- [ListFileNames](#ListFileNames)
-- [RemoveFile](#RemoveFile)
-- [ReadFileToString](#ReadFileToString)
-- [ReadFileByLine](#ReadFileByLine)
-- [Zip](#Zip)
-- [UnZip](#UnZip)
+
+-   [ClearFile](#ClearFile)
+-   [CreateFile](#CreateFile)
+-   [CreateDir](#CreateDir)
+-   [CopyFile](#CopyFile)
+-   [CurrentPath](#CurrentPath)
+-   [FileMode](#FileMode)
+-   [MiMeType](#MiMeType)
+-   [IsExist](#IsExist)
+-   [IsLink](#IsLink)
+-   [IsDir](#IsDir)
+-   [ListFileNames](#ListFileNames)
+-   [RemoveFile](#RemoveFile)
+-   [ReadFileToString](#ReadFileToString)
+-   [ReadFileByLine](#ReadFileByLine)
+-   [Zip](#Zip)
+-   [ZipAppendEntry](#ZipAppendEntry)
+-   [UnZip](#UnZip)
+-   [IsZipFile](#IsZipFile)
+-   [FileSize](#FileSize)
+-   [MTime](#MTime)
+-   [Sha](#Sha)
+-   [ReadCsvFile](#ReadCsvFile)
+-   [WriteCsvFile](#WriteCsvFile)
+-   [WriteStringToFile](#WriteStringToFile)
+-   [WriteBytesToFile](#WriteBytesToFile)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
-
-
 ### <span id="ClearFile">ClearFile</span>
+
 <p>清空文件内容</p>
 
 <b>函数签名:</b>
@@ -49,7 +61,8 @@ import (
 ```go
 func ClearFile(path string) error
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -68,6 +81,7 @@ func main() {
 ```
 
 ### <span id="CreateFile">CreateFile</span>
+
 <p>创建文件，创建成功返回true, 否则返回false</p>
 
 <b>函数签名:</b>
@@ -75,7 +89,8 @@ func main() {
 ```go
 func CreateFile(path string) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -91,16 +106,17 @@ func main() {
 }
 ```
 
-
 ### <span id="CreateDir">CreateDir</span>
-<p>使用绝对路径创建嵌套目录，例如/a/, /a/b/</p>
+
+<p>使用绝对路径创建嵌套目录，例如/a/, /a/b</p>
 
 <b>函数签名:</b>
 
 ```go
 func CreateDir(absPath string) error
 ```
-<b>Example:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -111,22 +127,22 @@ import (
 )
 
 func main() {
-    err := fileutil.CreateDir("/a/")
+    err := fileutil.CreateDir("/a/b") // will create folder /a/b
     fmt.Println(err)
 }
 ```
 
-
-
 ### <span id="CopyFile">CopyFile</span>
+
 <p>拷贝文件，会覆盖原有的文件</p>
 
 <b>函数签名:</b>
 
 ```go
-func CopyFile(srcFilePath string, dstFilePath string) error
+func CopyFile(srcPath string, dstPath string) error
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -144,9 +160,34 @@ func main() {
 }
 ```
 
+### <span id="CurrentPath">CurrentPath</span>
 
+<p>返回当前位置的绝对路径。</p>
+
+<b>函数签名:</b>
+
+```go
+func CurrentPath() string
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    absPath := CurrentPath()
+    fmt.Println(absPath)
+}
+```
 
 ### <span id="FileMode">FileMode</span>
+
 <p>获取文件mode信息</p>
 
 <b>函数签名:</b>
@@ -154,7 +195,8 @@ func main() {
 ```go
 func FileMode(path string) (fs.FileMode, error)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -173,9 +215,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="MiMeType">MiMeType</span>
+
 <p>获取文件mime类型, 'file'参数的类型必须是string或者*os.File</p>
 
 <b>函数签名:</b>
@@ -183,7 +224,8 @@ func main() {
 ```go
 func MiMeType(file any) string
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -204,10 +246,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="IsExist">IsExist</span>
+
 <p>判断文件或目录是否存在</p>
 
 <b>函数签名:</b>
@@ -215,7 +255,8 @@ func main() {
 ```go
 func IsExist(path string) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -232,9 +273,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="IsLink">IsLink</span>
+
 <p>判断文件是否是符号链接</p>
 
 <b>函数签名:</b>
@@ -242,7 +282,8 @@ func main() {
 ```go
 func IsLink(path string) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -258,17 +299,17 @@ func main() {
 }
 ```
 
-
-
 ### <span id="IsDir">IsDir</span>
+
 <p>判断参数是否是目录</p>
 
 <b>函数签名:</b>
 
 ```go
-func IsDir(path string) bool 
+func IsDir(path string) bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -287,9 +328,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="ListFileNames">ListFileNames</span>
+
 <p>返回目录下所有文件名</p>
 
 <b>函数签名:</b>
@@ -297,7 +337,8 @@ func main() {
 ```go
 func ListFileNames(path string) ([]string, error)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -313,9 +354,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="RemoveFile">RemoveFile</span>
+
 <p>删除文件</p>
 
 <b>函数签名:</b>
@@ -323,7 +363,8 @@ func main() {
 ```go
 func RemoveFile(path string) error
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -341,8 +382,8 @@ func main() {
 }
 ```
 
-
 ### <span id="ReadFileToString">ReadFileToString</span>
+
 <p>读取文件内容并返回字符串</p>
 
 <b>函数签名:</b>
@@ -350,7 +391,8 @@ func main() {
 ```go
 func ReadFileToString(path string) (string, error)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -373,9 +415,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="ReadFileByLine">ReadFileByLine</span>
+
 <p>按行读取文件内容，返回字符串切片包含每一行</p>
 
 <b>函数签名:</b>
@@ -383,7 +424,8 @@ func main() {
 ```go
 func ReadFileByLine(path string)([]string, error)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -407,9 +449,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Zip">Zip</span>
+
 <p>zip压缩文件, fpath参数可以是文件或目录</p>
 
 <b>函数签名:</b>
@@ -417,7 +458,8 @@ func main() {
 ```go
 func Zip(fpath string, destPath string) error
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -435,18 +477,45 @@ func main() {
 }
 ```
 
+### <span id="ZipAppendEntry">ZipAppendEntry</span>
 
+<p>通过将单个文件或目录追加到现有的zip文件</p>
 
+<b>函数签名:</b>
+
+```go
+func ZipAppendEntry(fpath string, destPath string) error
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    err := fileutil.ZipAppendEntry("./test.txt", "./test.zip")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
 
 ### <span id="UnZip">UnZip</span>
+
 <p>zip解压缩文件并保存在目录中</p>
 
-<b>Signature:</b>
+<b>函数签名:</b>
 
 ```go
 func UnZip(zipFile string, destPath string) error
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -464,7 +533,309 @@ func main() {
 }
 ```
 
+### <span id="IsZipFile">IsZipFile</span>
 
+<p>判断文件是否是zip压缩文件。</p>
 
+<b>函数签名:</b>
 
+```go
+func IsZipFile(filepath string) bool
+```
 
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    isZip := fileutil.IsZipFile("./zipfile.zip")
+    fmt.Println(isZip)
+}
+```
+
+### <span id="FileSize">FileSize</span>
+
+<p>返回文件字节大小。</p>
+
+<b>函数签名:</b>
+
+```go
+func FileSize(path string) (int64, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    size, err := fileutil.FileSize("./testdata/test.txt")
+
+    fmt.Println(size)
+    fmt.Println(err)
+
+    // Output:
+    // 20
+    // <nil>
+}
+```
+
+### <span id="MTime">MTime</span>
+
+<p>返回文件修改时间(unix timestamp).</p>
+
+<b>函数签名:</b>
+
+```go
+func MTime(filepath string) (int64, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    mtime, err := fileutil.MTime("./testdata/test.txt")
+
+    fmt.Println(mtime)
+    fmt.Println(err)
+
+    // Output:
+    // 1682391110
+    // <nil>
+}
+```
+
+### <span id="Sha">Sha</span>
+
+<p>返回文件sha值，参数`shaType` 应传值为: 1, 256，512.</p>
+
+<b>函数签名:</b>
+
+```go
+func Sha(filepath string, shaType ...int) (string, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    sha1, err := fileutil.Sha("./testdata/test.txt", 1)
+    sha256, _ := fileutil.Sha("./testdata/test.txt", 256)
+    sha512, _ := fileutil.Sha("./testdata/test.txt", 512)
+
+    fmt.Println(sha1)
+    fmt.Println(sha256)
+    fmt.Println(sha512)
+    fmt.Println(err)
+
+    // Output:
+    // dda3cf10c5a6ff6c6659a497bf7261b287af2bc7
+    // aa6d0a3fbc3442c228d606da09e0c1dc98c69a1cac3da1909199e0266171df35
+    // d22aba2a1b7a2e2f512756255cc1c3708905646920cb1eb95e45b531ba74774dbbb89baebf1f716220eb9cf4908f1cfc5b2a01267704d9a59f59d77cab609870
+    // <nil>
+}
+```
+
+### <span id="ReadCsvFile">ReadCsvFile</span>
+
+<p>读取csv文件内容到切片</p>
+
+<b>函数签名:</b>
+
+```go
+func ReadCsvFile(filepath string) ([][]string, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    content, err := fileutil.ReadCsvFile("./testdata/test.csv")
+
+    fmt.Println(content)
+    fmt.Println(err)
+
+    // Output:
+    // [[Bob  12  male] [Duke  14  male] [Lucy  16  female]]
+    // <nil>
+}
+```
+
+### <span id="WriteCsvFile">WriteCsvFile</span>
+
+<p>向csv文件写入内容。</p>
+
+<b>函数签名:</b>
+
+```go
+func WriteCsvFile(filepath string, records [][]string, append bool) error
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    fpath := "./test.csv"
+    fileutil.CreateFile(fpath)
+
+    f, _ := os.OpenFile(fpath, os.O_WRONLY|os.O_TRUNC, 0777)
+    defer f.Close()
+
+    data := [][]string{
+        {"Lili", "22", "female"},
+        {"Jim", "21", "male"},
+    }
+    err := fileutil.WriteCsvFile(fpath, data, false)
+
+    if err != nil {
+        return
+    }
+
+    content, err := fileutil.ReadCsvFile(fpath)
+
+    if err != nil {
+        return
+    }
+    fmt.Println(content)
+
+    // Output:
+    // [[Lili 22 female] [Jim 21 male]]
+}
+```
+
+### <span id="WriteBytesToFile">WriteBytesToFile</span>
+
+<p>将bytes写入文件。</p>
+
+<b>函数签名:</b>
+
+```go
+func WriteBytesToFile(filepath string, content []byte) error
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    filepath := "./bytes.txt"
+
+    file, err := os.Create(filepath)
+    if err != nil {
+        return
+    }
+
+    defer file.Close()
+
+    err = fileutil.WriteBytesToFile(filepath, []byte("hello"))
+    if err != nil {
+        return
+    }
+
+    content, err := fileutil.ReadFileToString(filepath)
+    if err != nil {
+        return
+    }
+
+    os.Remove(filepath)
+
+    fmt.Println(content)
+
+    // Output:
+    // hello
+}
+```
+
+### <span id="WriteStringToFile">WriteStringToFile</span>
+
+<p>将字符串写入文件。</p>
+
+<b>函数签名:</b>
+
+```go
+func WriteStringToFile(filepath string, content string, append bool) error
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    filepath := "./test.txt"
+
+    file, err := os.Create(filepath)
+    if err != nil {
+        return
+    }
+
+    defer file.Close()
+
+    err = fileutil.WriteStringToFile(filepath, "hello", true)
+    if err != nil {
+        return
+    }
+
+    content, err := fileutil.ReadFileToString(filepath)
+    if err != nil {
+        return
+    }
+
+    os.Remove(filepath)
+
+    fmt.Println(content)
+
+    // Output:
+    // hello
+}
+```

docs/formatter.md

@@ -1,15 +1,18 @@
 # Formatter
+
 formatter contains some functions for data formatting.
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Source:
 
-- [https://github.com/duke-git/lancet/blob/main/formatter/formatter.go](https://github.com/duke-git/lancet/blob/main/formatter/formatter.go)
+-   [https://github.com/duke-git/lancet/blob/main/formatter/formatter.go](https://github.com/duke-git/lancet/blob/main/formatter/formatter.go)
+-   [https://github.com/duke-git/lancet/blob/main/formatter/byte.go](https://github.com/duke-git/lancet/blob/main/formatter/byte.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/formatter"
@@ -19,15 +22,21 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## Index
-- [Comma](#Comma)
+
+-   [Comma](#Comma)
+-   [Pretty](#Pretty)
+-   [PrettyToWriter](#PrettyToWriter)
+-   [DecimalBytes](#DecimalBytes)
+-   [BinaryBytes](#BinaryBytes)
+-   [ParseDecimalBytes](#ParseDecimalBytes)
+-   [ParseBinaryBytes](#ParseBinaryBytes)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
-
-
 ### <span id="Comma">Comma</span>
+
 <p>Add comma to a number value by every 3 numbers from right to left. ahead by symbol char. if value is a invalid number string like "aa", return empty string.</p>
 
 <b>Signature:</b>
@@ -35,6 +44,7 @@ import (
 ```go
 func Comma[T constraints.Float | constraints.Integer | string](value T, symbol string) string
 ```
+
 <b>Example:</b>
 
 ```go
@@ -46,7 +56,255 @@ import (
 )
 
 func main() {
-    fmt.Println(formatter.Comma("12345", ""))   // "12,345"
-    fmt.Println(formatter.Comma(12345.67, "¥")) // "¥12,345.67"
+    result1 := formatter.Comma("123", "")
+    result2 := formatter.Comma("12345", "$")
+    result3 := formatter.Comma(1234567, "￥")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 123
+    // $12,345
+    // ￥1,234,567
+}
+```
+
+### <span id="Pretty">Pretty</span>
+
+<p>Pretty data to JSON string.</p>
+
+<b>Signature:</b>
+
+```go
+func Pretty(v any) (string, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1, _ := formatter.Pretty([]string{"a", "b", "c"})
+    result2, _ := formatter.Pretty(map[string]int{"a": 1})
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // [
+    //     "a",
+    //     "b",
+    //     "c"
+    // ]
+    // {
+    //     "a": 1
+    // }
+}
+```
+
+### <span id="PrettyToWriter">PrettyToWriter</span>
+
+<p>Pretty encode data to writer.</p>
+
+<b>Signature:</b>
+
+```go
+func PrettyToWriter(v any, out io.Writer) error
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    type User struct {
+        Name string `json:"name"`
+        Aage uint   `json:"age"`
+    }
+    user := User{Name: "King", Aage: 10000}
+
+    buf := &bytes.Buffer{}
+    err := formatter.PrettyToWriter(user, buf)
+
+    fmt.Println(buf)
+    fmt.Println(err)
+
+    // Output:
+    // {
+    //     "name": "King",
+    //     "age": 10000
+    // }
+    //
+    // <nil>
+}
+```
+
+### <span id="DecimalBytes">DecimalBytes</span>
+
+<p>Returns a human readable byte size under decimal standard (base 1000). The precision parameter specifies the number of digits after the decimal point, which is 4 for default.</p>
+
+<b>Signature:</b>
+
+```go
+func DecimalBytes(size float64, precision ...int) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1 := formatter.DecimalBytes(1000)
+    result2 := formatter.DecimalBytes(1024)
+    result3 := formatter.DecimalBytes(1234567)
+    result4 := formatter.DecimalBytes(1234567, 3)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 1KB
+    // 1.024KB
+    // 1.2346MB
+    // 1.235MB
+}
+```
+
+### <span id="BinaryBytes">BinaryBytes</span>
+
+<p>Returns a human readable byte size under binary standard (base 1024). The precision parameter specifies the number of digits after the decimal point, which is 4 for default.</p>
+
+<b>Signature:</b>
+
+```go
+func BinaryBytes(size float64, precision ...int) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1 := formatter.BinaryBytes(1024)
+    result2 := formatter.BinaryBytes(1024 * 1024)
+    result3 := formatter.BinaryBytes(1234567)
+    result4 := formatter.BinaryBytes(1234567, 2)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 1KiB
+    // 1MiB
+    // 1.1774MiB
+    // 1.18MiB
+}
+```
+
+### <span id="ParseDecimalBytes">ParseDecimalBytes</span>
+
+<p>Returns the human readable bytes size string into the amount it represents(base 1000).</p>
+
+<b>Signature:</b>
+
+```go
+func ParseDecimalBytes(size string) (uint64, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1, _ := formatter.ParseDecimalBytes("12")
+    result2, _ := formatter.ParseDecimalBytes("12k")
+    result3, _ := formatter.ParseDecimalBytes("12 Kb")
+    result4, _ := formatter.ParseDecimalBytes("12.2 kb")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 12
+    // 12000
+    // 12000
+    // 12200
+}
+```
+
+### <span id="ParseBinaryBytes">ParseBinaryBytes</span>
+
+<p>Returns the human readable bytes size string into the amount it represents(base 1024).</p>
+
+<b>Signature:</b>
+
+```go
+func ParseBinaryBytes(size string) (uint64, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1, _ := formatter.ParseBinaryBytes("12")
+    result2, _ := formatter.ParseBinaryBytes("12ki")
+    result3, _ := formatter.ParseBinaryBytes("12 KiB")
+    result4, _ := formatter.ParseBinaryBytes("12.2 kib")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 12
+    // 12288
+    // 12288
+    // 12492
 }
 ```

docs/formatter_zh-CN.md

@@ -1,15 +1,18 @@
 # Formatter
-formatter格式化器包含一些数据格式化处理方法。
+
+formatter 格式化器包含一些数据格式化处理方法。
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码:
 
-- [https://github.com/duke-git/lancet/blob/main/formatter/formatter.go](https://github.com/duke-git/lancet/blob/main/formatter/formatter.go)
+-   [https://github.com/duke-git/lancet/blob/main/formatter/formatter.go](https://github.com/duke-git/lancet/blob/main/formatter/formatter.go)
+-   [https://github.com/duke-git/lancet/blob/main/formatter/byte.go](https://github.com/duke-git/lancet/blob/main/formatter/byte.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 用法:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/formatter"
@@ -19,15 +22,21 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## 目录
-- [Comma](#Comma)
+
+-   [Comma](#Comma)
+-   [Pretty](#Pretty)
+-   [PrettyToWriter](#PrettyToWriter)
+-   [DecimalBytes](#DecimalBytes)
+-   [BinaryBytes](#BinaryBytes)
+-   [ParseDecimalBytes](#ParseDecimalBytes)
+-   [ParseBinaryBytes](#ParseBinaryBytes)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
-
-
 ### <span id="Comma">Comma</span>
+
 <p>用逗号每隔3位分割数字/字符串，支持前缀添加符号。参数value必须是数字或者可以转为数字的字符串, 否则返回空字符串</p>
 
 <b>函数签名:</b>
@@ -35,7 +44,8 @@ import (
 ```go
 func Comma[T constraints.Float | constraints.Integer | string](value T, symbol string) string
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -46,7 +56,255 @@ import (
 )
 
 func main() {
-    fmt.Println(formatter.Comma("12345", ""))   // "12,345"
-    fmt.Println(formatter.Comma(12345.67, "¥")) // "¥12,345.67"
+    result1 := formatter.Comma("123", "")
+    result2 := formatter.Comma("12345", "$")
+    result3 := formatter.Comma(1234567, "￥")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 123
+    // $12,345
+    // ￥1,234,567
+}
+```
+
+### <span id="Pretty">Pretty</span>
+
+<p>返回pretty JSON字符串.</p>
+
+<b>函数签名:</b>
+
+```go
+func Pretty(v any) (string, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1, _ := formatter.Pretty([]string{"a", "b", "c"})
+    result2, _ := formatter.Pretty(map[string]int{"a": 1})
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // [
+    //     "a",
+    //     "b",
+    //     "c"
+    // ]
+    // {
+    //     "a": 1
+    // }
+}
+```
+
+### <span id="PrettyToWriter">PrettyToWriter</span>
+
+<p>Pretty encode数据到writer。</p>
+
+<b>函数签名:</b>
+
+```go
+func PrettyToWriter(v any, out io.Writer) error
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    type User struct {
+        Name string `json:"name"`
+        Aage uint   `json:"age"`
+    }
+    user := User{Name: "King", Aage: 10000}
+
+    buf := &bytes.Buffer{}
+    err := formatter.PrettyToWriter(user, buf)
+
+    fmt.Println(buf)
+    fmt.Println(err)
+
+    // Output:
+    // {
+    //     "name": "King",
+    //     "age": 10000
+    // }
+    //
+    // <nil>
+}
+```
+
+### <span id="DecimalBytes">DecimalBytes</span>
+
+<p>返回十进制标准（以1000为基数）下的可读字节单位字符串。precision参数指定小数点后的位数，默认为4。</p>
+
+<b>函数签名:</b>
+
+```go
+func DecimalBytes(size float64, precision ...int) string
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1 := formatter.DecimalBytes(1000)
+    result2 := formatter.DecimalBytes(1024)
+    result3 := formatter.DecimalBytes(1234567)
+    result4 := formatter.DecimalBytes(1234567, 3)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 1KB
+    // 1.024KB
+    // 1.2346MB
+    // 1.235MB
+}
+```
+
+### <span id="BinaryBytes">BinaryBytes</span>
+
+<p>返回binary标准（以1024为基数）下的可读字节单位字符串。precision参数指定小数点后的位数，默认为4。</p>
+
+<b>函数签名:</b>
+
+```go
+func BinaryBytes(size float64, precision ...int) string
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1 := formatter.BinaryBytes(1024)
+    result2 := formatter.BinaryBytes(1024 * 1024)
+    result3 := formatter.BinaryBytes(1234567)
+    result4 := formatter.BinaryBytes(1234567, 2)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 1KiB
+    // 1MiB
+    // 1.1774MiB
+    // 1.18MiB
+}
+```
+
+### <span id="ParseDecimalBytes">ParseDecimalBytes</span>
+
+<p>将字节单位字符串转换成其所表示的字节数（以1000为基数）。</p>
+
+<b>函数签名:</b>
+
+```go
+func ParseDecimalBytes(size string) (uint64, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1, _ := formatter.ParseDecimalBytes("12")
+    result2, _ := formatter.ParseDecimalBytes("12k")
+    result3, _ := formatter.ParseDecimalBytes("12 Kb")
+    result4, _ := formatter.ParseDecimalBytes("12.2 kb")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 12
+    // 12000
+    // 12000
+    // 12200
+}
+```
+
+### <span id="ParseBinaryBytes">ParseBinaryBytes</span>
+
+<p>将字节单位字符串转换成其所表示的字节数（以1024为基数）。</p>
+
+<b>函数签名:</b>
+
+```go
+func ParseBinaryBytes(size string) (uint64, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/formatter"
+)
+
+func main() {
+    result1, _ := formatter.ParseBinaryBytes("12")
+    result2, _ := formatter.ParseBinaryBytes("12ki")
+    result3, _ := formatter.ParseBinaryBytes("12 KiB")
+    result4, _ := formatter.ParseBinaryBytes("12.2 kib")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // 12
+    // 12288
+    // 12288
+    // 12492
 }
 ```

docs/function.md

@@ -1,16 +1,18 @@
 # Function
+
 Package function can control the flow of function execution and support part of functional programming.
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Source:
 
-- [https://github.com/duke-git/lancet/blob/main/function/function.go](https://github.com/duke-git/lancet/blob/main/function/function.go)
-- [https://github.com/duke-git/lancet/blob/main/function/watcher.go](https://github.com/duke-git/lancet/blob/main/function/watcher.go)
+-   [https://github.com/duke-git/lancet/blob/main/function/function.go](https://github.com/duke-git/lancet/blob/main/function/function.go)
+-   [https://github.com/duke-git/lancet/blob/main/function/watcher.go](https://github.com/duke-git/lancet/blob/main/function/watcher.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/function"
@@ -20,22 +22,23 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## Index
-- [After](#After)
-- [Before](#Before)
-- [CurryFn](#CurryFn)
-- [Compose](#Compose)
-- [Debounced](#Debounced)
-- [Delay](#Delay)
-- [Pipeline](#Pipeline)
-- [Watcher](#Watcher)
+
+-   [After](#After)
+-   [Before](#Before)
+-   [CurryFn](#CurryFn)
+-   [Compose](#Compose)
+-   [Debounced](#Debounced)
+-   [Delay](#Delay)
+-   [Schedule](#Schedule)
+-   [Pipeline](#Pipeline)
+-   [Watcher](#Watcher)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
-
-
 ### <span id="After">After</span>
+
 <p>Creates a function that invokes given func once it's called n or more times.</p>
 
 <b>Signature:</b>
@@ -43,6 +46,7 @@ import (
 ```go
 func After(n int, fn any) func(args ...any) []reflect.Value
 ```
+
 <b>Example:</b>
 
 ```go
@@ -54,33 +58,18 @@ import (
 )
 
 func main() {
-	arr := []string{"a", "b"}
-	f := function.After(len(arr), func(i int) int {
-		fmt.Println("last print")
-		return i
-	})
+    fn := function.After(2, func() {
+        fmt.Println("hello")
+    })
 
-	type cb func(args ...any) []reflect.Value
-	print := func(i int, s string, fn cb) {
-		fmt.Printf("arr[%d] is %s \n", i, s)
-		fn(i)
-	}
+    fn()
+    fn()
 
-	fmt.Println("arr is", arr)
-	for i := 0; i < len(arr); i++ {
-		print(i, arr[i], f)
-	}
-
-    //output:
-    // arr is [a b]
-    // arr[0] is a 
-    // arr[1] is b 
-    // last print
+    // Output:
+    // hello
 }
 ```
 
-
-
 ### <span id="Before">Before</span>
 
 <p>creates a function that invokes func once it's called less than n times.</p>
@@ -90,6 +79,7 @@ func main() {
 ```go
 func Before(n int, fn any) func(args ...any) []reflect.Value
 ```
+
 <b>Example:</b>
 
 ```go
@@ -102,29 +92,21 @@ import (
 )
 
 func main() {
-	arr := []string{"a", "b", "c", "d", "e"}
-	f := function.Before(3, func(i int) int {
-		return i
-	})
+    fn := function.Before(2, func() {
+        fmt.Println("hello")
+    })
 
-	var res []int64
-	type cb func(args ...any) []reflect.Value
-	appendStr := func(i int, s string, fn cb) {
-		v := fn(i)
-		res = append(res, v[0].Int())
-	}
+    fn()
+    fn()
+    fn()
+    fn()
 
-	for i := 0; i < len(arr); i++ {
-		appendStr(i, arr[i], f)
-	}
-
-	expected := []int64{0, 1, 2, 2, 2}
-	fmt.Println(res) // 0, 1, 2, 2, 2
+    // Output:
+    // hello
+    // hello
 }
 ```
 
-
-
 ### <span id="CurryFn">CurryFn</span>
 
 <p>Make curry function.</p>
@@ -135,6 +117,7 @@ func main() {
 type CurryFn[T any] func(...T) T
 func (cf CurryFn[T]) New(val T) func(...T) T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -147,22 +130,23 @@ import (
 
 func main() {
     add := func(a, b int) int {
-		return a + b
-	}
+        return a + b
+    }
 
-	var addCurry CurryFn[int] = func(values ...int) int {
-		return add(values[0], values[1])
-	}
-	add1 := addCurry.New(1)
+    var addCurry function.CurryFn[int] = func(values ...int) int {
+        return add(values[0], values[1])
+    }
+    add1 := addCurry.New(1)
 
-	result := add1(2)
+    result := add1(2)
 
-	fmt.Println(result) //3
+    fmt.Println(result)
+
+    // Output:
+    // 3
 }
 ```
 
-
-
 ### <span id="Compose">Compose</span>
 
 <p>Compose the function list from right to left, then return the composed function.</p>
@@ -172,6 +156,7 @@ func main() {
 ```go
 func Compose[T any](fnList ...func(...T) T) func(...T) T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -183,22 +168,23 @@ import (
 )
 
 func main() {
-   	toUpper := func(strs ...string) string {
-		return strings.ToUpper(strs[0])
-	}
-	toLower := func(strs ...string) string {
-		return strings.ToLower(strs[0])
-	}
-	transform := Compose(toUpper, toLower)
+    toUpper := func(strs ...string) string {
+        return strings.ToUpper(strs[0])
+    }
+    toLower := func(strs ...string) string {
+        return strings.ToLower(strs[0])
+    }
+    transform := function.Compose(toUpper, toLower)
 
-	result := transform("aBCde")
+    result := transform("aBCde")
 
-	fmt.Println(result) //ABCDE
+    fmt.Println(result)
+
+    // Output:
+    // ABCDE
 }
 ```
 
-
-
 ### <span id="Debounced">Debounced</span>
 
 <p>Creates a debounced function that delays invoking fn until after wait duration have elapsed since the last time the debounced function was invoked.</p>
@@ -208,6 +194,7 @@ func main() {
 ```go
 func Debounced(fn func(), duration time.Duration) func()
 ```
+
 <b>Example:</b>
 
 ```go
@@ -220,27 +207,34 @@ import (
 
 func main() {
     count := 0
-	add := func() {
-		count++
-	}
 
-	debouncedAdd := function.Debounced(add, 50*time.Microsecond)
-	function.debouncedAdd()
-	function.debouncedAdd()
-	function.debouncedAdd()
-	function.debouncedAdd()
+    add := func() {
+        count++
+    }
 
-	time.Sleep(100 * time.Millisecond)
-	fmt.Println(count) //1
+    debouncedAdd := function.Debounced(add, 50*time.Microsecond)
 
-	function.debouncedAdd()
-	time.Sleep(100 * time.Millisecond)
-	fmt.Println(count) //2
+    debouncedAdd()
+    debouncedAdd()
+    debouncedAdd()
+    debouncedAdd()
+
+    time.Sleep(100 * time.Millisecond)
+
+    fmt.Println(count)
+
+    debouncedAdd()
+
+    time.Sleep(100 * time.Millisecond)
+
+    fmt.Println(count)
+
+    // Output:
+    // 1
+    // 2
 }
 ```
 
-
-
 ### <span id="Delay">Delay</span>
 
 <p>Invoke function after delayed time.</p>
@@ -250,6 +244,7 @@ func main() {
 ```go
 func Delay(delay time.Duration, fn any, args ...any)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -261,15 +256,17 @@ import (
 )
 
 func main() {
-	var print = func(s string) {
-		fmt.Println(count) //delay 2 seconds
-	}
-	function.Delay(2*time.Second, print, "delay 2 seconds")
+    var print = func(s string) {
+        fmt.Println(s)
+    }
+
+    function.Delay(2*time.Second, print, "hello")
+
+    // Output:
+    // hello
 }
 ```
 
-
-
 ### <span id="Schedule">Schedule</span>
 
 <p>Invoke function every duration time, until close the returned bool chan.</p>
@@ -279,6 +276,7 @@ func main() {
 ```go
 func Schedule(d time.Duration, fn any, args ...any) chan bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -290,20 +288,24 @@ import (
 )
 
 func main() {
-    var res []string
-	appendStr := func(s string) {
-		res = append(res, s)
-	}
+    count := 0
 
-	stop := function.Schedule(1*time.Second, appendStr, "*")
-	time.Sleep(5 * time.Second)
-	close(stop)
+    increase := func() {
+        count++
+    }
 
-	fmt.Println(res) //[* * * * *]
+    stop := function.Schedule(2*time.Second, increase)
+
+    time.Sleep(2 * time.Second)
+    close(stop)
+
+    fmt.Println(count)
+
+    // Output:
+    // 2
 }
 ```
 
-
 ### <span id="Pipeline">Pipeline</span>
 
 <p>Pipeline takes a list of functions and returns a function whose param will be passed into
@@ -314,6 +316,7 @@ the functions one by one.</p>
 ```go
 func Pipeline[T any](funcs ...func(T) T) func(T) T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -326,22 +329,26 @@ import (
 
 func main() {
     addOne := func(x int) int {
-		return x + 1
-	}
-	double := func(x int) int {
-		return 2 * x
-	}
-	square := func(x int) int {
-		return x * x
-	}
+        return x + 1
+    }
+    double := func(x int) int {
+        return 2 * x
+    }
+    square := func(x int) int {
+        return x * x
+    }
 
-	fn := Pipeline(addOne, double, square)
+    fn := function.Pipeline(addOne, double, square)
 
-	fmt.Println(fn(2)) //36
+    result := fn(2)
+
+    fmt.Println(result)
+
+    // Output:
+    // 36
 }
 ```
 
-
 ### <span id="Watcher">Watcher</span>
 
 <p>Watcher is used for record code excution time. can start/stop/reset the watch timer. get the elapsed time of function execution.</p>
@@ -350,9 +357,9 @@ func main() {
 
 ```go
 type Watcher struct {
-	startTime int64
-	stopTime  int64
-	excuting  bool
+    startTime int64
+    stopTime  int64
+    excuting  bool
 }
 func NewWatcher() *Watcher
 func (w *Watcher) Start() //start the watcher
@@ -360,6 +367,7 @@ func (w *Watcher) Stop() //stop the watcher
 func (w *Watcher) Reset() //reset the watcher
 func (w *Watcher) GetElapsedTime() time.Duration //get the elapsed time of function execution
 ```
+
 <b>Example:</b>
 
 ```go
@@ -371,31 +379,28 @@ import (
 )
 
 func main() {
-   	w := function.NewWatcher()
+       w := function.NewWatcher()
 
-	w.Start()
+    w.Start()
 
-	longRunningTask()
+    longRunningTask()
 
-	fmt.Println(w.excuting) //true
+    fmt.Println(w.excuting) //true
 
-	w.Stop()
+    w.Stop()
 
-	eapsedTime := w.GetElapsedTime().Milliseconds()
-	
-	fmt.Println(eapsedTime)
+    eapsedTime := w.GetElapsedTime().Milliseconds()
 
-	w.Reset()
+    fmt.Println(eapsedTime)
+
+    w.Reset()
 }
 
 func longRunningTask() {
-	var slice []int64
-	for i := 0; i < 10000000; i++ {
-		slice = append(slice, int64(i))
-	}
+    var slice []int64
+    for i := 0; i < 10000000; i++ {
+        slice = append(slice, int64(i))
+    }
 }
 
 ```
-
-
-

docs/function_zh-CN.md

@@ -1,16 +1,18 @@
 # Function
-function函数包控制函数执行流程，包含部分函数式编程。
+
+function 函数包控制函数执行流程，包含部分函数式编程。
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码:
 
-- [https://github.com/duke-git/lancet/blob/main/function/function.go](https://github.com/duke-git/lancet/blob/main/function/function.go)
-- [https://github.com/duke-git/lancet/blob/main/function/watcher.go](https://github.com/duke-git/lancet/blob/main/function/watcher.go)
+-   [https://github.com/duke-git/lancet/blob/main/function/function.go](https://github.com/duke-git/lancet/blob/main/function/function.go)
+-   [https://github.com/duke-git/lancet/blob/main/function/watcher.go](https://github.com/duke-git/lancet/blob/main/function/watcher.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 用法:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/function"
@@ -20,22 +22,23 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## 目录
-- [After](#After)
-- [Before](#Before)
-- [CurryFn](#CurryFn)
-- [Compose](#Compose)
-- [Debounced](#Debounced)
-- [Delay](#Delay)
-- [Pipeline](#Pipeline)
-- [Watcher](#Watcher)
+
+-   [After](#After)
+-   [Before](#Before)
+-   [CurryFn](#CurryFn)
+-   [Compose](#Compose)
+-   [Debounced](#Debounced)
+-   [Delay](#Delay)
+-   [Schedule](#Schedule)
+-   [Pipeline](#Pipeline)
+-   [Watcher](#Watcher)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
-
-
 ### <span id="After">After</span>
+
 <p>创建一个函数，当他被调用n或更多次之后将马上触发fn</p>
 
 <b>函数签名:</b>
@@ -43,7 +46,8 @@ import (
 ```go
 func After(n int, fn any) func(args ...any) []reflect.Value
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -54,33 +58,18 @@ import (
 )
 
 func main() {
-	arr := []string{"a", "b"}
-	f := function.After(len(arr), func(i int) int {
-		fmt.Println("last print")
-		return i
-	})
+    fn := function.After(2, func() {
+        fmt.Println("hello")
+    })
 
-	type cb func(args ...any) []reflect.Value
-	print := func(i int, s string, fn cb) {
-		fmt.Printf("arr[%d] is %s \n", i, s)
-		fn(i)
-	}
+    fn()
+    fn()
 
-	fmt.Println("arr is", arr)
-	for i := 0; i < len(arr); i++ {
-		print(i, arr[i], f)
-	}
-
-    //output:
-    // arr is [a b]
-    // arr[0] is a 
-    // arr[1] is b 
-    // last print
+    // Output:
+    // hello
 }
 ```
 
-
-
 ### <span id="Before">Before</span>
 
 <p>创建一个函数，调用次数不超过n次，之后再调用这个函数，将返回一次最后调用fn的结果</p>
@@ -90,7 +79,8 @@ func main() {
 ```go
 func Before(n int, fn any) func(args ...any) []reflect.Value
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -102,28 +92,21 @@ import (
 )
 
 func main() {
-	arr := []string{"a", "b", "c", "d", "e"}
-	f := function.Before(3, func(i int) int {
-		return i
-	})
+    fn := function.Before(2, func() {
+        fmt.Println("hello")
+    })
 
-	var res []int64
-	type cb func(args ...any) []reflect.Value
-	appendStr := func(i int, s string, fn cb) {
-		v := fn(i)
-		res = append(res, v[0].Int())
-	}
+    fn()
+    fn()
+    fn()
+    fn()
 
-	for i := 0; i < len(arr); i++ {
-		appendStr(i, arr[i], f)
-	}
-
-	fmt.Println(res) // 0, 1, 2, 2, 2
+    // Output:
+    // hello
+    // hello
 }
 ```
 
-
-
 ### <span id="CurryFn">CurryFn</span>
 
 <p>创建柯里化函数</p>
@@ -134,7 +117,8 @@ func main() {
 type CurryFn[T any] func(...T) T
 func (cf CurryFn[T]) New(val T) func(...T) T
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -145,23 +129,24 @@ import (
 )
 
 func main() {
-	add := func(a, b int) int {
-		return a + b
-	}
+    add := func(a, b int) int {
+        return a + b
+    }
 
-	var addCurry CurryFn[int] = func(values ...int) int {
-		return add(values[0], values[1])
-	}
-	add1 := addCurry.New(1)
+    var addCurry function.CurryFn[int] = func(values ...int) int {
+        return add(values[0], values[1])
+    }
+    add1 := addCurry.New(1)
 
-	result := add1(2)
+    result := add1(2)
 
-	fmt.Println(result) //3
+    fmt.Println(result)
+
+    // Output:
+    // 3
 }
 ```
 
-
-
 ### <span id="Compose">Compose</span>
 
 <p>从右至左组合函数列表fnList，返回组合后的函数</p>
@@ -171,7 +156,8 @@ func main() {
 ```go
 func Compose[T any](fnList ...func(...T) T) func(...T) T
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -182,22 +168,23 @@ import (
 )
 
 func main() {
-	toUpper := func(strs ...string) string {
-		return strings.ToUpper(strs[0])
-	}
-	toLower := func(strs ...string) string {
-		return strings.ToLower(strs[0])
-	}
-	transform := Compose(toUpper, toLower)
+    toUpper := func(strs ...string) string {
+        return strings.ToUpper(strs[0])
+    }
+    toLower := func(strs ...string) string {
+        return strings.ToLower(strs[0])
+    }
+    transform := function.Compose(toUpper, toLower)
 
-	result := transform("aBCde")
+    result := transform("aBCde")
 
-	fmt.Println(result) //ABCDE
+    fmt.Println(result)
+
+    // Output:
+    // ABCDE
 }
 ```
 
-
-
 ### <span id="Debounced">Debounced</span>
 
 <p>创建一个debounced函数，该函数延迟调用fn直到自上次调用debounced函数后等待持续时间过去。</p>
@@ -207,7 +194,8 @@ func main() {
 ```go
 func Debounced(fn func(), duration time.Duration) func()
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -218,28 +206,35 @@ import (
 )
 
 func main() {
-	count := 0
-	add := func() {
-		count++
-	}
+    count := 0
 
-	debouncedAdd := function.Debounced(add, 50*time.Microsecond)
-	function.debouncedAdd()
-	function.debouncedAdd()
-	function.debouncedAdd()
-	function.debouncedAdd()
+    add := func() {
+        count++
+    }
 
-	time.Sleep(100 * time.Millisecond)
-	fmt.Println(count) //1
+    debouncedAdd := function.Debounced(add, 50*time.Microsecond)
 
-	function.debouncedAdd()
-	time.Sleep(100 * time.Millisecond)
-	fmt.Println(count) //2
+    debouncedAdd()
+    debouncedAdd()
+    debouncedAdd()
+    debouncedAdd()
+
+    time.Sleep(100 * time.Millisecond)
+
+    fmt.Println(count)
+
+    debouncedAdd()
+
+    time.Sleep(100 * time.Millisecond)
+
+    fmt.Println(count)
+
+    // Output:
+    // 1
+    // 2
 }
 ```
 
-
-
 ### <span id="Delay">Delay</span>
 
 <p>延迟delay时间后调用函数</p>
@@ -249,7 +244,8 @@ func main() {
 ```go
 func Delay(delay time.Duration, fn any, args ...any)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -260,15 +256,17 @@ import (
 )
 
 func main() {
-	var print = func(s string) {
-		fmt.Println(count) //test delay
-	}
-	function.Delay(2*time.Second, print, "test delay")
+    var print = func(s string) {
+        fmt.Println(s)
+    }
+
+    function.Delay(2*time.Second, print, "hello")
+
+    // Output:
+    // hello
 }
 ```
 
-
-
 ### <span id="Schedule">Schedule</span>
 
 <p>每次持续时间调用函数，直到关闭返回的 bool chan</p>
@@ -278,7 +276,8 @@ func main() {
 ```go
 func Schedule(d time.Duration, fn any, args ...any) chan bool
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -289,21 +288,24 @@ import (
 )
 
 func main() {
-    var res []string
-	appendStr := func(s string) {
-		res = append(res, s)
-	}
+    count := 0
 
-	stop := function.Schedule(1*time.Second, appendStr, "*")
-	time.Sleep(5 * time.Second)
-	close(stop)
+    increase := func() {
+        count++
+    }
 
-	fmt.Println(res) //[* * * * *]
+    stop := function.Schedule(2*time.Second, increase)
+
+    time.Sleep(2 * time.Second)
+    close(stop)
+
+    fmt.Println(count)
+
+    // Output:
+    // 2
 }
 ```
 
-
-
 ### <span id="Pipeline">Pipeline</span>
 
 <p>执行函数pipeline.</p>
@@ -313,7 +315,8 @@ func main() {
 ```go
 func Pipeline[T any](funcs ...func(T) T) func(T) T
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -325,23 +328,26 @@ import (
 
 func main() {
     addOne := func(x int) int {
-		return x + 1
-	}
-	double := func(x int) int {
-		return 2 * x
-	}
-	square := func(x int) int {
-		return x * x
-	}
+        return x + 1
+    }
+    double := func(x int) int {
+        return 2 * x
+    }
+    square := func(x int) int {
+        return x * x
+    }
 
-	f := Pipeline(addOne, double, square)
+    fn := function.Pipeline(addOne, double, square)
 
-	fmt.Println(fn(2)) //36
+    result := fn(2)
+
+    fmt.Println(result)
+
+    // Output:
+    // 36
 }
 ```
 
-
-
 ### <span id="Watcher">Watcher</span>
 
 <p>Watcher用于记录代码执行时间。可以启动/停止/重置手表定时器。获取函数执行的时间。</p>
@@ -350,9 +356,9 @@ func main() {
 
 ```go
 type Watcher struct {
-	startTime int64
-	stopTime  int64
-	excuting  bool
+    startTime int64
+    stopTime  int64
+    excuting  bool
 }
 func NewWatcher() *Watcher
 func (w *Watcher) Start() //start the watcher
@@ -360,7 +366,8 @@ func (w *Watcher) Stop() //stop the watcher
 func (w *Watcher) Reset() //reset the watcher
 func (w *Watcher) GetElapsedTime() time.Duration //get the elapsed time of function execution
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -373,30 +380,27 @@ import (
 func main() {
     w := function.NewWatcher()
 
-	w.Start()
+    w.Start()
 
-	longRunningTask()
+    longRunningTask()
 
-	fmt.Println(w.excuting) //true
+    fmt.Println(w.excuting) //true
 
-	w.Stop()
+    w.Stop()
 
-	eapsedTime := w.GetElapsedTime().Milliseconds()
-	
-	fmt.Println(eapsedTime)
+    eapsedTime := w.GetElapsedTime().Milliseconds()
 
-	w.Reset()
+    fmt.Println(eapsedTime)
+
+    w.Reset()
 
 }
 
 func longRunningTask() {
-	var slice []int64
-	for i := 0; i < 10000000; i++ {
-		slice = append(slice, int64(i))
-	}
+    var slice []int64
+    for i := 0; i < 10000000; i++ {
+        slice = append(slice, int64(i))
+    }
 }
 
 ```
-
-
-

docs/pointer.md

@@ -0,0 +1,229 @@
+# Pointer
+
+pointer contains some util functions to operate go pointer.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+-   [https://github.com/duke-git/lancet/blob/main/pointer/pointer.go](https://github.com/duke-git/lancet/blob/main/pointer/pointer.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/pointer"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+-   [Of](#Of)
+-   [Unwrap](#Unwrap)
+-   [UnwarpOr](#UnwarpOr)
+-   [UnwarpOrDefault](#UnwarpOrDefault)
+-   [ExtractPointer](#ExtractPointer)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### <span id="Of">Of</span>
+
+<p>Returns a pointer to the pass value `v`.</p>
+
+<b>Signature:</b>
+
+```go
+func Of[T any](v T) *T
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    result1 := pointer.Of(123)
+    result2 := pointer.Of("abc")
+
+    fmt.Println(*result1)
+    fmt.Println(*result2)
+
+    // Output:
+    // 123
+    // abc
+}
+```
+
+
+### <span id="Unwrap">Unwrap</span>
+
+<p>Returns the value from the pointer.</p>
+
+<b>Signature:</b>
+
+```go
+func Unwrap[T any](p *T) T
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    a := 123
+    b := "abc"
+
+    result1 := pointer.Unwrap(&a)
+    result2 := pointer.Unwrap(&b)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 123
+    // abc
+}
+```
+
+
+### <span id="UnwarpOr">UnwarpOr</span>
+
+<p>Returns the value from the pointer or fallback if the pointer is nil.</p>
+
+<b>Signature:</b>
+```go
+UnwarpOr[T any](p *T, fallback T) T
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+	a := 123
+	b := "abc"
+
+	var c *int
+	var d *string
+
+	result1 := pointer.UnwarpOr(&a, 456)
+	result2 := pointer.UnwarpOr(&b, "abc")
+	result3 := pointer.UnwarpOr(c, 456)
+	result4 := pointer.UnwarpOr(d, "def")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// 123
+	// abc
+	// 456
+	// def
+}
+```
+
+
+### <span id="UnwarpOrDefault">UnwarpOrDefault</span>
+
+<p>Returns the value from the pointer or the default value if the pointer is nil.</p>
+
+<b>Signature:</b>
+```go
+UnwarpOrDefault[T any](p *T) T
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+	a := 123
+	b := "abc"
+
+	var c *int
+	var d *string
+
+	result1 := pointer.UnwarpOrDefault(&a)
+	result2 := pointer.UnwarpOrDefault(&b)
+	result3 := pointer.UnwarpOrDefault(c)
+	result4 := pointer.UnwarpOrDefault(d)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// 123
+	// abc
+	// 0
+	//
+}
+```
+
+
+### <span id="ExtractPointer">ExtractPointer</span>
+
+<p>Returns the underlying value by the given interface type</p>
+
+<b>Signature:</b>
+
+```go
+func ExtractPointer(value any) any
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    a := 1
+    b := &a
+    c := &b
+    d := &c
+
+    result := pointer.ExtractPointer(d)
+
+    fmt.Println(result)
+
+    // Output:
+    // 1
+}
+```

docs/pointer_zh-CN.md

@@ -0,0 +1,227 @@
+# Pointer
+
+pointer 包支持一些指针类型的操作。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/pointer/pointer.go](https://github.com/duke-git/lancet/blob/main/pointer/pointer.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/pointer"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [Of](#Of)
+-   [Unwrap](#Unwrap)
+-   [ExtractPointer](#ExtractPointer)
+-   [UnwarpOr](#UnwarpOr)
+-   [UnwarpOrDefault](#UnwarpOrDefault)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="Of">Of</span>
+
+<p>返回传入参数的指针值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Of[T any](v T) *T
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    result1 := pointer.Of(123)
+    result2 := pointer.Of("abc")
+
+    fmt.Println(*result1)
+    fmt.Println(*result2)
+
+    // Output:
+    // 123
+    // abc
+}
+```
+
+### <span id="Unwrap">Unwrap</span>
+
+<p>返回传入指针指向的值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Unwrap[T any](p *T) T
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    a := 123
+    b := "abc"
+
+    result1 := pointer.Unwrap(&a)
+    result2 := pointer.Unwrap(&b)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 123
+    // abc
+}
+```
+
+### <span id="ExtractPointer">ExtractPointer</span>
+
+<p>返回传入interface的底层值。</p>
+
+<b>函数签名:</b>
+
+```go
+func ExtractPointer(value any) any
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    a := 1
+    b := &a
+    c := &b
+    d := &c
+
+    result := pointer.ExtractPointer(d)
+
+    fmt.Println(result)
+
+    // Output:
+    // 1
+}
+```
+
+### <span id="UnwarpOr">UnwarpOr</span>
+
+<p>返回指针的值，如果指针为零值，则返回fallback。</p>
+
+<b>函数签名:</b>
+
+```go
+UnwarpOr[T any](p *T, fallback T) T
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+	a := 123
+	b := "abc"
+
+	var c *int
+	var d *string
+
+	result1 := pointer.UnwarpOr(&a, 456)
+	result2 := pointer.UnwarpOr(&b, "abc")
+	result3 := pointer.UnwarpOr(c, 456)
+	result4 := pointer.UnwarpOr(d, "def")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// 123
+	// abc
+	// 456
+	// def
+}
+```
+
+### <span id="UnwarpOrDefault">UnwarpOrDefault</span>
+
+<p>返回指针的值，如果指针为零值，则返回相应零值。</p>
+
+<b>函数签名:</b>
+
+```go
+UnwarpOrDefault[T any](p *T) T
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+	a := 123
+	b := "abc"
+
+	var c *int
+	var d *string
+
+	result1 := pointer.UnwarpOrDefault(&a)
+	result2 := pointer.UnwarpOrDefault(&b)
+	result3 := pointer.UnwarpOrDefault(c)
+	result4 := pointer.UnwarpOrDefault(d)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// 123
+	// abc
+	// 0
+	//
+}
+```

docs/random.md

@@ -30,6 +30,7 @@ import (
 -   [RandNumeral](#RandNumeral)
 -   [RandNumeralOrLetter](#RandNumeralOrLetter)
 -   [UUIdV4](#UUIdV4)
+-   [RandUniqueIntSlice](#RandUniqueIntSlice)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -56,8 +57,8 @@ import (
 )
 
 func main() {
-	randBytes := random.RandBytes(4)
-	fmt.Println(randBytes)
+    randBytes := random.RandBytes(4)
+    fmt.Println(randBytes)
 }
 ```
 
@@ -82,8 +83,8 @@ import (
 )
 
 func main() {
-	rInt := random.RandInt(1, 10)
-	fmt.Println(rInt)
+    rInt := random.RandInt(1, 10)
+    fmt.Println(rInt)
 }
 ```
 
@@ -108,8 +109,8 @@ import (
 )
 
 func main() {
-	randStr := random.RandString(6)
-	fmt.Println(randStr) //pGWsze
+    randStr := random.RandString(6)
+    fmt.Println(randStr) //pGWsze
 }
 ```
 
@@ -134,8 +135,8 @@ import (
 )
 
 func main() {
-	randStr := random.RandString(6)
-	fmt.Println(randStr) //PACWGF
+    randStr := random.RandString(6)
+    fmt.Println(randStr) //PACWGF
 }
 ```
 
@@ -160,8 +161,8 @@ import (
 )
 
 func main() {
-	randStr := random.RandLower(6)
-	fmt.Println(randStr) //siqbew
+    randStr := random.RandLower(6)
+    fmt.Println(randStr) //siqbew
 }
 ```
 
@@ -186,8 +187,8 @@ import (
 )
 
 func main() {
-	randStr := random.RandNumeral(6)
-	fmt.Println(randStr) //035172
+    randStr := random.RandNumeral(6)
+    fmt.Println(randStr) //035172
 }
 ```
 
@@ -212,8 +213,8 @@ import (
 )
 
 func main() {
-	randStr := random.RandNumeralOrLetter(6)
-	fmt.Println(randStr) //0aW7cQ
+    randStr := random.RandNumeralOrLetter(6)
+    fmt.Println(randStr) //0aW7cQ
 }
 ```
 
@@ -238,10 +239,37 @@ import (
 )
 
 func main() {
-	uuid, err := random.UUIdV4()
+    uuid, err := random.UUIdV4()
     if err != nil {
         return
     }
-	fmt.Println(uuid)
+    fmt.Println(uuid)
+}
+```
+
+
+### <span id="RandUniqueIntSlice">RandUniqueIntSlice</span>
+
+<p>Generate a slice of random int of length n that do not repeat.</p>
+
+<b>Signature:</b>
+
+```go
+func RandUniqueIntSlice(n, min, max int) []int
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    result := random.RandUniqueIntSlice(5, 0, 10)
+    fmt.Println(result) //[0 4 7 1 5] (random)
 }
 ```

docs/random_zh-CN.md

@@ -30,6 +30,7 @@ import (
 -   [RandNumeral](#RandNumeral)
 -   [RandNumeralOrLetter](#RandNumeralOrLetter)
 -   [UUIdV4](#UUIdV4)
+-   [RandUniqueIntSlice](#RandUniqueIntSlice)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -45,7 +46,7 @@ import (
 func RandBytes(length int) []byte
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -56,8 +57,8 @@ import (
 )
 
 func main() {
-	randBytes := random.RandBytes(4)
-	fmt.Println(randBytes)
+    randBytes := random.RandBytes(4)
+    fmt.Println(randBytes)
 }
 ```
 
@@ -71,7 +72,7 @@ func main() {
 func RandInt(min, max int) int
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -82,8 +83,8 @@ import (
 )
 
 func main() {
-	rInt := random.RandInt(1, 10)
-	fmt.Println(rInt)
+    rInt := random.RandInt(1, 10)
+    fmt.Println(rInt)
 }
 ```
 
@@ -97,7 +98,7 @@ func main() {
 func RandString(length int) string
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -108,8 +109,8 @@ import (
 )
 
 func main() {
-	randStr := random.RandString(6)
-	fmt.Println(randStr) //pGWsze
+    randStr := random.RandString(6)
+    fmt.Println(randStr) //pGWsze
 }
 ```
 
@@ -123,7 +124,7 @@ func main() {
 func RandUpper(length int) string
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -134,8 +135,8 @@ import (
 )
 
 func main() {
-	randStr := random.RandString(6)
-	fmt.Println(randStr) //PACWGF
+    randStr := random.RandString(6)
+    fmt.Println(randStr) //PACWGF
 }
 ```
 
@@ -149,7 +150,7 @@ func main() {
 func RandLower(length int) string
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -160,8 +161,8 @@ import (
 )
 
 func main() {
-	randStr := random.RandLower(6)
-	fmt.Println(randStr) //siqbew
+    randStr := random.RandLower(6)
+    fmt.Println(randStr) //siqbew
 }
 ```
 
@@ -175,7 +176,7 @@ func main() {
 func RandNumeral(length int) string
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -186,8 +187,8 @@ import (
 )
 
 func main() {
-	randStr := random.RandNumeral(6)
-	fmt.Println(randStr) //035172
+    randStr := random.RandNumeral(6)
+    fmt.Println(randStr) //035172
 }
 ```
 
@@ -201,7 +202,7 @@ func main() {
 func RandNumeralOrLetter(length int) string
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -212,8 +213,8 @@ import (
 )
 
 func main() {
-	randStr := random.RandNumeralOrLetter(6)
-	fmt.Println(randStr) //0aW7cQ
+    randStr := random.RandNumeralOrLetter(6)
+    fmt.Println(randStr) //0aW7cQ
 }
 ```
 
@@ -227,7 +228,7 @@ func main() {
 func UUIdV4() (string, error)
 ```
 
-<b>例子:</b>
+<b>示例:</b>
 
 ```go
 package main
@@ -238,10 +239,36 @@ import (
 )
 
 func main() {
-	uuid, err := random.UUIdV4()
+    uuid, err := random.UUIdV4()
     if err != nil {
         return
     }
-	fmt.Println(uuid)
+    fmt.Println(uuid)
+}
+```
+
+### <span id="RandUniqueIntSlice">RandUniqueIntSlice</span>
+
+<p>生成一个不重复的长度为n的随机int切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandUniqueIntSlice(n, min, max int) []int
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    result := random.RandUniqueIntSlice(5, 0, 10)
+    fmt.Println(result) //[0 4 7 1 5] (random)
 }
 ```

docs/retry.md

@@ -1,16 +1,17 @@
 # Retry
+
 Package retry is for executing a function repeatedly until it was successful or canceled by the context.
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Source:
 
-- [https://github.com/duke-git/lancet/blob/main/retry/retry.go](https://github.com/duke-git/lancet/blob/main/retry/retry.go)
-
+-   [https://github.com/duke-git/lancet/blob/main/retry/retry.go](https://github.com/duke-git/lancet/blob/main/retry/retry.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/retry"
@@ -20,18 +21,19 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## Index
-- [Context](#Context)
-- [Retry](#Retry)
-- [RetryFunc](#RetryFunc)
-- [RetryDuration](#RetryDuration)
-- [RetryTimes](#RetryTimes)
+
+-   [Context](#Context)
+-   [Retry](#Retry)
+-   [RetryFunc](#RetryFunc)
+-   [RetryDuration](#RetryDuration)
+-   [RetryTimes](#RetryTimes)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
-
 ### <span id="Context">Context</span>
+
 <p>Set retry context config, can cancel the retry with context.</p>
 
 <b>Signature:</b>
@@ -39,43 +41,46 @@ import (
 ```go
 func Context(ctx context.Context)
 ```
+
 <b>Example:</b>
 
 ```go
 import (
-	"context"
-	"errors"
-	"fmt"
-	"github.com/duke-git/lancet/v2/retry"
-	"time"
+    "context"
+    "errors"
+    "fmt"
+    "github.com/duke-git/lancet/v2/retry"
+    "time"
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.TODO())
-	var number int
-	increaseNumber := func() error {
-		number++
-		if number > 3 {
-			cancel()
-		}
-		return errors.New("error occurs")
-	}
+    ctx, cancel := context.WithCancel(context.TODO())
 
-	err := retry.Retry(increaseNumber,
-		retry.RetryDuration(time.Microsecond*50),
-		retry.Context(ctx),
-	)
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number > 3 {
+            cancel()
+        }
+        return errors.New("error occurs")
+    }
 
-	if err != nil {
-		fmt.Println(err) //retry is cancelled
-	}
+    duration := retry.RetryDuration(time.Microsecond*50)
+
+    retry.Retry(increaseNumber,
+        duration,
+        retry.Context(ctx),
+    )
+
+    fmt.Println(number)
+
+    // Output:
+    // 4
 }
 ```
 
-
-
-
 ### <span id="RetryFunc">RetryFunc</span>
+
 <p>Function that retry executes.</p>
 
 <b>Signature:</b>
@@ -83,6 +88,7 @@ func main() {
 ```go
 type RetryFunc func() error
 ```
+
 <b>Example:</b>
 
 ```go
@@ -96,28 +102,31 @@ import (
 )
 
 func main() {
-    var number int
+    number := 0
+    var increaseNumber retry.RetryFunc = func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
 
-	increaseNumber := func() error {
-		number++
-		if number == 3 {
-			return nil
-		}
-		return errors.New("error occurs")
-	}
+    duration := retry.RetryDuration(time.Microsecond*50)
 
-	err := retry.Retry(increaseNumber, retry.RetryDuration(time.Microsecond*50))
+    err := retry.Retry(increaseNumber, duration)
     if err != nil {
-		log.Fatal(err)
-	}
+        return
+    }
 
-    fmt.Println(number) //3
+    fmt.Println(number)
+
+    // Output:
+    // 3
 }
 ```
 
-
-
 ### <span id="RetryTimes">RetryTimes</span>
+
 <p>Set times of retry. Default times is 5.</p>
 
 <b>Signature:</b>
@@ -125,6 +134,7 @@ func main() {
 ```go
 func RetryTimes(n uint)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -138,26 +148,28 @@ import (
 )
 
 func main() {
-    var number int
+    number := 0
 
-	increaseNumber := func() error {
-		number++
-		if number == 3 {
-			return nil
-		}
-		return errors.New("error occurs")
-	}
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
 
-	err := retry.Retry(increaseNumber, retry.RetryTimes(2))
+    err := retry.Retry(increaseNumber, retry.RetryTimes(2))
     if err != nil {
-		log.Fatal(err) //2022/02/01 18:42:25 function main.main.func1 run failed after 2 times retry exit status 1
-	}
+        fmt.Println(err)
+    }
+
+    // Output:
+    // function main.main.func1 run failed after 2 times retry
 }
 ```
 
-
-
 ### <span id="RetryDuration">RetryDuration</span>
+
 <p>Set duration of retries. Default duration is 3 second.</p>
 
 <b>Signature:</b>
@@ -165,6 +177,7 @@ func main() {
 ```go
 func RetryDuration(d time.Duration)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -178,26 +191,31 @@ import (
 )
 
 func main() {
-    var number int
-	increaseNumber := func() error {
-		number++
-		if number == 3 {
-			return nil
-		}
-		return errors.New("error occurs")
-	}
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
 
-	err := retry.Retry(increaseNumber, retry.RetryDuration(time.Microsecond*50))
+    duration := retry.RetryDuration(time.Microsecond*50)
+
+    err := retry.Retry(increaseNumber, duration)
     if err != nil {
-		log.Fatal(err)
-	}
+        return
+    }
 
-    fmt.Println(number) //3
+    fmt.Println(number)
+
+    // Output:
+    // 3
 }
 ```
 
-
 ### <span id="Retry">Retry</span>
+
 <p>Executes the retryFunc repeatedly until it was successful or canceled by the context.</p>
 
 <b>Signature:</b>
@@ -205,6 +223,7 @@ func main() {
 ```go
 func Retry(retryFunc RetryFunc, opts ...Option) error
 ```
+
 <b>Example:</b>
 
 ```go
@@ -218,20 +237,25 @@ import (
 )
 
 func main() {
-    var number int
-	increaseNumber := func() error {
-		number++
-		if number == 3 {
-			return nil
-		}
-		return errors.New("error occurs")
-	}
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
 
-	err := retry.Retry(increaseNumber, retry.RetryDuration(time.Microsecond*50))
+    duration := retry.RetryDuration(time.Microsecond*50)
+
+    err := retry.Retry(increaseNumber, duration)
     if err != nil {
-		log.Fatal(err)
-	}
+        return
+    }
 
-    fmt.Println(number) //3
+    fmt.Println(number)
+
+    // Output:
+    // 3
 }
 ```

docs/retry_zh-CN.md

@@ -1,16 +1,17 @@
 # Retry
-retry重试执行函数直到函数运行成功或被context cancel。
+
+retry 重试执行函数直到函数运行成功或被 context cancel。
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码:
 
-- [https://github.com/duke-git/lancet/blob/main/retry/retry.go](https://github.com/duke-git/lancet/blob/main/retry/retry.go)
-
+-   [https://github.com/duke-git/lancet/blob/main/retry/retry.go](https://github.com/duke-git/lancet/blob/main/retry/retry.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 用法:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/retry"
@@ -20,20 +21,19 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## 目录
-- [Context](#Context)
-- [Retry](#Retry)
-- [RetryFunc](#RetryFunc)
-- [RetryDuration](#RetryDuration)
-- [RetryTimes](#RetryTimes)
 
+-   [Context](#Context)
+-   [Retry](#Retry)
+-   [RetryFunc](#RetryFunc)
+-   [RetryDuration](#RetryDuration)
+-   [RetryTimes](#RetryTimes)
 
 <div STYLE="page-break-after: always;"></div>
 
-
-## Document文档
-
+## Document 文档
 
 ### <span id="Context">Context</span>
+
 <p>设置重试context参数</p>
 
 <b>函数签名:</b>
@@ -41,43 +41,46 @@ import (
 ```go
 func Context(ctx context.Context)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 import (
-	"context"
-	"errors"
-	"fmt"
-	"lancet-demo/retry"
-	"time"
+    "context"
+    "errors"
+    "fmt"
+    "lancet-demo/retry"
+    "time"
 )
 
 func main() {
-	ctx, cancel := context.WithCancel(context.TODO())
-	var number int
-	increaseNumber := func() error {
-		number++
-		if number > 3 {
-			cancel()
-		}
-		return errors.New("error occurs")
-	}
+    ctx, cancel := context.WithCancel(context.TODO())
 
-	err := retry.Retry(increaseNumber,
-		retry.RetryDuration(time.Microsecond*50),
-		retry.Context(ctx),
-	)
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number > 3 {
+            cancel()
+        }
+        return errors.New("error occurs")
+    }
 
-	if err != nil {
-		fmt.Println(err) //retry is cancelled
-	}
+    duration := retry.RetryDuration(time.Microsecond*50)
+
+    retry.Retry(increaseNumber,
+        duration,
+        retry.Context(ctx),
+    )
+
+    fmt.Println(number)
+
+    // Output:
+    // 4
 }
 ```
 
-
-
-
 ### <span id="RetryFunc">RetryFunc</span>
+
 <p>被重试执行的函数</p>
 
 <b>函数签名:</b>
@@ -85,7 +88,8 @@ func main() {
 ```go
 type RetryFunc func() error
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -98,27 +102,31 @@ import (
 )
 
 func main() {
-    var number int
-	increaseNumber := func() error {
-		number++
-		if number == 3 {
-			return nil
-		}
-		return errors.New("error occurs")
-	}
+    number := 0
+    var increaseNumber retry.RetryFunc = func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
 
-	err := retry.Retry(increaseNumber, retry.RetryDuration(time.Microsecond*50))
+    duration := retry.RetryDuration(time.Microsecond*50)
+
+    err := retry.Retry(increaseNumber, duration)
     if err != nil {
-		log.Fatal(err)
-	}
+        return
+    }
 
-    fmt.Println(number) //3
+    fmt.Println(number)
+
+    // Output:
+    // 3
 }
 ```
 
-
-
 ### <span id="RetryTimes">RetryTimes</span>
+
 <p>设置重试次数，默认5</p>
 
 <b>函数签名:</b>
@@ -126,7 +134,8 @@ func main() {
 ```go
 func RetryTimes(n uint)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -139,25 +148,28 @@ import (
 )
 
 func main() {
-    var number int
-	increaseNumber := func() error {
-		number++
-		if number == 3 {
-			return nil
-		}
-		return errors.New("error occurs")
-	}
+    number := 0
 
-	err := retry.Retry(increaseNumber, retry.RetryTimes(2))
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    err := retry.Retry(increaseNumber, retry.RetryTimes(2))
     if err != nil {
-		log.Fatal(err) //2022/02/01 18:42:25 function main.main.func1 run failed after 2 times retry exit status 1
-	}
+        fmt.Println(err)
+    }
+
+    // Output:
+    // function main.main.func1 run failed after 2 times retry
 }
 ```
 
-
-
 ### <span id="RetryDuration">RetryDuration</span>
+
 <p>设置重试间隔时间，默认3秒</p>
 
 <b>函数签名:</b>
@@ -165,7 +177,8 @@ func main() {
 ```go
 func RetryDuration(d time.Duration)
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -178,26 +191,31 @@ import (
 )
 
 func main() {
-    var number int
-	increaseNumber := func() error {
-		number++
-		if number == 3 {
-			return nil
-		}
-		return errors.New("error occurs")
-	}
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
 
-	err := retry.Retry(increaseNumber, retry.RetryDuration(time.Microsecond*50))
+    duration := retry.RetryDuration(time.Microsecond*50)
+
+    err := retry.Retry(increaseNumber, duration)
     if err != nil {
-		log.Fatal(err)
-	}
+        return
+    }
 
-    fmt.Println(number) //3
+    fmt.Println(number)
+
+    // Output:
+    // 3
 }
 ```
 
-
 ### <span id="Retry">Retry</span>
+
 <p>重试执行函数retryFunc，直到函数运行成功，或被context停止</p>
 
 <b>函数签名:</b>
@@ -205,7 +223,8 @@ func main() {
 ```go
 func Retry(retryFunc RetryFunc, opts ...Option) error
 ```
-<b>例子:</b>
+
+<b>示例:</b>
 
 ```go
 package main
@@ -218,20 +237,25 @@ import (
 )
 
 func main() {
-    var number int
-	increaseNumber := func() error {
-		number++
-		if number == 3 {
-			return nil
-		}
-		return errors.New("error occurs")
-	}
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
 
-	err := retry.Retry(increaseNumber, retry.RetryDuration(time.Microsecond*50))
+    duration := retry.RetryDuration(time.Microsecond*50)
+
+    err := retry.Retry(increaseNumber, duration)
     if err != nil {
-		log.Fatal(err)
-	}
+        return
+    }
 
-    fmt.Println(number) //3
+    fmt.Println(number)
+
+    // Output:
+    // 3
 }
 ```

docs/stream.md

@@ -0,0 +1,940 @@
+# Stream
+
+Package stream implements a sequence of elements supporting sequential and operations. This package is an experiment to explore if stream in go can work as the way java does. it's feature is very limited.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+-   [https://github.com/duke-git/lancet/blob/main/stream/stream.go](https://github.com/duke-git/lancet/blob/main/stream/stream.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/stream"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+-   [Of](#Of)
+-   [FromSlice](#FromSlice)
+-   [FromChannel](#FromChannel)
+-   [FromRange](#FromRange)
+-   [Generate](#Generate)
+-   [Concat](#Concat)
+-   [Distinct](#Distinct)
+-   [Filter](#Filter)
+-   [Map](#Map)
+-   [Peek](#Peek)
+-   [Skip](#Skip)
+-   [Limit](#Limit)
+-   [Reverse](#Reverse)
+-   [Range](#Range)
+-   [Sorted](#Sorted)
+-   [ForEach](#ForEach)
+-   [Reduce](#Reduce)
+-   [FindFirst](#FindFirst)
+-   [FindLast](#FindLast)
+-   [Max](#Max)
+-   [Min](#Min)
+-   [AllMatch](#AllMatch)
+-   [AnyMatch](#AnyMatch)
+-   [NoneMatch](#NoneMatch)
+-   [Count](#Count)
+-   [ToSlice](#ToSlice)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### <span id="Of">Of</span>
+
+<p>Creates a stream whose elements are the specified values.</p>
+
+<b>Signature:</b>
+
+```go
+func Of[T any](elems ...T) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    s := stream.Of(1, 2, 3)
+
+    data := s.ToSlice()
+
+    fmt.Println(data)
+
+    // Output:
+    // [1 2 3]
+}
+```
+
+### <span id="FromSlice">FromSlice</span>
+
+<p>Creates a stream from slice.</p>
+
+<b>Signature:</b>
+
+```go
+func FromSlice[T any](source []T) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    s := stream.FromSlice([]int{1, 2, 3})
+
+    data := s.ToSlice()
+
+    fmt.Println(data)
+
+    // Output:
+    // [1 2 3]
+}
+```
+
+### <span id="FromChannel">FromChannel</span>
+
+<p>Creates a stream from channel.</p>
+
+<b>Signature:</b>
+
+```go
+func FromChannel[T any](source <-chan T) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    ch := make(chan int)
+    go func() {
+        for i := 1; i < 4; i++ {
+            ch <- i
+        }
+        close(ch)
+    }()
+
+    s := stream.FromChannel(ch)
+
+    data := s.ToSlice()
+
+    fmt.Println(data)
+
+    // Output:
+    // [1 2 3]
+}
+```
+
+### <span id="FromRange">FromRange</span>
+
+<p>Creates a number stream from start to end. both start and end are included. [start, end]</p>
+
+<b>Signature:</b>
+
+```go
+func FromRange[T constraints.Integer | constraints.Float](start, end, step T) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    s := stream.FromRange(1, 5, 1)
+
+    data := s.ToSlice()
+    fmt.Println(data)
+
+    // Output:
+    // [1 2 3 4 5]
+}
+```
+
+### <span id="Generate">Generate</span>
+
+<p>Creates a stream where each element is generated by the provided generater function.</p>
+
+<b>Signature:</b>
+
+```go
+func Generate[T any](generator func() func() (item T, ok bool)) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    n := 0
+    max := 4
+
+    generator := func() func() (int, bool) {
+        return func() (int, bool) {
+            n++
+            return n, n < max
+        }
+    }
+
+    s := stream.Generate(generator)
+
+    data := s.ToSlice()
+
+    fmt.Println(data)
+
+    // Output:
+    // [1 2 3]
+}
+```
+
+### <span id="Concat">Concat</span>
+
+<p>Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.</p>
+
+<b>Signature:</b>
+
+```go
+func Concat[T any](a, b stream[T]) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    s1 := stream.FromSlice([]int{1, 2, 3})
+    s2 := stream.FromSlice([]int{4, 5, 6})
+
+    s := Concat(s1, s2)
+
+    data := s.ToSlice()
+
+    fmt.Println(data)
+
+    // Output:
+    // [1 2 3 4 5 6]
+}
+```
+
+### <span id="Distinct">Distinct</span>
+
+<p>Creates returns a stream that removes the duplicated items. <b>Support chainable operation</b></p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Distinct() stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 2, 3, 3, 3})
+    distinct := original.Distinct()
+
+    data1 := original.ToSlice()
+    data2 := distinct.ToSlice()
+
+    fmt.Println(data1)
+    fmt.Println(data2)
+
+    // Output:
+    // [1 2 2 3 3 3]
+    // [1 2 3]
+}
+```
+
+### <span id="Filter">Filter</span>
+
+<p>Returns a stream consisting of the elements of this stream that match the given predicate. <b>Support chainable operation</b></p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Filter(predicate func(item T) bool) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3, 4, 5})
+
+    isEven := func(n int) bool {
+        return n%2 == 0
+    }
+
+    even := original.Filter(isEven)
+
+    fmt.Println(even.ToSlice())
+
+    // Output:
+    // [2 4]
+}
+```
+
+### <span id="Map">Map</span>
+
+<p>Returns a stream consisting of the elements of this stream that apply the given function to elements of stream. <b>Support chainable operation</b></p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Map(mapper func(item T) T) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3})
+
+    addOne := func(n int) int {
+        return n + 1
+    }
+
+    increament := original.Map(addOne)
+
+    fmt.Println(increament.ToSlice())
+
+    // Output:
+    // [2 3 4]
+}
+```
+
+### <span id="Peek">Peek</span>
+
+<p>Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream. <b>Support chainable operation</b></p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Peek(consumer func(item T)) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3})
+
+    data := []string{}
+    peekStream := original.Peek(func(n int) {
+        data = append(data, fmt.Sprint("value", n))
+    })
+
+    fmt.Println(original.ToSlice())
+    fmt.Println(peekStream.ToSlice())
+    fmt.Println(data)
+
+    // Output:
+    // [1 2 3]
+    // [1 2 3]
+    // [value1 value2 value3]
+}
+```
+
+### <span id="Skip">Skip</span>
+
+<p>Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream. If this stream contains fewer than n elements then an empty stream will be returned. <b>Support chainable operation</b></p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Skip(n int) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3, 4})
+
+    s1 := original.Skip(-1)
+    s2 := original.Skip(0)
+    s3 := original.Skip(1)
+    s4 := original.Skip(5)
+
+    fmt.Println(s1.ToSlice())
+    fmt.Println(s2.ToSlice())
+    fmt.Println(s3.ToSlice())
+    fmt.Println(s4.ToSlice())
+
+    // Output:
+    // [1 2 3 4]
+    // [1 2 3 4]
+    // [2 3 4]
+    // []
+}
+```
+
+### <span id="Limit">Limit</span>
+
+<p>Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length. <b>Support chainable operation</b></p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Limit(maxSize int) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3, 4})
+
+    s1 := original.Limit(-1)
+    s2 := original.Limit(0)
+    s3 := original.Limit(1)
+    s4 := original.Limit(5)
+
+    fmt.Println(s1.ToSlice())
+    fmt.Println(s2.ToSlice())
+    fmt.Println(s3.ToSlice())
+    fmt.Println(s4.ToSlice())
+
+    // Output:
+    // []
+    // []
+    // [1]
+    // [1 2 3 4]
+}
+```
+
+### <span id="Reverse">Reverse</span>
+
+<p>Returns a stream whose elements are reverse order of given stream. <b>Support chainable operation</b></p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Reverse() stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3})
+
+    reverse := original.Reverse()
+
+    fmt.Println(reverse.ToSlice())
+
+    // Output:
+    // [3 2 1]
+}
+```
+
+### <span id="Range">Range</span>
+
+<p>Returns a stream whose elements are in the range from start(included) to end(excluded) original stream.<b>Support chainable operation</b></p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Range(start, end int) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3})
+
+    s1 := original.Range(0, 0)
+    s2 := original.Range(0, 1)
+    s3 := original.Range(0, 3)
+    s4 := original.Range(1, 2)
+
+    fmt.Println(s1.ToSlice())
+    fmt.Println(s2.ToSlice())
+    fmt.Println(s3.ToSlice())
+    fmt.Println(s4.ToSlice())
+
+    // Output:
+    // []
+    // [1]
+    // [1 2 3]
+    // [2]
+}
+```
+
+### <span id="Sorted">Sorted</span>
+
+<p>Returns a stream consisting of the elements of this stream, sorted according to the provided less function.<b>Support chainable operation</b></p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Sorted(less func(a, b T) bool) stream[T]
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{4, 2, 1, 3})
+
+    sorted := original.Sorted(func(a, b int) bool { return a < b })
+
+    fmt.Println(original.ToSlice())
+    fmt.Println(sorted.ToSlice())
+
+    // Output:
+    // [4 2 1 3]
+    // [1 2 3 4]
+}
+```
+
+### <span id="ForEach">ForEach</span>
+
+<p>Performs an action for each element of this stream.</p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) ForEach(action func(item T))
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3})
+
+    result := 0
+    original.ForEach(func(item int) {
+        result += item
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // 6
+}
+```
+
+### <span id="Reduce">Reduce</span>
+
+<p>Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any.</p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Reduce(initial T, accumulator func(a, b T) T) T
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3})
+
+    result := original.Reduce(0, func(a, b int) int {
+        return a + b
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // 6
+}
+```
+
+### <span id="FindFirst">FindFirst</span>
+
+<p>Returns the first element of this stream and true, or zero value and false if the stream is empty.</p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) FindFirst() (T, bool)
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3})
+
+    result, ok := original.FindFirst()
+
+    fmt.Println(result)
+    fmt.Println(ok)
+
+    // Output:
+    // 1
+    // true
+}
+```
+
+### <span id="FindLast">FindLast</span>
+
+<p>Returns the last element of this stream and true, or zero value and false if the stream is empty.</p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) FindLast() (T, bool)
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{3, 2, 1})
+
+    result, ok := original.FindLast()
+
+    fmt.Println(result)
+    fmt.Println(ok)
+
+    // Output:
+    // 1
+    // true
+}
+```
+
+### <span id="Max">Max</span>
+
+<p>Returns the maximum element of this stream according to the provided less function. less fuction: a > b</p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Max(less func(a, b T) bool) (T, bool)
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{4, 2, 1, 3})
+
+    max, ok := original.Max(func(a, b int) bool { return a > b })
+
+    fmt.Println(max)
+    fmt.Println(ok)
+
+    // Output:
+    // 4
+    // true
+}
+```
+
+### <span id="Min">Min</span>
+
+<p>Returns the minimum element of this stream according to the provided less function. less fuction: a < b</p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Min(less func(a, b T) bool) (T, bool)
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{4, 2, 1, 3})
+
+    min, ok := original.Min(func(a, b int) bool { return a < b })
+
+    fmt.Println(min)
+    fmt.Println(ok)
+
+    // Output:
+    // 1
+    // true
+}
+```
+
+### <span id="AllMatch">AllMatch</span>
+
+<p>Returns whether all elements of this stream match the provided predicate.</p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) AllMatch(predicate func(item T) bool) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3})
+
+    result1 := original.AllMatch(func(item int) bool {
+        return item > 0
+    })
+
+    result2 := original.AllMatch(func(item int) bool {
+        return item > 1
+    })
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="AnyMatch">AnyMatch</span>
+
+<p>Returns whether any elements of this stream match the provided predicate.</p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) AnyMatch(predicate func(item T) bool) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3})
+
+    result1 := original.AnyMatch(func(item int) bool {
+        return item > 1
+    })
+
+    result2 := original.AnyMatch(func(item int) bool {
+        return item > 3
+    })
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="NoneMatch">NoneMatch</span>
+
+<p>Returns whether no elements of this stream match the provided predicate.</p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) NoneMatch(predicate func(item T) bool) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    original := stream.FromSlice([]int{1, 2, 3})
+
+    result1 := original.NoneMatch(func(item int) bool {
+        return item > 3
+    })
+
+    result2 := original.NoneMatch(func(item int) bool {
+        return item > 1
+    })
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="Count">Count</span>
+
+<p>Returns the count of elements in the stream.</p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) Count() int
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    s1 := stream.FromSlice([]int{1, 2, 3})
+    s2 := stream.FromSlice([]int{})
+
+    fmt.Println(s1.Count())
+    fmt.Println(s2.Count())
+
+    // Output:
+    // 3
+    // 0
+}
+```
+
+### <span id="ToSlice">ToSlice</span>
+
+<p>Returns the elements in the stream.</p>
+
+<b>Signature:</b>
+
+```go
+func (s stream[T]) ToSlice() []T
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    s := stream.Of(1, 2, 3)
+
+    data := s.ToSlice()
+
+    fmt.Println(data)
+
+    // Output:
+    // [1 2 3]
+}
+```