doc: add document for compare package

doc: update fileutils package document
test: add examples for compare package
2026-02-17 19:22:28 +08:00 · 2023-04-26 11:02:11 +08:00 · 2023-04-26 10:44:12 +08:00 · 2023-04-26 10:19:42 +08:00 · 2023-04-26 10:05:09 +08:00 · 2023-04-25 18:01:05 +08:00
48 changed files with 3423 additions and 227 deletions
--- a/README.md
+++ b/README.md
@@ -543,6 +543,7 @@ import "github.com/duke-git/lancet/v2/fileutil"
    [[play](https://go.dev/play/p/g0w34kS7B8m)]
 -   **<big>CurrentPath</big>** : return current absolute path.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/fileutil.md#CurrentPath)]
+    [[play](https://go.dev/play/p/s74a9iBGcSw)]

 ### 9. Formatter contains some functions for data formatting.

@@ -557,16 +558,22 @@ import "github.com/duke-git/lancet/v2/formatter"
    [[play](https://go.dev/play/p/eRD5k2vzUVX)]
 -   **<big>Pretty</big>** : pretty print data to JSON string.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter.md#Pretty)]
+    [[play](https://go.dev/play/p/YsciGj3FH2x)]
 -   **<big>PrettyToWriter</big>** : pretty encode data to writer.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter.md#PrettyToWriter)]
+    [[play](https://go.dev/play/p/LPLZ3lDi5ma)]
 -   **<big>DecimalBytes</big>** : returns a human readable byte size under decimal standard (base 1000).
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter.md#DecimalBytes)]
+    [[play](https://go.dev/play/p/FPXs1suwRcs)]
 -   **<big>BinaryBytes</big>** : returns a human-readable byte size under binary standard (base 1024).
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter.md#BinaryBytes)]
+    [[play](https://go.dev/play/p/G9oHHMCAZxP)]
 -   **<big>ParseDecimalBytes</big>** : return the human readable bytes size string into the amount it represents(base 1000).
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter.md#ParseDecimalBytes)]
+    [[play](https://go.dev/play/p/Am98ybWjvjj)]
 -   **<big>ParseBinaryBytes</big>** : return the human readable bytes size string into the amount it represents(base 1024).
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter.md#ParseBinaryBytes)]
+    [[play](https://go.dev/play/p/69v1tTT62x8)]

 ### 10. Function package can control the flow of function execution and support part of functional programming

@@ -614,6 +621,7 @@ import "github.com/duke-git/lancet/v2/maputil"

 -   **<big>MapTo</big>** : quick map any value to struct or any base type.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#MapTo)]
+    [[play](https://go.dev/play/p/4K7KBEPgS5M)]
 -   **<big>ForEach</big>** : executes iteratee funcation for every key and value pair in map.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#ForEach)]
    [[play](https://go.dev/play/p/OaThj6iNVXK)]
@@ -988,11 +996,13 @@ import "github.com/duke-git/lancet/v2/slice"
    [[play](https://go.dev/play/p/8uI8f1lwNrQ)]
 -   **<big>Reduce<sup>deprecated</sup></big>** : creates an slice of values by running each element of slice thru iteratee function.(Deprecated: use ReduceBy)
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Reduce)]
+    [[play](https://go.dev/play/p/_RfXJJWIsIm)]
 -   **<big>ReduceBy</big>** : produces a value from slice by accumulating the result of each element as passed through the reducer function.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ReduceBy)]
+    [[play](https://go.dev/play/p/YKDpLi7gtee)]
 -   **<big>ReduceRight</big>** : ReduceRight is like ReduceBy, but it iterates over elements of slice from right to left.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ReduceRight)]
-    [[play](https://go.dev/play/p/_RfXJJWIsIm)]
+    [[play](https://go.dev/play/p/qT9dZC03A1K)]
 -   **<big>Replace</big>** : returns a copy of the slice with the first n non-overlapping instances of old replaced by new.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Replace)]
    [[play](https://go.dev/play/p/P5mZp7IhOFo)]
@@ -1351,11 +1361,13 @@ import "github.com/duke-git/lancet/v2/validator"
    [[play](https://go.dev/play/p/dpzgUjFnBCX)]
 -   **<big>IsFloat</big>** : check if the value is float(float32, float34) or not.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsFloat)]
+    [[play](https://go.dev/play/p/vsyG-sxr99_Z)]
 -   **<big>IsFloatStr</big>** : check if the string can convert to a float.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsFloatStr)]
    [[play](https://go.dev/play/p/LOYwS_Oyl7U)]
 -   **<big>IsNumber</big>** : check if the value is number(integer, float) or not.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsNumber)]
+    [[play](https://go.dev/play/p/mdJHOAvtsvF)]
 -   **<big>IsNumberStr</big>** : check if the string can convert to a number.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsNumberStr)]
    [[play](https://go.dev/play/p/LzaKocSV79u)]
@@ -1367,6 +1379,7 @@ import "github.com/duke-git/lancet/v2/validator"
    [[play](https://go.dev/play/p/z_XeZo_litG)]
 -   **<big>IsInt</big>** : check if the string can convert to a number.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsInt)]
+    [[play](https://go.dev/play/p/eFoIHbgzl-z)]
 -   **<big>IsIntStr</big>** : check if the string can convert to a integer.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsIntStr)]
    [[play](https://go.dev/play/p/jQRtFv-a0Rk)]
--- a/README_zh-CN.md
+++ b/README_zh-CN.md
@@ -542,6 +542,7 @@ import "github.com/duke-git/lancet/v2/fileutil"
    [[play](https://go.dev/play/p/g0w34kS7B8m)]
 -   **<big>CurrentPath</big>** : 返回当前位置的绝对路径。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/fileutil_zh-CN.md#CurrentPath)]
+    [[play](https://go.dev/play/p/s74a9iBGcSw)]

 ### 9. formatter 格式化器包含一些数据格式化处理方法。

@@ -556,16 +557,22 @@ import "github.com/duke-git/lancet/v2/formatter"
    [[play](https://go.dev/play/p/eRD5k2vzUVX)]
 -   **<big>Pretty</big>** : 返回 pretty JSON 字符串。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter_zh-CN.md#Pretty)]
+    [[play](https://go.dev/play/p/YsciGj3FH2x)]
 -   **<big>PrettyToWriter</big>** : Pretty encode 数据到 writer。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter_zh-CN.md#PrettyToWriter)]
+    [[play](https://go.dev/play/p/LPLZ3lDi5ma)]
 -   **<big>DecimalBytes</big>** : 返回十进制标准（以 1000 为基数）下的可读字节单位字符串。precision 参数指定小数点后的位数，默认为 4。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter_zh-CN.md#DecimalBytes)]
+    [[play](https://go.dev/play/p/FPXs1suwRcs)]
 -   **<big>BinaryBytes</big>** : 返回 binary 标准（以 1024 为基数）下的可读字节单位字符串。precision 参数指定小数点后的位数，默认为 4。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter_zh-CN.md#BinaryBytes)]
+    [[play](https://go.dev/play/p/G9oHHMCAZxP)]
 -   **<big>ParseDecimalBytes</big>** : 将字节单位字符串转换成其所表示的字节数（以 1000 为基数）。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter_zh-CN.md#ParseDecimalBytes)]
+    [[play](https://go.dev/play/p/Am98ybWjvjj)]
 -   **<big>ParseBinaryBytes</big>** : 将字节单位字符串转换成其所表示的字节数（以 1024 为基数）。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter_zh-CN.md#ParseBinaryBytes)]
+    [[play](https://go.dev/play/p/69v1tTT62x8)]

 ### 10. function 函数包控制函数执行流程，包含部分函数式编程。

@@ -613,6 +620,7 @@ import "github.com/duke-git/lancet/v2/maputil"

 -   **<big>MapTo</big>** : 快速将 map 或者其他类型映射到结构体或者指定类型。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#MapTo)]
+    [[play](https://go.dev/play/p/4K7KBEPgS5M)]
 -   **<big>ForEach</big>** : 对 map 中的每对 key 和 value 执行 iteratee 函数。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#ForEach)]
    [[play](https://go.dev/play/p/OaThj6iNVXK)]
@@ -990,8 +998,10 @@ import "github.com/duke-git/lancet/v2/slice"
    [[play](https://go.dev/play/p/_RfXJJWIsIm)]
 -   **<big>ReduceBy</big>** : 对切片元素执行 reduce 操作。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ReduceBy)]
+    [[play](https://go.dev/play/p/YKDpLi7gtee)]
 -   **<big>ReduceRight</big>** : 类似 ReduceBy 操作，迭代切片元素顺序从右至左。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ReduceRight)]
+    [[play](https://go.dev/play/p/qT9dZC03A1K)]
 -   **<big>Replace</big>** : 返回切片的副本，其中前 n 个不重叠的 old 替换为 new。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Replace)]
    [[play](https://go.dev/play/p/P5mZp7IhOFo)]
@@ -1353,11 +1363,13 @@ import "github.com/duke-git/lancet/v2/validator"
    [[play](https://go.dev/play/p/dpzgUjFnBCX)]
 -   **<big>IsFloat</big>** : 验证参数是否是浮点数((float32，float34)。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsFloat)]
+    [[play](https://go.dev/play/p/vsyG-sxr99_Z)]
 -   **<big>IsFloatStr</big>** : 验证字符串是否是可以转换为浮点数。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsFloatStr)]
    [[play](https://go.dev/play/p/LOYwS_Oyl7U)]
 -   **<big>IsNumber</big>** : 验证参数是否是数字(integer，float)。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsNumber)]
+    [[play](https://go.dev/play/p/mdJHOAvtsvF)]
 -   **<big>IsNumberStr</big>** : 验证字符串是否是可以转换为数字。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsNumberStr)]
    [[play](https://go.dev/play/p/LzaKocSV79u)]
@@ -1369,6 +1381,7 @@ import "github.com/duke-git/lancet/v2/validator"
    [[play](https://go.dev/play/p/z_XeZo_litG)]
 -   **<big>IsInt</big>** : 验证参数是否是整数(int, unit)。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsInt)]
+    [[play](https://go.dev/play/p/eFoIHbgzl-z)]
 -   **<big>IsIntStr</big>** : 验证字符串是否是可以转换为整数。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsIntStr)]
    [[play](https://go.dev/play/p/jQRtFv-a0Rk)]
--- a/compare/compare.go
+++ b/compare/compare.go
@@ -0,0 +1,58 @@
+// 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)
+func Equal(left, right any) bool {
+	return compareValue(equal, left, right)
+}
+
+// EqualValue checks if two values are equal or not. (check value only)
+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`.
+func LessThan(left, right any) bool {
+	return compareValue(lessThan, left, right)
+}
+
+// GreaterThan checks if value `left` greater than value `right`.
+func GreaterThan(left, right any) bool {
+	return compareValue(greaterThan, left, right)
+}
+
+// LessOrEqual checks if value `left` less than or equal to value `right`.
+func LessOrEqual(left, right any) bool {
+	return compareValue(lessOrEqual, left, right)
+}
+
+// GreaterOrEqual checks if value `left` greater than or equal to value `right`.
+func GreaterOrEqual(left, right any) bool {
+	return compareValue(greaterOrEqual, left, right)
+}
--- a/compare/compare_example_test.go
+++ b/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
+}
--- a/compare/compare_internal.go
+++ b/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
+}
--- a/compare/compare_test.go
+++ b/compare/compare_test.go
@@ -0,0 +1,134 @@
+package compare
+
+import (
+	"testing"
+	"time"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestEqual(t *testing.T) {
+	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) {
+	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) {
+	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) {
+	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) {
+	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) {
+	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"))
+}
--- a/convertor/convertor.go
+++ b/convertor/convertor.go
@@ -11,11 +11,12 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/duke-git/lancet/v2/structs"
 	"math"
 	"reflect"
 	"strconv"
 	"strings"
+
+	"github.com/duke-git/lancet/v2/structs"
 )

 // ToBool convert string to boolean.
@@ -319,43 +320,29 @@ func DeepClone[T any](src T) T {
 }

 // CopyProperties copies each field from the source into the destination. It recursively copies struct pointers and interfaces that contain struct pointers.
-// Play: https://go.dev/play/p/FOVY3XJL-6B
-func CopyProperties[T, U any](dst T, src U) (err error) {
-	defer func() {
-		if e := recover(); e != nil {
-			err = fmt.Errorf("%v", e)
-		}
-	}()
-
-	dstType, dstValue := reflect.TypeOf(dst), reflect.ValueOf(dst)
-	srcType, srcValue := reflect.TypeOf(src), reflect.ValueOf(src)
+// use json.Marshal/Unmarshal, so json tag should be set for fields of dst and src struct.
+// Play: todo
+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: param dst should be struct pointer")
+		return errors.New("CopyProperties: parameter dst should be struct pointer")
 	}

 	if srcType.Kind() == reflect.Ptr {
-		srcType, srcValue = srcType.Elem(), srcValue.Elem()
+		srcType = srcType.Elem()
 	}
 	if srcType.Kind() != reflect.Struct {
-		return errors.New("CopyProperties: param src should be a struct or struct pointer")
+		return errors.New("CopyProperties: parameter src should be a struct or struct pointer")
 	}

-	dstType, dstValue = dstType.Elem(), dstValue.Elem()
-
-	propertyNums := dstType.NumField()
-
-	for i := 0; i < propertyNums; i++ {
-		property := dstType.Field(i)
-		propertyValue := srcValue.FieldByName(property.Name)
-
-		if !propertyValue.IsValid() || property.Type != propertyValue.Type() {
-			continue
-		}
-
-		if dstValue.Field(i).CanSet() {
-			dstValue.Field(i).Set(propertyValue)
-		}
+	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
--- a/convertor/convertor_example_test.go
+++ b/convertor/convertor_example_test.go
@@ -297,49 +297,55 @@ func ExampleDeepClone() {
 }

 func ExampleCopyProperties() {
-	type Address struct {
-		Country string
-		ZipCode string
+	type Disk struct {
+		Name    string  `json:"name"`
+		Total   string  `json:"total"`
+		Used    string  `json:"used"`
+		Percent float64 `json:"percent"`
 	}

-	type User struct {
-		Name   string
-		Age    int
-		Role   string
-		Addr   Address
-		Hobbys []string
-		salary int
+	type DiskVO struct {
+		Name    string  `json:"name"`
+		Total   string  `json:"total"`
+		Used    string  `json:"used"`
+		Percent float64 `json:"percent"`
 	}

-	type Employee struct {
-		Name   string
-		Age    int
-		Role   string
-		Addr   Address
-		Hobbys []string
-		salary int
+	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:"-"`
 	}

-	user := User{Name: "user001", Age: 10, Role: "Admin", Addr: Address{Country: "CN", ZipCode: "001"}, Hobbys: []string{"a", "b"}, salary: 1000}
-
-	employee1 := Employee{}
-	err := CopyProperties(&employee1, &user)
-	if err != nil {
-		return
+	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"`
 	}

-	employee2 := Employee{Name: "employee001", Age: 20, Role: "User",
-		Addr: Address{Country: "UK", ZipCode: "002"}, salary: 500}
+	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},
+	}}

-	err = CopyProperties(&employee2, &user)
-	if err != nil {
-		return
-	}
+	indicatorVO := IndicatorVO{}

-	fmt.Println(employee1)
-	fmt.Println(employee2)
+	CopyProperties(&indicatorVO, indicator)
+
+	fmt.Println(indicatorVO.Id)
+	fmt.Println(indicatorVO.Ip)
+	fmt.Println(len(indicatorVO.Disk))

 	// Output:
-	// {user001 10 Admin {CN 001} [a b] 0}
-	// {user001 10 Admin {CN 001} [a b] 500}
+	// 001
+	// 127.0.0.1
+	// 3
 }
--- a/convertor/convertor_test.go
+++ b/convertor/convertor_test.go
@@ -320,49 +320,51 @@ func TestDeepClone(t *testing.T) {
 func TestCopyProperties(t *testing.T) {
 	assert := internal.NewAssert(t, "TestCopyProperties")

-	type Address struct {
-		Country string
-		ZipCode string
+	type Disk struct {
+		Name    string  `json:"name"`
+		Total   string  `json:"total"`
+		Used    string  `json:"used"`
+		Percent float64 `json:"percent"`
 	}

-	type User struct {
-		Name   string
-		Age    int
-		Role   string
-		Addr   Address
-		Hobbys []string
-		salary int
+	type DiskVO struct {
+		Name    string  `json:"name"`
+		Total   string  `json:"total"`
+		Used    string  `json:"used"`
+		Percent float64 `json:"percent"`
 	}

-	type Employee struct {
-		Name   string
-		Age    int
-		Role   string
-		Addr   Address
-		Hobbys []string
-		salary int
+	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:"-"`
 	}

-	user := User{Name: "user001", Age: 10, Role: "Admin", Addr: Address{Country: "CN", ZipCode: "001"}, Hobbys: []string{"a", "b"}, salary: 1000}
+	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"`
+	}

-	employee1 := Employee{}
+	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},
+	}}

-	err := CopyProperties(&employee1, &user)
+	indicatorVO := IndicatorVO{}
+
+	err := CopyProperties(&indicatorVO, indicator)

 	assert.IsNil(err)
-	assert.Equal("user001", employee1.Name)
-	assert.Equal("Admin", employee1.Role)
-	assert.Equal("CN", employee1.Addr.Country)
-	assert.Equal(0, employee1.salary)
-
-	employee2 := Employee{Name: "employee001", Age: 20, Role: "User",
-		Addr: Address{Country: "UK", ZipCode: "002"}, salary: 500}
-
-	err = CopyProperties(&employee2, &user)
-
-	assert.IsNil(err)
-	assert.Equal("user001", employee2.Name)
-	assert.Equal("Admin", employee2.Role)
-	assert.Equal("CN", employee2.Addr.Country)
-	assert.Equal(500, employee2.salary)
+	assert.Equal("001", indicatorVO.Id)
+	assert.Equal("127.0.0.1", indicatorVO.Ip)
+	assert.Equal(3, len(indicatorVO.Disk))
 }
--- a/docs/compare.md
+++ b/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
+}
+```
--- a/docs/compare_zh-CN.md
+++ b/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
+}
+```
--- a/docs/convertor.md
+++ b/docs/convertor.md
@@ -697,7 +697,7 @@ func main() {

 ### <span id="CopyProperties">CopyProperties</span>

-<p>Copies each field from the source struct into the destination struct.</p>
+<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>

@@ -716,44 +716,56 @@ import (
 )

 func main() {
-    type Address struct {
-        Country string
-        ZipCode string
+    type Disk struct {
+        Name    string  `json:"name"`
+        Total   string  `json:"total"`
+        Used    string  `json:"used"`
+        Percent float64 `json:"percent"`
    }

-    type User struct {
-        Name   string
-        Age    int
-        Role   string
-        Addr   Address
-        Hobbys []string
-        salary int
+    type DiskVO struct {
+        Name    string  `json:"name"`
+        Total   string  `json:"total"`
+        Used    string  `json:"used"`
+        Percent float64 `json:"percent"`
    }

-    type Employee struct {
-        Name   string
-        Age    int
-        Role   string
-        Addr   Address
-        Hobbys []string
-        salary int
+    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:"-"`
    }

-    user := User{Name: "user001", Age: 10, Role: "Admin", Addr: Address{Country: "CN", ZipCode: "001"}, Hobbys: []string{"a", "b"}, salary: 1000}
+    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"`
+    }

-    employee1 := Employee{}
-    CopyProperties(&employee1, &user)
+    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},
+    }}

-    employee2 := Employee{Name: "employee001", Age: 20, Role: "User",
-        Addr: Address{Country: "UK", ZipCode: "002"}, salary: 500}
+    indicatorVO := IndicatorVO{}

-    CopyProperties(&employee2, &user)
+    CopyProperties(&indicatorVO, indicator)

-    fmt.Println(employee1)
-    fmt.Println(employee2)
+    fmt.Println(indicatorVO.Id)
+    fmt.Println(indicatorVO.Ip)
+    fmt.Println(len(indicatorVO.Disk))

    // Output:
-    // {user001 10 Admin {CN 001} [a b] 0}
-    // {user001 10 Admin {CN 001} [a b] 500}
+    // 001
+    // 127.0.0.1
+    // 3
 }
 ```
--- a/docs/convertor_zh-CN.md
+++ b/docs/convertor_zh-CN.md
@@ -696,7 +696,7 @@ func main() {

 ### <span id="CopyProperties">CopyProperties</span>

-<p>拷贝不同结构体之间的同名字段。</p>
+<p>拷贝不同结构体之间的同名字段。使用json.Marshal序列化，需要设置dst和src struct字段的json tag。</p>

 <b>函数签名:</b>

@@ -715,44 +715,56 @@ import (
 )

 func main() {
-    type Address struct {
-        Country string
-        ZipCode string
+    type Disk struct {
+        Name    string  `json:"name"`
+        Total   string  `json:"total"`
+        Used    string  `json:"used"`
+        Percent float64 `json:"percent"`
    }

-    type User struct {
-        Name   string
-        Age    int
-        Role   string
-        Addr   Address
-        Hobbys []string
-        salary int
+    type DiskVO struct {
+        Name    string  `json:"name"`
+        Total   string  `json:"total"`
+        Used    string  `json:"used"`
+        Percent float64 `json:"percent"`
    }

-    type Employee struct {
-        Name   string
-        Age    int
-        Role   string
-        Addr   Address
-        Hobbys []string
-        salary int
+    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:"-"`
    }

-    user := User{Name: "user001", Age: 10, Role: "Admin", Addr: Address{Country: "CN", ZipCode: "001"}, Hobbys: []string{"a", "b"}, salary: 1000}
+    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"`
+    }

-    employee1 := Employee{}
-    CopyProperties(&employee1, &user)
+    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},
+    }}

-    employee2 := Employee{Name: "employee001", Age: 20, Role: "User",
-        Addr: Address{Country: "UK", ZipCode: "002"}, salary: 500}
+    indicatorVO := IndicatorVO{}

-    CopyProperties(&employee2, &user)
+    CopyProperties(&indicatorVO, indicator)

-    fmt.Println(employee1)
-    fmt.Println(employee2)
+    fmt.Println(indicatorVO.Id)
+    fmt.Println(indicatorVO.Ip)
+    fmt.Println(len(indicatorVO.Disk))

    // Output:
-    // {user001 10 Admin {CN 001} [a b] 0}
-    // {user001 10 Admin {CN 001} [a b] 500}
+    // 001
+    // 127.0.0.1
+    // 3
 }
 ```
--- a/docs/fileutil.md
+++ b/docs/fileutil.md
@@ -38,7 +38,11 @@ import (
 -   [ReadFileByLine](#ReadFileByLine)
 -   [Zip](#Zip)
 -   [UnZip](#UnZip)
-   [UnZip](#UnZip)
+-   [IsZipFile](#IsZipFile)
+-   [FileSize](#FileSize)
+-   [MTime](#MTime)
+-   [Sha](#Sha)
+-   [ReadCsvFile](#ReadCsvFile)

 <div STYLE="page-break-after: always;"></div>

@@ -131,7 +135,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func CopyFile(srcFilePath string, dstFilePath string) error
+func CopyFile(srcPath string, dstPath string) error
 ```

 <b>Example:</b>
@@ -496,3 +500,163 @@ 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 := 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>
+}
+```
--- a/docs/fileutil_zh-CN.md
+++ b/docs/fileutil_zh-CN.md
@@ -38,6 +38,11 @@ import (
 -   [ReadFileByLine](#ReadFileByLine)
 -   [Zip](#Zip)
 -   [UnZip](#UnZip)
+-   [IsZipFile](#IsZipFile)
+-   [FileSize](#FileSize)
+-   [MTime](#MTime)
+-   [Sha](#Sha)
+-   [ReadCsvFile](#ReadCsvFile)

 <div STYLE="page-break-after: always;"></div>

@@ -107,7 +112,7 @@ func main() {
 func CreateDir(absPath string) error
 ```

-<b>Example:</b>
+<b>示例:</b>

 ```go
 package main
@@ -130,7 +135,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func CopyFile(srcFilePath string, dstFilePath string) error
+func CopyFile(srcPath string, dstPath string) error
 ```

 <b>示例:</b>
@@ -472,7 +477,7 @@ func main() {

 <p>zip解压缩文件并保存在目录中</p>

-<b>Signature:</b>
+<b>函数签名:</b>

 ```go
 func UnZip(zipFile string, destPath string) error
@@ -495,3 +500,163 @@ 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 := 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>
+}
+```
--- a/docs/netutil.md
+++ b/docs/netutil.md
@@ -44,6 +44,10 @@ import (
 -   [HttpPut<sup>Deprecated</sup>](#HttpPut)
 -   [HttpPatch<sup>Deprecated</sup>](#HttpPatch)
 -   [ParseHttpResponse](#ParseHttpResponse)
+-   [DownloadFile](#DownloadFile)
+-   [UploadFile](#UploadFile)
+-   [IsPingConnected](#IsPingConnected)
+-   [IsTelnetConnected](#IsTelnetConnected)

 <div STYLE="page-break-after: always;"></div>

@@ -110,8 +114,8 @@ func main() {
        fmt.Println(err)
    }

-    fmt.Println(encodedUrl) 
-    
+    fmt.Println(encodedUrl)
+
    // Output:
    // http://www.lancet.com?a=1&b=%5B2%5D
 }
@@ -142,8 +146,8 @@ func main() {
    internalIp := netutil.GetInternalIp()
    ip := net.ParseIP(internalIp)

-    fmt.Println(ip) 
-    
+    fmt.Println(ip)
+
    // Output:
    // 192.168.1.9
 }
@@ -172,7 +176,7 @@ import (

 func main() {
    ips := netutil.GetIps()
-    fmt.Println(ips) 
+    fmt.Println(ips)

    // Output:
    // [192.168.1.9]
@@ -896,3 +900,124 @@ func main() {
    fmt.Println(toDoResp)
 }
 ```
+
+### <span id="DownloadFile">DownloadFile</span>
+
+<p>Download the file exist in url to a local file.</p>
+
+<b>Signature:</b>
+
+```go
+func DownloadFile(filepath string, url string) error
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+    err := DownloadFile("./lancet_logo.jpg", "https://picx.zhimg.com/v2-fc82a4199749de9cfb71e32e54f489d3_720w.jpg?source=172ae18b")
+
+    fmt.Println(err)
+}
+```
+
+### <span id="UploadFile">UploadFile</span>
+
+<p>Upload the file to a server.</p>
+
+<b>Signature:</b>
+
+```go
+func UploadFile(filepath string, server string) (bool, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+    ok, err := netutil.UploadFile("./a.jpg", "http://www.xxx.com/bucket/test")
+
+    fmt.Println(ok)
+    fmt.Println(err)
+}
+```
+
+### <span id="IsPingConnected">IsPingConnected</span>
+
+<p>checks if can ping the specified host or not.</p>
+
+<b>Signature:</b>
+
+```go
+func IsPingConnected(host string) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+    result1 := netutil.IsPingConnected("www.baidu.com")
+    result2 := netutil.IsPingConnected("www.!@#&&&.com")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsTelnetConnected">IsTelnetConnected</span>
+
+<p>Checks if can telnet the specified host or not.</p>
+
+<b>Signature:</b>
+
+```go
+func IsTelnetConnected(host string, port string) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+    result1 := netutil.IsTelnetConnected("www.baidu.com", "80")
+    result2 := netutil.IsTelnetConnected("www.baidu.com", "123")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
--- a/docs/netutil_zh-CN.md
+++ b/docs/netutil_zh-CN.md
@@ -44,6 +44,10 @@ import (
 -   [HttpPut<sup>Deprecated</sup>](#HttpPut)
 -   [HttpPatch<sup>Deprecated</sup>](#HttpPatch)
 -   [ParseHttpResponse](#ParseHttpResponse)
+-   [DownloadFile](#DownloadFile)
+-   [UploadFile](#UploadFile)
+-   [IsPingConnected](#IsPingConnected)
+-   [IsTelnetConnected](#IsTelnetConnected)

 <div STYLE="page-break-after: always;"></div>

@@ -898,3 +902,124 @@ func main() {
    fmt.Println(toDoResp)
 }
 ```
+
+### <span id="DownloadFile">DownloadFile</span>
+
+<p>从指定的server地址下载文件。</p>
+
+<b>函数签名:</b>
+
+```go
+func DownloadFile(filepath string, url string) error
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+    err := DownloadFile("./lancet_logo.jpg", "https://picx.zhimg.com/v2-fc82a4199749de9cfb71e32e54f489d3_720w.jpg?source=172ae18b")
+
+    fmt.Println(err)
+}
+```
+
+### <span id="UploadFile">UploadFile</span>
+
+<p>将文件上传指定的server地址。</p>
+
+<b>函数签名:</b>
+
+```go
+func UploadFile(filepath string, server string) (bool, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+    ok, err := netutil.UploadFile("./a.jpg", "http://www.xxx.com/bucket/test")
+
+    fmt.Println(ok)
+    fmt.Println(err)
+}
+```
+
+### <span id="IsPingConnected">IsPingConnected</span>
+
+<p>检查能否ping通主机。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsPingConnected(host string) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+    result1 := netutil.IsPingConnected("www.baidu.com")
+    result2 := netutil.IsPingConnected("www.!@#&&&.com")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsTelnetConnected">IsTelnetConnected</span>
+
+<p>检查能否telnet到主机。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsTelnetConnected(host string, port string) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+    result1 := netutil.IsTelnetConnected("www.baidu.com", "80")
+    result2 := netutil.IsTelnetConnected("www.baidu.com", "123")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
--- a/docs/slice.md
+++ b/docs/slice.md
@@ -43,8 +43,10 @@ import (
 -   [EqualWith](#EqualWith)
 -   [Every](#Every)
 -   [Filter](#Filter)
-   [Find](#Find)
-   [FindLast](#FindLast)
+-   [Find<sup>deprecated</sup>](#Find)
+-   [FindBy](#FindBy)
+-   [FindLast<sup>deprecated</sup>](#FindLast)
+-   [FindLastBy](#FindLastBy)
 -   [Flatten](#Flatten)
 -   [FlattenDeep](#FlattenDeep)
 -   [ForEach](#ForEach)
@@ -837,7 +839,7 @@ func main() {
 }
 ```

-### <span id="Find">Find</span>
+### <span id="Find">Find(deprecated: use FindBy)</span>

 <p>Iterates over elements of slice, returning the first one that passes a truth test on function.</p>

@@ -873,7 +875,43 @@ func main() {
 }
 ```

-### <span id="FindLast">FindLast</span>
+### <span id="FindBy">FindBy</span>
+
+<p>Iterates over elements of slice, returning the first one that passes a truth test on predicate function.If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing</p>
+
+<b>Signature:</b>
+
+```go
+func FindBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+	isEven := func(i, num int) bool {
+		return num%2 == 0
+	}
+
+	result, ok := slice.FindBy(nums, isEven)
+
+	fmt.Println(result)
+	fmt.Println(ok)
+
+	// Output:
+	// 2
+	// true
+}
+```
+
+### <span id="FindLast">FindLast(deprecated: use FindLastBy)</span>

 <p>iterates over elements of slice from end to begin, returning the last one that passes a truth test on function.</p>

@@ -909,6 +947,42 @@ func main() {
 }
 ```

+### <span id="FindLastBy">FindLastBy</span>
+
+<p>FindLastBy iterates over elements of slice, returning the last one that passes a truth test on predicate function. If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing</p>
+
+<b>Signature:</b>
+
+```go
+func FindLastBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+	isEven := func(i, num int) bool {
+		return num%2 == 0
+	}
+
+	result, ok := slice.FindLastBy(nums, isEven)
+
+	fmt.Println(result)
+	fmt.Println(ok)
+
+	// Output:
+	// 4
+	// true
+}
+```
+
 ### <span id="Flatten">Flatten</span>

 <p>Flatten slice with one level.</p>
--- a/docs/slice_zh-CN.md
+++ b/docs/slice_zh-CN.md
@@ -43,8 +43,10 @@ import (
 -   [Equal](#Equal)
 -   [EqualWith](#EqualWith)
 -   [Filter](#Filter)
-   [Find](#Find)
-   [FindLast](#FindLast)
+-   [Find<sup>deprecated</sup>](#Find)
+-   [FindBy](#FindBy)
+-   [FindLast<sup>deprecated</sup>](#FindLast)
+-   [FindLastBy](#FindLastBy)
 -   [Flatten](#Flatten)
 -   [FlattenDeep](#FlattenDeep)
 -   [ForEach](#ForEach)
@@ -838,9 +840,9 @@ func main() {
 }
 ```

-### <span id="Find">Find</span>
+### <span id="Find">Find (废弃：使用 FindBy)</span>

-<p>遍历切片的元素，返回第一个通过predicate函数真值测试的元素</p>
+<p>遍历slice的元素，返回第一个通过predicate函数真值测试的元素</p>

 <b>函数签名:</b>

@@ -874,9 +876,45 @@ func main() {
 }
 ```

-### <span id="FindLast">FindLast</span>
+### <span id="FindBy">FindBy</span>

-<p>从头到尾遍历slice的元素，返回最后一个通过predicate函数真值测试的元素。</p>
+<p>遍历slice的元素，返回第一个通过predicate函数真值测试的元素</p>
+
+<b>函数签名:</b>
+
+```go
+func FindBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+	isEven := func(i, num int) bool {
+		return num%2 == 0
+	}
+
+	result, ok := slice.FindBy(nums, isEven)
+
+	fmt.Println(result)
+	fmt.Println(ok)
+
+	// Output:
+	// 2
+	// true
+}
+```
+
+### <span id="FindLast">FindLast(废弃：使用 FindLastBy)</span>
+
+<p>遍历slice的元素，返回最后一个通过predicate函数真值测试的元素。</p>

 <b>函数签名:</b>

@@ -910,6 +948,42 @@ func main() {
 }
 ```

+### <span id="FindLastBy">FindLastBy</span>
+
+<p>从遍历slice的元素，返回最后一个通过predicate函数真值测试的元素。</p>
+
+<b>函数签名:</b>
+
+```go
+func FindLastBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+	isEven := func(i, num int) bool {
+		return num%2 == 0
+	}
+
+	result, ok := slice.FindLastBy(nums, isEven)
+
+	fmt.Println(result)
+	fmt.Println(ok)
+
+	// Output:
+	// 4
+	// true
+}
+```
+
 ### <span id="Flatten">Flatten</span>

 <p>将切片压平一层</p>
--- a/docs/strutil.md
+++ b/docs/strutil.md
@@ -46,6 +46,12 @@ import (
 -   [SplitWords](#SplitWords)
 -   [WordCount](#WordCount)
 -   [RemoveNonPrintable](#RemoveNonPrintable)
+-   [StringToBytes](#StringToBytes)
+-   [BytesToString](#BytesToString)
+-   [IsBlank](#IsBlank)
+-   [HasPrefixAny](#HasPrefixAny)
+-   [HasSuffixAny](#HasSuffixAny)
+-   [IndexOffset](#IndexOffset)

 <div STYLE="page-break-after: always;"></div>

@@ -852,7 +858,6 @@ func main() {
 }
 ```

-
 ### <span id="SplitWords">SplitWords</span>

 <p>Splits a string into words, word only contains alphabetic characters.</p>
@@ -896,7 +901,6 @@ func main() {
 }
 ```

-
 ### <span id="WordCount">WordCount</span>

 <p>Return the number of meaningful word, word only contains alphabetic characters.</p>
@@ -940,7 +944,6 @@ func main() {
 }
 ```

-
 ### <span id="RemoveNonPrintable">RemoveNonPrintable</span>

 <p>Remove non-printable characters from a string.</p>
@@ -969,4 +972,196 @@ func main() {
    // hello world
    // 你好😄
 }
-```
+```
+
+### <span id="StringToBytes">StringToBytes</span>
+
+<p>Converts a string to byte slice without a memory allocation.</p>
+
+<b>Signature:</b>
+
+```go
+func StringToBytes(str string) (b []byte)
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.StringToBytes("abc")
+	result2 := reflect.DeepEqual(result1, []byte{'a', 'b', 'c'})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	// Output:
+	// [97 98 99]
+	// true
+}
+```
+
+### <span id="BytesToString">BytesToString</span>
+
+<p>Converts a byte slice to string without a memory allocation.</p>
+
+<b>Signature:</b>
+
+```go
+func BytesToString(bytes []byte) string
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    bytes := []byte{'a', 'b', 'c'}
+	result := strutil.BytesToString(bytes)
+
+	fmt.Println(result)
+	// Output:
+	// abc
+}
+```
+
+### <span id="IsBlank">IsBlank</span>
+
+<p>Checks if a string is whitespace or empty.</p>
+
+<b>Signature:</b>
+
+```go
+func IsBlank(str string) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.IsBlank("")
+	result2 := strutil.IsBlank("\t\v\f\n")
+	result3 := strutil.IsBlank(" 中文")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	// Output:
+	// true
+	// true
+	// false
+}
+```
+
+### <span id="HasPrefixAny">HasPrefixAny</span>
+
+<p>Checks if a string starts with any of an array of specified strings.</p>
+
+<b>Signature:</b>
+
+```go
+func HasPrefixAny(str string, prefixes []string) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.HasPrefixAny("foo bar", []string{"fo", "xyz", "hello"})
+	result2 := strutil.HasPrefixAny("foo bar", []string{"oom", "world"})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	// Output:
+	// true
+	// false
+}
+```
+
+### <span id="HasSuffixAny">HasSuffixAny</span>
+
+<p>Checks if a string ends with any of an array of specified strings.</p>
+
+<b>Signature:</b>
+
+```go
+func HasSuffixAny(str string, suffixes []string) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.HasSuffixAny("foo bar", []string{"bar", "xyz", "hello"})
+	result2 := strutil.HasSuffixAny("foo bar", []string{"oom", "world"})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	// Output:
+	// true
+	// false
+}
+```
+
+### <span id="IndexOffset">IndexOffset</span>
+
+<p>Returns the index of the first instance of substr in string after offsetting the string by `idxFrom`, or -1 if substr is not present in string.</p>
+
+<b>Signature:</b>
+
+```go
+func IndexOffset(str string, substr string, idxFrom int) int
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    str := "foo bar hello world"
+
+	result1 := strutil.IndexOffset(str, "o", 5)
+	result2 := strutil.IndexOffset(str, "o", 0)
+	result3 := strutil.IndexOffset(str, "d", len(str)-1)
+	result4 := strutil.IndexOffset(str, "d", len(str))
+	result5 := strutil.IndexOffset(str, "f", -1)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	// Output:
+	// 12
+	// 1
+	// 18
+	// -1
+	// -1
+}
+```
--- a/docs/strutil_zh-CN.md
+++ b/docs/strutil_zh-CN.md
@@ -46,6 +46,12 @@ import (
 -   [SplitWords](#SplitWords)
 -   [WordCount](#WordCount)
 -   [RemoveNonPrintable](#RemoveNonPrintable)
+-   [StringToBytes](#StringToBytes)
+-   [BytesToString](#BytesToString)
+-   [IsBlank](#IsBlank)
+-   [HasPrefixAny](#HasPrefixAny)
+-   [HasSuffixAny](#HasSuffixAny)
+-   [IndexOffset](#IndexOffset)

 <div STYLE="page-break-after: always;"></div>

@@ -895,7 +901,6 @@ func main() {
 }
 ```

-
 ### <span id="WordCount">WordCount</span>

 <p>返回有意义单词的数量，只支持字母字符单词。</p>
@@ -939,7 +944,6 @@ func main() {
 }
 ```

-
 ### <span id="RemoveNonPrintable">RemoveNonPrintable</span>

 <p>删除字符串中不可打印的字符。</p>
@@ -968,4 +972,196 @@ func main() {
    // hello world
    // 你好😄
 }
-```
+```
+
+### <span id="StringToBytes">StringToBytes</span>
+
+<p>在不分配内存的情况下将字符串转换为字节片。</p>
+
+<b>函数签名:</b>
+
+```go
+func StringToBytes(str string) (b []byte)
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.StringToBytes("abc")
+	result2 := reflect.DeepEqual(result1, []byte{'a', 'b', 'c'})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	// Output:
+	// [97 98 99]
+	// true
+}
+```
+
+### <span id="BytesToString">BytesToString</span>
+
+<p>在不分配内存的情况下将字节切片转换为字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func BytesToString(bytes []byte) string
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    bytes := []byte{'a', 'b', 'c'}
+	result := strutil.BytesToString(bytes)
+
+	fmt.Println(result)
+	// Output:
+	// abc
+}
+```
+
+### <span id="IsBlank">IsBlank</span>
+
+<p>检查字符串是否为空格或空。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsBlank(str string) bool
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.IsBlank("")
+	result2 := strutil.IsBlank("\t\v\f\n")
+	result3 := strutil.IsBlank(" 中文")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	// Output:
+	// true
+	// true
+	// false
+}
+```
+
+### <span id="HasPrefixAny">HasPrefixAny</span>
+
+<p>检查字符串是否以指定字符串数组中的任何一个开头。</p>
+
+<b>函数签名:</b>
+
+```go
+func HasPrefixAny(str string, prefixes []string) bool
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.HasPrefixAny("foo bar", []string{"fo", "xyz", "hello"})
+	result2 := strutil.HasPrefixAny("foo bar", []string{"oom", "world"})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	// Output:
+	// true
+	// false
+}
+```
+
+### <span id="HasSuffixAny">HasSuffixAny</span>
+
+<p>检查字符串是否以指定字符串数组中的任何一个结尾。</p>
+
+<b>函数签名:</b>
+
+```go
+func HasSuffixAny(str string, suffixes []string) bool
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.HasSuffixAny("foo bar", []string{"bar", "xyz", "hello"})
+	result2 := strutil.HasSuffixAny("foo bar", []string{"oom", "world"})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	// Output:
+	// true
+	// false
+}
+```
+
+### <span id="IndexOffset">IndexOffset</span>
+
+<p>将字符串偏移idxFrom后，返回字符串中第一个 substr 实例的索引，如果字符串中不存在 substr，则返回 -1。</p>
+
+<b>函数签名:</b>
+
+```go
+func IndexOffset(str string, substr string, idxFrom int) int
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    str := "foo bar hello world"
+
+	result1 := strutil.IndexOffset(str, "o", 5)
+	result2 := strutil.IndexOffset(str, "o", 0)
+	result3 := strutil.IndexOffset(str, "d", len(str)-1)
+	result4 := strutil.IndexOffset(str, "d", len(str))
+	result5 := strutil.IndexOffset(str, "f", -1)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	// Output:
+	// 12
+	// 1
+	// 18
+	// -1
+	// -1
+}
+```
--- a/docs/system.md
+++ b/docs/system.md
@@ -239,14 +239,17 @@ func main() {
 }
 ```

-### <span id="ExecCommand">CompareOsEnv</span>
+### <span id="ExecCommand">ExecCommand</span>

 <p>Execute shell command, return the stdout and stderr string of command, and error if error occur. param `command` is a complete command string, like, ls -a (linux), dir(windows), ping 127.0.0.1. In linux, use /bin/bash -c to execute command, In windows, use powershell.exe to execute command.</p>

 <b>Signature:</b>

 ```go
-func ExecCommand(command string) (stdout, stderr string, err error)
+type (
+	Option func(*exec.Cmd)
+)
+func ExecCommand(command string, opts ...Option) (stdout, stderr string, err error)
 ```

 <b>Example:</b>
--- a/docs/system_zh-CN.md
+++ b/docs/system_zh-CN.md
@@ -246,7 +246,10 @@ func main() {
 <b>Signature:</b>

 ```go
-func ExecCommand(command string) (stdout, stderr string, err error)
+type (
+	Option func(*exec.Cmd)
+)
+func ExecCommand(command string, opts ...Option) (stdout, stderr string, err error)
 ```

 <b>Example:</b>
--- a/fileutil/file.go
+++ b/fileutil/file.go
@@ -7,6 +7,11 @@ package fileutil
 import (
 	"archive/zip"
 	"bufio"
+	"bytes"
+	"crypto/sha1"
+	"crypto/sha256"
+	"crypto/sha512"
+	"encoding/csv"
 	"errors"
 	"fmt"
 	"io"
@@ -68,14 +73,14 @@ func RemoveFile(path string) error {

 // CopyFile copy src file to dest file.
 // Play: https://go.dev/play/p/Jg9AMJMLrJi
-func CopyFile(srcFilePath string, dstFilePath string) error {
-	srcFile, err := os.Open(srcFilePath)
+func CopyFile(srcPath string, dstPath string) error {
+	srcFile, err := os.Open(srcPath)
 	if err != nil {
 		return err
 	}
 	defer srcFile.Close()

-	distFile, err := os.Create(dstFilePath)
+	distFile, err := os.Create(dstPath)
 	if err != nil {
 		return err
 	}
@@ -174,6 +179,23 @@ func ListFileNames(path string) ([]string, error) {
 	return result, nil
 }

+// IsZipFile checks if file is zip or not.
+// Play: todo
+func IsZipFile(filepath string) bool {
+	f, err := os.Open(filepath)
+	if err != nil {
+		return false
+	}
+	defer f.Close()
+
+	buf := make([]byte, 4)
+	if n, err := f.Read(buf); err != nil || n < 4 {
+		return false
+	}
+
+	return bytes.Equal(buf, []byte("PK\x03\x04"))
+}
+
 // Zip create zip file, fpath could be a single file or a directory.
 // Play: https://go.dev/play/p/j-3sWBp8ik_P
 func Zip(fpath string, destPath string) error {
@@ -276,6 +298,7 @@ func UnZip(zipFile string, destPath string) error {
 			}
 		}
 	}
+
 	return nil
 }

@@ -348,7 +371,7 @@ func MiMeType(file any) string {
 }

 // CurrentPath return current absolute path.
-// Play: todo
+// Play: https://go.dev/play/p/s74a9iBGcSw
 func CurrentPath() string {
 	var absPath string
 	_, filename, _, ok := runtime.Caller(1)
@@ -358,3 +381,75 @@ func CurrentPath() string {

 	return absPath
 }
+
+// FileSize returns file size in bytes.
+// Play: todo
+func FileSize(path string) (int64, error) {
+	f, err := os.Stat(path)
+	if err != nil {
+		return 0, err
+	}
+	return f.Size(), nil
+}
+
+// MTime returns file modified time.
+// Play: todo
+func MTime(filepath string) (int64, error) {
+	f, err := os.Stat(filepath)
+	if err != nil {
+		return 0, err
+	}
+	return f.ModTime().Unix(), nil
+}
+
+// MTime returns file sha value, param `shaType` should be 1, 256 or 512.
+// Play: todo
+func Sha(filepath string, shaType ...int) (string, error) {
+	file, err := os.Open(filepath)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	h := sha1.New()
+	if len(shaType) > 0 {
+		if shaType[0] == 1 {
+			h = sha1.New()
+		} else if shaType[0] == 256 {
+			h = sha256.New()
+		} else if shaType[0] == 512 {
+			h = sha512.New()
+		} else {
+			return "", errors.New("param `shaType` should be 1, 256 or 512.")
+		}
+	}
+
+	_, err = io.Copy(h, file)
+
+	if err != nil {
+		return "", err
+	}
+
+	sha := fmt.Sprintf("%x", h.Sum(nil))
+
+	return sha, nil
+
+}
+
+// ReadCsvFile read file content into slice.
+// Play: todo
+func ReadCsvFile(filepath string) ([][]string, error) {
+	f, err := os.Open(filepath)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	csvReader := csv.NewReader(f)
+	records, err := csvReader.ReadAll()
+	if err != nil {
+		return nil, err
+	}
+
+	return records, nil
+}
--- a/fileutil/file_example_test.go
+++ b/fileutil/file_example_test.go
@@ -223,3 +223,65 @@ func ExampleUnZip() {
 	// Output:
 	// application/octet-stream
 }
+
+func ExampleIsZipFile() {
+	result1 := IsZipFile("./file.go")
+	result2 := IsZipFile("./testdata/file.go.zip")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// false
+	// true
+}
+
+func ExampleFileSize() {
+	size, err := FileSize("./testdata/test.txt")
+
+	fmt.Println(size)
+	fmt.Println(err)
+
+	// Output:
+	// 20
+	// <nil>
+}
+
+func ExampleMTime() {
+	mtime, err := MTime("./testdata/test.txt")
+
+	fmt.Println(mtime)
+	fmt.Println(err)
+
+	// Output:
+	// 1682391110
+	// <nil>
+}
+
+func ExampleSha() {
+	sha1, err := Sha("./testdata/test.txt", 1)
+	sha256, _ := Sha("./testdata/test.txt", 256)
+	sha512, _ := Sha("./testdata/test.txt", 512)
+
+	fmt.Println(sha1)
+	fmt.Println(sha256)
+	fmt.Println(sha512)
+	fmt.Println(err)
+
+	// Output:
+	// dda3cf10c5a6ff6c6659a497bf7261b287af2bc7
+	// aa6d0a3fbc3442c228d606da09e0c1dc98c69a1cac3da1909199e0266171df35
+	// d22aba2a1b7a2e2f512756255cc1c3708905646920cb1eb95e45b531ba74774dbbb89baebf1f716220eb9cf4908f1cfc5b2a01267704d9a59f59d77cab609870
+	// <nil>
+}
+
+func ExampleReadCsvFile() {
+	content, err := ReadCsvFile("./testdata/test.csv")
+
+	fmt.Println(content)
+	fmt.Println(err)
+
+	// Output:
+	// [[Bob  12  male] [Duke  14  male] [Lucy  16  female]]
+	// <nil>
+}
--- a/fileutil/file_test.go
+++ b/fileutil/file_test.go
@@ -246,3 +246,54 @@ func TestCurrentPath(t *testing.T) {
 	absPath := CurrentPath()
 	t.Log(absPath)
 }
+
+func TestIsZipFile(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIsZipFile")
+
+	assert.Equal(false, IsZipFile("./file.go"))
+	assert.Equal(true, IsZipFile("./testdata/file.go.zip"))
+}
+
+func TestFileSize(t *testing.T) {
+	assert := internal.NewAssert(t, "TestFileSize")
+
+	size, err := FileSize("./testdata/test.txt")
+
+	assert.IsNil(err)
+	assert.Equal(int64(20), size)
+}
+
+func TestMTime(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMTime")
+
+	mtime, err := MTime("./testdata/test.txt")
+
+	assert.IsNil(err)
+	assert.Equal(int64(1682391110), mtime)
+}
+
+func TestSha(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSha")
+
+	sha1, err := Sha("./testdata/test.txt", 1)
+	sha256, err := Sha("./testdata/test.txt", 256)
+	sha512, err := Sha("./testdata/test.txt", 512)
+
+	assert.IsNil(err)
+	assert.Equal("dda3cf10c5a6ff6c6659a497bf7261b287af2bc7", sha1)
+	assert.Equal("aa6d0a3fbc3442c228d606da09e0c1dc98c69a1cac3da1909199e0266171df35", sha256)
+	assert.Equal("d22aba2a1b7a2e2f512756255cc1c3708905646920cb1eb95e45b531ba74774dbbb89baebf1f716220eb9cf4908f1cfc5b2a01267704d9a59f59d77cab609870", sha512)
+}
+
+func TestReadCsvFile(t *testing.T) {
+	assert := internal.NewAssert(t, "TestReadCsvFile")
+
+	content, err := ReadCsvFile("./testdata/test.csv")
+	t.Log(content)
+
+	assert.IsNil(err)
+
+	assert.Equal(3, len(content))
+	assert.Equal(3, len(content[0]))
+	assert.Equal("Bob", content[0][0])
+}
--- a/fileutil/testdata/file.go.zip
+++ b/fileutil/testdata/file.go.zip
--- a/fileutil/testdata/test.csv
+++ b/fileutil/testdata/test.csv
@@ -0,0 +1,3 @@
+Bob, 12, male
+Duke, 14, male
+Lucy, 16, female
--- a/fileutil/testdata/test.txt
+++ b/fileutil/testdata/test.txt
@@ -0,0 +1 @@
+this is a test file.
--- a/formatter/byte.go
+++ b/formatter/byte.go
@@ -82,7 +82,7 @@ var (

 // DecimalBytes returns a human readable byte size under decimal standard (base 1000)
 // The precision parameter specifies the number of digits after the decimal point, which defaults to 4.
-// Play: todo
+// Play: https://go.dev/play/p/FPXs1suwRcs
 func DecimalBytes(size float64, precision ...int) string {
 	p := 5
 	if len(precision) > 0 {
@@ -95,7 +95,7 @@ func DecimalBytes(size float64, precision ...int) string {

 // BinaryBytes returns a human-readable byte size under binary standard (base 1024)
 // The precision parameter specifies the number of digits after the decimal point, which defaults to 4.
-// Play: todo
+// Play: https://go.dev/play/p/G9oHHMCAZxP
 func BinaryBytes(size float64, precision ...int) string {
 	p := 5
 	if len(precision) > 0 {
@@ -118,14 +118,14 @@ func calculateByteSize(size float64, base float64, byteUnits []string) (float64,

 // ParseDecimalBytes return the human readable bytes size string into the amount it represents(base 1000).
 // ParseDecimalBytes("42 MB") -> 42000000, nil
-// Play: todo
+// Play: https://go.dev/play/p/Am98ybWjvjj
 func ParseDecimalBytes(size string) (uint64, error) {
 	return parseBytes(size, "decimal")
 }

 // ParseBinaryBytes return the human readable bytes size string into the amount it represents(base 1024).
 // ParseBinaryBytes("42 mib") -> 44040192, nil
-// Play: todo
+// Play: https://go.dev/play/p/69v1tTT62x8
 func ParseBinaryBytes(size string) (uint64, error) {
 	return parseBytes(size, "binary")
 }
--- a/formatter/formatter.go
+++ b/formatter/formatter.go
@@ -48,14 +48,14 @@ func Comma[T constraints.Float | constraints.Integer | string](value T, symbol s
 }

 // Pretty data to JSON string.
-// Play: todo
+// Play: https://go.dev/play/p/YsciGj3FH2x
 func Pretty(v any) (string, error) {
 	out, err := json.MarshalIndent(v, "", "    ")
 	return string(out), err
 }

 // PrettyToWriter pretty encode data to writer.
-// Play: todo
+// Play: https://go.dev/play/p/LPLZ3lDi5ma
 func PrettyToWriter(v any, out io.Writer) error {
 	enc := json.NewEncoder(out)
 	enc.SetIndent("", "    ")
--- a/go.mod
+++ b/go.mod
@@ -4,5 +4,5 @@ go 1.18

 require (
 	golang.org/x/exp v0.0.0-20221208152030-732eee02a75a
-	golang.org/x/text v0.5.0
+	golang.org/x/text v0.9.0
 )
--- a/go.sum
+++ b/go.sum
@@ -2,3 +2,5 @@ golang.org/x/exp v0.0.0-20221208152030-732eee02a75a h1:4iLhBPcpqFmylhnkbY3W0ONLU
 golang.org/x/exp v0.0.0-20221208152030-732eee02a75a/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
 golang.org/x/text v0.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM=
 golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
--- a/internal/assert.go
+++ b/internal/assert.go
@@ -211,7 +211,7 @@ func compare(x, y any) int {

 }

-// logFailedInfo make test failed and log error info
+// makeTestFailed make test failed and log error info
 func makeTestFailed(t *testing.T, caseName string, expected, actual any) {
 	_, file, line, _ := runtime.Caller(2)
 	errInfo := fmt.Sprintf("Case %v failed. file: %v, line: %v, expected: %v, actual: %v.", caseName, file, line, expected, actual)
--- a/maputil/typemap.go
+++ b/maputil/typemap.go
@@ -60,6 +60,7 @@ var _ = func() struct{} {
 		log.Println(dist)

 */
+// Play: https://go.dev/play/p/4K7KBEPgS5M
 func MapTo(src any, dst any) error {

 	dstRef := reflect.ValueOf(dst)
--- a/netutil/net.go
+++ b/netutil/net.go
@@ -1,12 +1,20 @@
 package netutil

 import (
+	"bytes"
 	"encoding/json"
+	"errors"
 	"io"
+	"mime/multipart"
 	"net"
 	"net/http"
 	"net/url"
+	"os"
+	"os/exec"
 	"strings"
+	"time"
+
+	"github.com/duke-git/lancet/v2/fileutil"
 )

 // GetInternalIp return internal ipv4.
@@ -178,3 +186,90 @@ func EncodeUrl(urlStr string) (string, error) {

 	return URL.String(), nil
 }
+
+// DownloadFile will upload the file to a server.
+func UploadFile(filepath string, server string) (bool, error) {
+	if !fileutil.IsExist(filepath) {
+		return false, errors.New("file not exist")
+	}
+
+	fileInfo, err := os.Stat(filepath)
+	if err != nil {
+		return false, err
+	}
+
+	bodyBuffer := &bytes.Buffer{}
+	writer := multipart.NewWriter(bodyBuffer)
+
+	formFile, err := writer.CreateFormFile("uploadfile", fileInfo.Name())
+	if err != nil {
+		return false, err
+	}
+
+	srcFile, err := os.Open(filepath)
+	if err != nil {
+		return false, err
+	}
+	defer srcFile.Close()
+
+	_, err = io.Copy(formFile, srcFile)
+	if err != nil {
+		return false, err
+	}
+
+	contentType := writer.FormDataContentType()
+	writer.Close()
+
+	_, err = http.Post(server, contentType, bodyBuffer)
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}
+
+// DownloadFile will download the file exist in url to a local file.
+// Play: todo
+func DownloadFile(filepath string, url string) error {
+	resp, err := http.Get(url)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	out, err := os.Create(filepath)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	_, err = io.Copy(out, resp.Body)
+
+	return err
+}
+
+// IsPingConnected checks if can ping specified host or not.
+// Play: todo
+func IsPingConnected(host string) bool {
+	cmd := exec.Command("ping", host, "-c", "1", "-W", "6")
+	err := cmd.Run()
+	if err != nil {
+		return false
+	}
+	return true
+}
+
+// IsTelnetConnected checks if can telnet specified host or not.
+// Play: todo
+func IsTelnetConnected(host string, port string) bool {
+	adder := host + ":" + port
+	conn, err := net.DialTimeout("tcp", adder, 5*time.Second)
+
+	if err != nil {
+		return false
+	}
+
+	defer conn.Close()
+
+	return true
+}
--- a/netutil/net_example_test.go
+++ b/netutil/net_example_test.go
@@ -16,18 +16,18 @@ func ExampleGetInternalIp() {
 	// true
 }

-func ExampleGetPublicIpInfo() {
-	ipInfo, err := GetPublicIpInfo()
-	if err != nil {
-		return
-	}
+// func ExampleGetPublicIpInfo() {
+// 	ipInfo, err := GetPublicIpInfo()
+// 	if err != nil {
+// 		return
+// 	}

-	result := IsPublicIP(net.ParseIP(ipInfo.Ip))
-	fmt.Println(result)
+// 	result := IsPublicIP(net.ParseIP(ipInfo.Ip))
+// 	fmt.Println(result)

-	// Output:
-	// true
-}
+// 	// Output:
+// 	// true
+// }

 func ExampleGetRequestPublicIp() {
 	ip := "36.112.24.10"
@@ -178,3 +178,26 @@ func ExampleConvertMapToQueryString() {
 	// Output:
 	// a=1&b=2&c=3
 }
+
+func ExampleIsPingConnected() {
+	// result1 := IsPingConnected("bing.com")
+	result2 := IsPingConnected("www.!@#&&&.com")
+
+	// fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// false
+}
+
+func ExampleIsTelnetConnected() {
+	result1 := IsTelnetConnected("bing.com", "80")
+	result2 := IsTelnetConnected("www.baidu.com", "123")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// true
+	// false
+}
--- a/netutil/net_test.go
+++ b/netutil/net_test.go
@@ -40,14 +40,14 @@ func TestGetRequestPublicIp(t *testing.T) {
 	assert.Equal(publicIp, ip)
 }

-func TestGetPublicIpInfo(t *testing.T) {
-	assert := internal.NewAssert(t, "TestGetPublicIpInfo")
+// func TestGetPublicIpInfo(t *testing.T) {
+// 	assert := internal.NewAssert(t, "TestGetPublicIpInfo")

-	publicIpInfo, err := GetPublicIpInfo()
-	assert.IsNil(err)
+// 	publicIpInfo, err := GetPublicIpInfo()
+// 	assert.IsNil(err)

-	t.Logf("public ip info is: %+v \n", *publicIpInfo)
-}
+// 	t.Logf("public ip info is: %+v \n", *publicIpInfo)
+// }

 func TestIsPublicIP(t *testing.T) {
 	assert := internal.NewAssert(t, "TestIsPublicIP")
@@ -98,7 +98,7 @@ func TestGetMacAddrs(t *testing.T) {
 }

 func TestEncodeUrl(t *testing.T) {
-	assert := internal.NewAssert(t, "TestIsInternalIP")
+	assert := internal.NewAssert(t, "TestEncodeUrl")

 	urlAddr := "http://www.lancet.com?a=1&b=[2]"
 	encodedUrl, err := EncodeUrl(urlAddr)
@@ -109,3 +109,31 @@ func TestEncodeUrl(t *testing.T) {
 	expected := "http://www.lancet.com?a=1&b=%5B2%5D"
 	assert.Equal(expected, encodedUrl)
 }
+
+// func TestDownloadFile(t *testing.T) {
+// 	assert := internal.NewAssert(t, "TestDownloadFile")
+
+// 	err := DownloadFile("./lancet_logo.jpg", "https://picx.zhimg.com/v2-fc82a4199749de9cfb71e32e54f489d3_720w.jpg?source=172ae18b")
+// 	assert.IsNil(err)
+// }
+
+func TestIsPingConnected(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIsPingConnected")
+
+	// in github action env, this will fail
+	// result1 := IsPingConnected("bing.com")
+	// assert.Equal(true, result1)
+
+	result2 := IsPingConnected("www.!@#&&&.com")
+	assert.Equal(false, result2)
+}
+
+func TestTelnetConnected(t *testing.T) {
+	assert := internal.NewAssert(t, "TestTelnetConnected")
+
+	result1 := IsTelnetConnected("bing.com", "80")
+	assert.Equal(true, result1)
+
+	result2 := IsTelnetConnected("www.baidu.com", "123")
+	assert.Equal(false, result2)
+}
--- a/slice/slice.go
+++ b/slice/slice.go
@@ -319,7 +319,27 @@ func GroupWith[T any, U comparable](slice []T, iteratee func(item T) U) map[U][]
 // Find iterates over elements of slice, returning the first one that passes a truth test on predicate function.
 // If return T is nil then no items matched the predicate func.
 // Play: https://go.dev/play/p/CBKeBoHVLgq
+// Deprecated
 func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool) {
+	v, ok := FindBy(slice, predicate)
+	return &v, ok
+}
+
+// FindLast iterates over elements of slice from end to begin,
+// return the first one that passes a truth test on predicate function.
+// If return T is nil then no items matched the predicate func.
+// Play: https://go.dev/play/p/FFDPV_j7URd
+// Deprecated
+func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool) {
+	v, ok := FindLastBy(slice, predicate)
+	return &v, ok
+}
+
+// FindBy iterates over elements of slice, returning the first one that passes a truth test on predicate function.
+// If return T is nil or zero value then no items matched the predicate func.
+// In contrast to Find or FindLast, its return value no longer requires dereferencing
+// Play: todo
+func FindBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool) {
 	index := -1

 	for i, v := range slice {
@@ -330,17 +350,17 @@ func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool) {
 	}

 	if index == -1 {
-		return nil, false
+		return v, false
 	}

-	return &slice[index], true
+	return slice[index], true
 }

-// FindLast iterates over elements of slice from end to begin,
-// return the first one that passes a truth test on predicate function.
-// If return T is nil then no items matched the predicate func.
-// Play: https://go.dev/play/p/FFDPV_j7URd
-func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool) {
+// FindLastBy iterates over elements of slice, returning the last one that passes a truth test on predicate function.
+// If return T is nil or zero value then no items matched the predicate func.
+// In contrast to Find or FindLast, its return value no longer requires dereferencing
+// Play: todo
+func FindLastBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool) {
 	index := -1

 	for i := len(slice) - 1; i >= 0; i-- {
@@ -351,10 +371,10 @@ func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, boo
 	}

 	if index == -1 {
-		return nil, false
+		return v, false
 	}

-	return &slice[index], true
+	return slice[index], true
 }

 // Flatten flattens slice with one level.
@@ -493,7 +513,7 @@ func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initia
 }

 // ReduceBy produces a value from slice by accumulating the result of each element as passed through the reducer function.
-// Play: todo
+// Play: https://go.dev/play/p/YKDpLi7gtee
 func ReduceBy[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U {
 	accumulator := initial

@@ -505,7 +525,7 @@ func ReduceBy[T any, U any](slice []T, initial U, reducer func(index int, item T
 }

 // ReduceRight is like ReduceBy, but it iterates over elements of slice from right to left.
-// Play: todo
+// Play: https://go.dev/play/p/qT9dZC03A1K
 func ReduceRight[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U {
 	accumulator := initial

--- a/slice/slice_example_test.go
+++ b/slice/slice_example_test.go
@@ -341,6 +341,40 @@ func ExampleFindLast() {
 	// true
 }

+func ExampleFindBy() {
+	nums := []int{1, 2, 3, 4, 5}
+
+	isEven := func(i, num int) bool {
+		return num%2 == 0
+	}
+
+	result, ok := FindBy(nums, isEven)
+
+	fmt.Println(result)
+	fmt.Println(ok)
+
+	// Output:
+	// 2
+	// true
+}
+
+func ExampleFindLastBy() {
+	nums := []int{1, 2, 3, 4, 5}
+
+	isEven := func(i, num int) bool {
+		return num%2 == 0
+	}
+
+	result, ok := FindLastBy(nums, isEven)
+
+	fmt.Println(result)
+	fmt.Println(ok)
+
+	// Output:
+	// 4
+	// true
+}
+
 func ExampleFlatten() {
 	arrs := [][][]string{{{"a", "b"}}, {{"c", "d"}}}

--- a/slice/slice_test.go
+++ b/slice/slice_test.go
@@ -249,6 +249,44 @@ func TestFind(t *testing.T) {
 	assert.Equal(2, *res)
 }

+func TestFindBy(t *testing.T) {
+	assert := internal.NewAssert(t, "TestFindBy")
+
+	nums := []int{1, 2, 3, 4, 5}
+	even := func(i, num int) bool {
+		return num%2 == 0
+	}
+	res, ok := FindBy(nums, even)
+	if !ok {
+		t.Fatal("found nothing")
+	}
+	assert.Equal(2, res)
+
+	res, ok = FindBy(nums, func(_ int, v int) bool {
+		return v == 6
+	})
+	assert.Equal(res == 0 && ok == false, true)
+}
+
+func TestFindLastBy(t *testing.T) {
+	assert := internal.NewAssert(t, "TestFindBy")
+
+	nums := []int{1, 2, 3, 4, 5}
+	even := func(i, num int) bool {
+		return num%2 == 0
+	}
+	res, ok := FindLastBy(nums, even)
+	if !ok {
+		t.Fatal("found nothing")
+	}
+	assert.Equal(4, res)
+
+	res, ok = FindLastBy(nums, func(_ int, v int) bool {
+		return v == 6
+	})
+	assert.Equal(res == 0 && ok == false, true)
+}
+
 func TestFindLast(t *testing.T) {
 	nums := []int{1, 2, 3, 4, 5}
 	even := func(i, num int) bool {
--- a/strutil/string.go
+++ b/strutil/string.go
@@ -4,9 +4,11 @@
 package strutil

 import (
+	"reflect"
 	"strings"
 	"unicode"
 	"unicode/utf8"
+	"unsafe"
 )

 // CamelCase coverts string to camelCase string. Non letters and numbers will be ignored.
@@ -373,3 +375,73 @@ func RemoveNonPrintable(str string) string {

 	return result
 }
+
+// StringToBytes converts a string to byte slice without a memory allocation.
+// Play: todo
+func StringToBytes(str string) (b []byte) {
+	sh := *(*reflect.StringHeader)(unsafe.Pointer(&str))
+	bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	bh.Data, bh.Len, bh.Cap = sh.Data, sh.Len, sh.Len
+	return b
+}
+
+// BytesToString converts a byte slice to string without a memory allocation.
+// Play: todo
+func BytesToString(bytes []byte) string {
+	return *(*string)(unsafe.Pointer(&bytes))
+}
+
+// IsBlank checks if a string is whitespace, empty.
+// Play: todo
+func IsBlank(str string) bool {
+	if len(str) == 0 {
+		return true
+	}
+	// memory copies will occur here, but UTF8 will be compatible
+	runes := []rune(str)
+	for _, r := range runes {
+		if !unicode.IsSpace(r) {
+			return false
+		}
+	}
+	return true
+}
+
+// HasPrefixAny check if a string starts with any of an array of specified strings.
+// Play: todo
+func HasPrefixAny(str string, prefixes []string) bool {
+	if len(str) == 0 || len(prefixes) == 0 {
+		return false
+	}
+	for _, prefix := range prefixes {
+		if strings.HasPrefix(str, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
+// HasSuffixAny check if a string ends with any of an array of specified strings.
+// Play: todo
+func HasSuffixAny(str string, suffixes []string) bool {
+	if len(str) == 0 || len(suffixes) == 0 {
+		return false
+	}
+	for _, suffix := range suffixes {
+		if strings.HasSuffix(str, suffix) {
+			return true
+		}
+	}
+	return false
+}
+
+// IndexOffset returns the index of the first instance of substr in string after offsetting the string by `idxFrom`,
+// or -1 if substr is not present in string.
+// Play: todo
+func IndexOffset(str string, substr string, idxFrom int) int {
+	if idxFrom > len(str)-1 || idxFrom < 0 {
+		return -1
+	}
+
+	return strings.Index(str[idxFrom:], substr) + idxFrom
+}
--- a/strutil/string_example_test.go
+++ b/strutil/string_example_test.go
@@ -2,6 +2,7 @@ package strutil

 import (
 	"fmt"
+	"reflect"
 )

 func ExampleAfter() {
@@ -449,3 +450,81 @@ func ExampleRemoveNonPrintable() {
 	// hello world
 	// 你好😄
 }
+
+func ExampleStringToBytes() {
+	result1 := StringToBytes("abc")
+	result2 := reflect.DeepEqual(result1, []byte{'a', 'b', 'c'})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	// Output:
+	// [97 98 99]
+	// true
+}
+
+func ExampleBytesToString() {
+	bytes := []byte{'a', 'b', 'c'}
+	result := BytesToString(bytes)
+
+	fmt.Println(result)
+	// Output:
+	// abc
+}
+
+func ExampleIsBlank() {
+	result1 := IsBlank("")
+	result2 := IsBlank("\t\v\f\n")
+	result3 := IsBlank(" 中文")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	// Output:
+	// true
+	// true
+	// false
+}
+
+func ExampleHasPrefixAny() {
+	result1 := HasPrefixAny("foo bar", []string{"fo", "xyz", "hello"})
+	result2 := HasPrefixAny("foo bar", []string{"oom", "world"})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	// Output:
+	// true
+	// false
+}
+
+func ExampleHasSuffixAny() {
+	result1 := HasSuffixAny("foo bar", []string{"bar", "xyz", "hello"})
+	result2 := HasSuffixAny("foo bar", []string{"oom", "world"})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	// Output:
+	// true
+	// false
+}
+
+func ExampleIndexOffset() {
+	str := "foo bar hello world"
+
+	result1 := IndexOffset(str, "o", 5)
+	result2 := IndexOffset(str, "o", 0)
+	result3 := IndexOffset(str, "d", len(str)-1)
+	result4 := IndexOffset(str, "d", len(str))
+	result5 := IndexOffset(str, "f", -1)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	// Output:
+	// 12
+	// 1
+	// 18
+	// -1
+	// -1
+}
--- a/strutil/string_test.go
+++ b/strutil/string_test.go
@@ -1,6 +1,7 @@
 package strutil

 import (
+	"reflect"
 	"testing"

 	"github.com/duke-git/lancet/v2/internal"
@@ -349,3 +350,52 @@ func TestRemoveNonPrintable(t *testing.T) {
 	assert.Equal("hello world", RemoveNonPrintable("hello\u00a0 \u200bworld\n"))
 	assert.Equal("你好😄", RemoveNonPrintable("你好😄"))
 }
+
+func TestStringToBytes(t *testing.T) {
+	assert := internal.NewAssert(t, "TestStringToBytes")
+	str := "abc"
+	bytes := StringToBytes(str)
+	assert.Equal(reflect.DeepEqual(bytes, []byte{'a', 'b', 'c'}), true)
+}
+
+func TestBytesToString(t *testing.T) {
+	assert := internal.NewAssert(t, "TestBytesToString")
+	bytes := []byte{'a', 'b', 'c'}
+	str := BytesToString(bytes)
+	assert.Equal(str == "abc", true)
+}
+
+func TestIsBlank(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIsBlank")
+	assert.Equal(IsBlank(""), true)
+	assert.Equal(IsBlank("\t\v\f\n"), true)
+	assert.Equal(IsBlank(" 中文"), false)
+}
+
+func TestHasPrefixAny(t *testing.T) {
+	assert := internal.NewAssert(t, "TestHasPrefixAny")
+	str := "foo bar"
+	prefixes := []string{"fo", "xyz", "hello"}
+	notMatches := []string{"oom", "world"}
+	assert.Equal(HasPrefixAny(str, prefixes), true)
+	assert.Equal(HasPrefixAny(str, notMatches), false)
+}
+
+func TestHasSuffixAny(t *testing.T) {
+	assert := internal.NewAssert(t, "TestHasSuffixAny")
+	str := "foo bar"
+	suffixes := []string{"bar", "xyz", "hello"}
+	notMatches := []string{"oom", "world"}
+	assert.Equal(HasSuffixAny(str, suffixes), true)
+	assert.Equal(HasSuffixAny(str, notMatches), false)
+}
+
+func TestIndexOffset(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIndexOffset")
+	str := "foo bar hello world"
+	assert.Equal(IndexOffset(str, "o", 5), 12)
+	assert.Equal(IndexOffset(str, "o", 0), 1)
+	assert.Equal(IndexOffset(str, "d", len(str)-1), len(str)-1)
+	assert.Equal(IndexOffset(str, "d", len(str)), -1)
+	assert.Equal(IndexOffset(str, "f", -1), -1)
+}
--- a/system/os_darwin.go
+++ b/system/os_darwin.go
@@ -0,0 +1,26 @@
+//go:build darwin
+
+package system
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+func WithForeground() Option {
+	return func(c *exec.Cmd) {
+		if c.SysProcAttr == nil {
+			c.SysProcAttr = &syscall.SysProcAttr{
+				Foreground: true,
+			}
+		} else {
+			c.SysProcAttr.Foreground = true
+		}
+	}
+}
+
+func WithWinHide() Option {
+	return func(c *exec.Cmd) {
+
+	}
+}
--- a/system/os_linux.go
+++ b/system/os_linux.go
@@ -1,3 +1,5 @@
+//go:build linux
+
 package system

 import (
@@ -16,3 +18,9 @@ func WithForeground() Option {
 		}
 	}
 }
+
+func WithWinHide() Option {
+	return func(c *exec.Cmd) {
+
+	}
+}
--- a/system/os_windows.go
+++ b/system/os_windows.go
@@ -1,3 +1,5 @@
+//go:build windows
+
 package system

 import (
--- a/validator/validator.go
+++ b/validator/validator.go
@@ -371,13 +371,13 @@ func IsGBK(data []byte) bool {
 }

 // IsNumberStr check if the value is number(integer, float) or not.
-// Play: todo
+// Play: https://go.dev/play/p/mdJHOAvtsvF
 func IsNumber(v any) bool {
 	return IsInt(v) || IsFloat(v)
 }

 // IsFloat check if the value is float(float32, float34) or not.
-// Play: todo
+// Play: https://go.dev/play/p/vsyG-sxr99_Z
 func IsFloat(v any) bool {
 	switch v.(type) {
 	case float32, float64:
@@ -387,7 +387,7 @@ func IsFloat(v any) bool {
 }

 // IsInt check if the value is integer(int, unit) or not.
-// Play: todo
+// Play: https://go.dev/play/p/eFoIHbgzl-z
 func IsInt(v any) bool {
 	switch v.(type) {
 	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr:
Author	SHA1	Message	Date
dudaodong	f399425c2a	doc: add document for compare package	2023-04-26 11:02:11 +08:00
dudaodong	dcdb29334d	doc: update fileutils package document	2023-04-26 10:44:12 +08:00
dudaodong	4859f3ca23	test: add examples for compare package	2023-04-26 10:19:42 +08:00
dudaodong	9f2528842e	feat: add unit test for compare package	2023-04-26 10:05:09 +08:00
dudaodong	6066d6669f	feat: add compare package	2023-04-25 18:01:05 +08:00
dudaodong	e3804e9534	test: add test.csv file	2023-04-25 11:34:09 +08:00
dudaodong	2f51397d2c	feat: add ReadCsvFile	2023-04-25 11:28:43 +08:00
dudaodong	11217a11c7	feat: add FileSize, MTime, Sha	2023-04-25 11:16:00 +08:00
dudaodong	fa81ee143e	refactor: update param name CopyFile	2023-04-25 10:49:12 +08:00
dudaodong	62891f20f8	feat: add IsZipFile	2023-04-24 14:00:53 +08:00
dudaodong	5e79eaa9dd	feat: add IsZipFile	2023-04-24 11:00:58 +08:00
dudaodong	aaf45012e4	fix: refact CopyProperties	2023-04-22 14:14:13 +08:00
dudaodong	48c17ea1ce	fix: update params in TestIsPingConnected	2023-04-19 17:40:55 +08:00
dudaodong	e90283c3f9	fix: update params in TestIsPingConnected	2023-04-19 17:35:17 +08:00
dudaodong	f82c4a305d	fix: update params in TestIsPingConnected	2023-04-19 17:32:30 +08:00
dudaodong	05997603a9	doc: add document for DownloadFile and UploadFile	2023-04-19 16:16:47 +08:00
dudaodong	6d5ec807f7	test: comment some test case	2023-04-19 16:04:35 +08:00
dudaodong	f73c7e7e86	doc: add document and example for IsPingConnected and IsTelnetConnected	2023-04-19 11:48:28 +08:00
dudaodong	c137428b9e	feat: add IsPingConnected and IsTelnetConnected	2023-04-19 11:14:10 +08:00
dudaodong	9f68620b37	feat: add IsPingConnected and IsTelnetConnected	2023-04-19 11:13:21 +08:00
dudaodong	2cdbba56a4	feat: add UploadFile and DownloadFile	2023-04-18 20:09:56 +08:00
dudaodong	01a3b139c0	doc: add document for new functions in slice and strutil package	2023-04-18 15:49:09 +08:00
dudaodong	fcb3b97b45	doc: add docment and playground demo for v2.1.19	2023-04-18 15:21:03 +08:00
dudaodong	52ea64bc33	feat: add FindLastBy function	2023-04-17 20:17:26 +08:00
燕归来	14bc08c6d6	feat: add FindBy that a result will be without unrefrence #88 (#90 ) feat: add example for FindBy chore: reduce code duplication	2023-04-17 20:11:56 +08:00
dudaodong	47bdd6718a	fix: ExecCommand can't compile in macos	2023-04-17 17:03:46 +08:00
dudaodong	18d27604e6	update mod file	2023-04-17 17:00:53 +08:00
dudaodong	66bd339e3a	doc: add example for strutil new functions	2023-04-17 16:35:26 +08:00
燕归来	04abb7a3ea	feat: add some function for strutil package #88 (#89 )	2023-04-17 16:07:14 +08:00