fix: test failed

* refactor package structutil to structs

* add structs package zh-CN docs

README.md

@@ -4,7 +4,7 @@
 <br/>
 
 ![Go version](https://img.shields.io/badge/go-%3E%3Dv1.18-9cf)
-[![Release](https://img.shields.io/badge/release-2.1.15-green.svg)](https://github.com/duke-git/lancet/releases)
+[![Release](https://img.shields.io/badge/release-2.1.17-green.svg)](https://github.com/duke-git/lancet/releases)
 [![GoDoc](https://godoc.org/github.com/duke-git/lancet/v2?status.svg)](https://pkg.go.dev/github.com/duke-git/lancet/v2)
 [![Go Report Card](https://goreportcard.com/badge/github.com/duke-git/lancet/v2)](https://goreportcard.com/report/github.com/duke-git/lancet/v2)
 [![test](https://github.com/duke-git/lancet/actions/workflows/codecov.yml/badge.svg?branch=main&event=push)](https://github.com/duke-git/lancet/actions/workflows/codecov.yml)
@@ -38,10 +38,10 @@ English | [简体中文](./README_zh-CN.md)
 go get github.com/duke-git/lancet/v2 // will install latest version of v2.x.x
 ```
 
-2. <b>For users who use version below go1.18, you should install v1.x.x. The latest of v1.x.x is v1.3.6. </b>
+2. <b>For users who use version below go1.18, you should install v1.x.x. The latest of v1.x.x is v1.3.7. </b>
 
 ```go
-go get github.com/duke-git/lancet@v1.3.6 // below go1.18, install latest version of v1.x.x
+go get github.com/duke-git/lancet@v1.3.7 // below go1.18, install latest version of v1.x.x
 ```
 
 ## Usage
@@ -248,6 +248,10 @@ import "github.com/duke-git/lancet/v2/convertor"
     [[play](https://go.dev/play/p/zI6xsmuQRbn)]
 -   **<big>DeepClone</big>** : creates a deep copy of passed item, can't clone unexported field of struct.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#DeepClone)]
+    [[play](https://go.dev/play/p/j4DP5dquxnk)]
+-   **<big>CopyProperties</big>** : copies each field from the source struct into the destination struct.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#CopyProperties)]
+    [[play](https://go.dev/play/p/FOVY3XJL-6B)]
 
 ### 5. Cryptor package is for data encryption and decryption.
 
@@ -452,9 +456,6 @@ import "github.com/duke-git/lancet/v2/datetime"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#ToIso8601)]
     [[play](https://go.dev/play/p/mkhOHQkdeA2)]
 
-
-
-
 ### 7. Datastructure package constains some common data structure. eg. list, linklist, stack, queue, set, tree, graph.
 
 ```go
@@ -589,7 +590,6 @@ import "github.com/duke-git/lancet/v2/function"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/function.md#Watcher)]
     [[play](https://go.dev/play/p/l2yrOpCLd1I)]
 
-
 ### 11. Maputil package includes some functions to manipulate map.
 
 ```go
@@ -604,12 +604,30 @@ import "github.com/duke-git/lancet/v2/maputil"
 -   **<big>Filter</big>** : iterates over map, return a new map contains all key and value pairs pass the predicate function.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Filter)]
     [[play](https://go.dev/play/p/fSvF3wxuNG7)]
+-   **<big>FilterByKeys</big>** : iterates over map, return a new map whose keys are all given keys
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#FilterByKeys)]
+    [[play](https://go.dev/play/p/7ov6BJHbVqh)]
+-   **<big>FilterByValues</big>** : iterates over map, return a new map whose values are all given values.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#FilterByValues)]
+    [[play](https://go.dev/play/p/P3-9MdcXegR)]
+-   **<big>OmitBy</big>** : the opposite of Filter, removes all the map elements for which the predicate function returns true.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#OmitBy)]
+    [[play](https://go.dev/play/p/YJM4Hj5hNwm)]
+-   **<big>OmitByKeys</big>** : the opposite of FilterByKeys, extracts all the map elements which keys are not omitted.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#OmitByKeys)]
+    [[play](https://go.dev/play/p/jXGrWDBfSRp)]
+-   **<big>OmitByValues</big>** : the opposite of FilterByValues. remov all elements whose value are in the give slice.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#OmitByValues)]
+    [[play](https://go.dev/play/p/XB7Y10uw20_U)]
 -   **<big>Intersect</big>** : iterates over maps, return a new map of key and value pairs in all given maps.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Intersect)]
     [[play](https://go.dev/play/p/Zld0oj3sjcC)]
 -   **<big>Keys</big>** : returns a slice of the map's keys.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Keys)]
     [[play](https://go.dev/play/p/xNB5bTb97Wd)]
+-   **<big>KeysBy</big>** : creates a slice whose element is the result of function mapper invoked by every map's key.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#KeysBy)]
+    [[play](https://go.dev/play/p/hI371iB8Up8)]
 -   **<big>Merge</big>** : merge maps, next key will overwrite previous key.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Merge)]
     [[play](https://go.dev/play/p/H95LENF1uB-)]
@@ -619,6 +637,24 @@ import "github.com/duke-git/lancet/v2/maputil"
 -   **<big>Values</big>** : returns a slice of the map's values.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Values)]
     [[play](https://go.dev/play/p/CBKdUc5FTW6)]
+-   **<big>ValuesBy</big>** : creates a slice whose element is the result of function mapper invoked by every map's value.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#ValuesBy)]
+    [[play](https://go.dev/play/p/sg9-oRidh8f)]
+-   **<big>MapKeys</big>** : transforms a map to other type map by manipulating it's keys.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#MapKeys)]
+    [[play](https://go.dev/play/p/8scDxWeBDKd)]
+-   **<big>MapValues</big>** : transforms a map to other type map by manipulating it's values.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#MapValues)]
+    [[play](https://go.dev/play/p/g92aY3fc7Iw)]
+-   **<big>Entries</big>** : transforms a map into array of key/value pairs.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Entries)]
+    [[play](https://go.dev/play/p/Ltb11LNcElY)]
+-   **<big>FromEntries</big>** : creates a map based on a slice of key/value pairs.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#FromEntries)]
+    [[play](https://go.dev/play/p/fTdu4sCNjQO)]
+-   **<big>Transform</big>** : transform a map to another type map.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Transform)]
+    [[play](https://go.dev/play/p/P6ovfToM3zj)]
 -   **<big>IsDisjoint</big>** : check two map are disjoint if they have no keys in common.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#IsDisjoint)]
     [[play](https://go.dev/play/p/N9qgYg_Ho6f)]
@@ -667,6 +703,10 @@ import "github.com/duke-git/lancet/v2/mathutil"
 -   **<big>TruncRound</big>** : round off n decimal places for int64.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#TruncRound)]
     [[play](https://go.dev/play/p/aumarSHIGzP)]
+-   **<big>Range</big>** : Creates a slice of numbers from start with specified count, element step is 1.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#Range)]
+-   **<big>RangeWithStep</big>** : Creates a slice of numbers from start to end with specified step.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#Range)]
 
 ### 13. Netutil package contains functions to get net information and send http request.
 
@@ -731,8 +771,6 @@ import "github.com/duke-git/lancet/v2/netutil"
 -   **<big>ParseHttpResponse</big>** : decode http response into target object.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#ParseHttpResponse)]
 
-
-
 ### 14. Random package implements some basic functions to generate random int and string.
 
 ```go
@@ -804,6 +842,9 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>Contain</big>** : check if the value is in the slice or not.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Contain)]
     [[play](https://go.dev/play/p/_454yEHcNjf)]
+-   **<big>ContainBy</big>** : returns true if predicate function return true.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ContainBy)]
+    [[play](https://go.dev/play/p/49tkHfX4GNc)]
 -   **<big>ContainSubSlice</big>** : check if the slice contain a given subslice or not.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ContainSubSlice)]
     [[play](https://go.dev/play/p/bcuQ3UT6Sev)]
@@ -836,13 +877,16 @@ import "github.com/duke-git/lancet/v2/slice"
     [[play](https://go.dev/play/p/pJ-d6MUWcvK)]
 -   **<big>Drop</big>** : drop n elements from the start of a slice.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Drop)]
-    [[play](https://go.dev/play/p/pJ-d6MUWcvK)]
+    [[play](https://go.dev/play/p/jnPO2yQsT8H)]
 -   **<big>DropRight</big>** : drop n elements from the end of a slice.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DropRight)]
+    [[play](https://go.dev/play/p/8bcXvywZezG)]
 -   **<big>DropWhile</big>** : drop n elements from the start of a slice while predicate function returns true.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DropWhile)]
+    [[play](https://go.dev/play/p/4rt252UV_qs)]
 -   **<big>DropRightWhile</big>** : drop n elements from the end of a slice while predicate function returns true.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DropRightWhile)]
+    [[play](https://go.dev/play/p/6wyK3zMY56e)]
 -   **<big>Equal</big>** : checks if two slices are equal: the same length and all elements' order and value are equal.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Equal)]
     [[play](https://go.dev/play/p/WcRQJ37ifPa)]
@@ -855,6 +899,9 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>Filter</big>** : iterates over elements of slice, returning an slice of all elements pass the predicate function.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Filter)]
     [[play](https://go.dev/play/p/SdPna-7qK4T)]
+-   **<big>FilterMap</big>** : returns a slice which apply both filtering and mapping to the given slice.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#FilterMap)]
+    [[play](https://go.dev/play/p/J94SZ_9MiIe)]
 -   **<big>Find</big>** : iterates over elements of slice, returning the first one that passes a truth test on predicate function.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Find)]
     [[play](https://go.dev/play/p/CBKeBoHVLgq)]
@@ -867,9 +914,14 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>FlattenDeep</big>** : flattens slice recursive to one level.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#FlattenDeep)]
     [[play](https://go.dev/play/p/yjYNHPyCFaF)]
+-   **<big>FlatMap</big>** : manipulates a slice and transforms and flattens it to a slice of another type.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#FlatMap)]
+    [[play](https://go.dev/play/p/_QARWlWs1N_F)]
 -   **<big>ForEach</big>** : iterates over elements of slice and invokes function for each element.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ForEach)]
     [[play](https://go.dev/play/p/DrPaa4YsHRF)]
+-   **<big>ForEachWithBreak</big>** : iterates over elements of slice and invokes function for each element, when iteratee return false, will break the for each loop.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ForEach)]
 -   **<big>GroupBy</big>** : iterate over elements of the slice, each element will be group by criteria, returns two slices.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#GroupBy)]
     [[play](https://go.dev/play/p/QVkPxzPR0iA)]
@@ -920,12 +972,16 @@ import "github.com/duke-git/lancet/v2/slice"
     [[play](https://go.dev/play/p/YHvhnWGU3Ge)]
 -   **<big>IsAscending</big>** : Checks if a slice is ascending order.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#IsAscending)]
+    [[play](https://go.dev/play/p/9CtsFjet4SH)]
 -   **<big>IsDescending</big>** : Checks if a slice is descending order.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#IsDescending)]
+    [[play](https://go.dev/play/p/U_LljFXma14)]
 -   **<big>IsSorted</big>** : Checks if a slice is sorted (ascending or descending).
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#IsSorted)]
+    [[play](https://go.dev/play/p/nCE8wPLwSA-)]
 -   **<big>IsSortedByKey</big>** : Checks if a slice is sorted by iteratee function.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#IsSortedByKey)]
+    [[play](https://go.dev/play/p/tUoGB7DOHI4)]
 -   **<big>Sort</big>** : sorts a slice of any ordered type(number or string).
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Sort)]
     [[play](https://go.dev/play/p/V9AVjzf_4Fk)]
@@ -972,7 +1028,41 @@ import "github.com/duke-git/lancet/v2/slice"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#KeyBy)]
     [[play](https://go.dev/play/p/uXod2LWD1Kg)]
 
-### 17. Strutil package contains some functions to manipulate string.
+
+### 17. Structs package provides several high level functions to manipulate struct, tag, and field.
+
+```go
+import "github.com/duke-git/lancet/v2/structs"
+```
+
+#### Function list:
+
+-   **<big>New</big>** : creates a `Struct` instance.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#New)]
+-   **<big>ToMap</big>** : converts a valid struct to a map.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#ToMap)]
+-   **<big>Fields</big>** : get all fields of a given struct, that the fields are abstract struct field.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#Fields)]
+-   **<big>IsStruct</big>** : check if the struct is valid.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#IsStruct)]
+-   **<big>Tag</big>** : get a `Tag` of the `Field`, `Tag` is a abstract struct field tag
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#Tag)]
+-   **<big>Name</big>** : get the field name.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#Name)]
+-   **<big>Value</big>** : get the `Field` underlying value.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#Value)]
+-   **<big>Kind</big>** : get the field's kind
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#Kind)]
+-   **<big>IsEmbedded</big>** : check if the field is an embedded field.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#IsEmbedded)]
+-   **<big>IsExported</big>** : check if the field is exporte
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#IsExported)]
+-   **<big>IsZero</big>** : check if the field is zero value
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#IsZero)]
+-   **<big>IsSlice</big>** : check if the field is a slice
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#IsSlice)]
+
+### 18. Strutil package contains some functions to manipulate string.
 
 ```go
 import "github.com/duke-git/lancet/v2/strutil"
@@ -1012,6 +1102,9 @@ import "github.com/duke-git/lancet/v2/strutil"
 -   **<big>UpperFirst</big>** : converts the first character of string to upper case.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#UpperFirst)]
     [[play](https://go.dev/play/p/sBbBxRbs8MM)]
+-   **<big>Pad</big>** : pads string on the left and right side if it's shorter than size.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#Pad)]
+    [[play](https://go.dev/play/p/NzImQq-VF8q)]
 -   **<big>PadEnd</big>** : pads string with given characters on the right side if it's shorter than limit size. Padding characters are truncated if they exceed size.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#PadEnd)]
     [[play](https://go.dev/play/p/9xP8rN0vz--)]
@@ -1039,6 +1132,12 @@ import "github.com/duke-git/lancet/v2/strutil"
 -   **<big>Unwrap</big>** : unwrap a given string from anther string. will change source string.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#Unwrap)]
     [[play](https://go.dev/play/p/Ec2q4BzCpG-)]
+-   **<big>SplitWords</big>** : splits a string into words, word only contains alphabetic characters.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#SplitWords)]
+    [[play](https://go.dev/play/p/KLiX4WiysMM)]
+-   **<big>WordCount</big>** : return the number of meaningful word of a string, word only contains alphabetic characters.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#WordCount)]
+    [[play](https://go.dev/play/p/bj7_odx3vRf)]
 
 ### 19. System package contain some functions about os, runtime, shell command.
 
@@ -1076,7 +1175,7 @@ import "github.com/duke-git/lancet/v2/system"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/system.md#GetOsBits)]
     [[play](https://go.dev/play/p/ml-_XH3gJbW)]
 
-### 19. Validator package contains some functions for data validation.
+### 20. Validator package contains some functions for data validation.
 
 ```go
 import "github.com/duke-git/lancet/v2/validator"
@@ -1169,41 +1268,53 @@ import "github.com/duke-git/lancet/v2/validator"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsGBK)]
     [[play](https://go.dev/play/p/E2nt3unlmzP)]
 
-### 20. xerror package implements helpers for errors.
+### 21. xerror package implements helpers for errors.
 
 ```go
 import "github.com/duke-git/lancet/v2/xerror"
 ```
 
 #### Function list:
+
 -   **<big>New</big>** : creates a new XError pointer instance with message.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#New)]
+    [[play](https://go.dev/play/p/w4oWZts7q7f)]
 -   **<big>Wrap</big>** : creates a new XError pointer instance based on error object, and add message.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#Wrap)]
+    [[play](https://go.dev/play/p/5385qT2dCi4)]
 -   **<big>Unwrap</big>** : returns unwrapped XError from err by errors.As. If no XError, returns nil.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#Unwrap)]
+    [[play](https://go.dev/play/p/LKMLep723tu)]
 -   **<big>XError_Wrap</big>** : creates a new XError and copy message and id to new one.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#XError_Wrap)]
+    [[play](https://go.dev/play/p/5385qT2dCi4)]
 -   **<big>XError_Unwrap</big>** : Compatible with github.com/pkg/errors.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#XError_Unwrap)]
+    [[play](https://go.dev/play/p/VUXJ8BST4c6)]
 -   **<big>XError_With</big>** : adds key and value related to the XError object.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#XError_With)]
+    [[play](https://go.dev/play/p/ow8UISXX_Dp)]
 -   **<big>XError_Id</big>** : sets XError object id to check equality in XError.Is.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#XError_Id)]
+    [[play](https://go.dev/play/p/X6HBlsy58U9)]
 -   **<big>XError_Is</big>** : checks if target error is XError and Error.id of two errors are matched.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#XError_Is)]
+    [[play](https://go.dev/play/p/X6HBlsy58U9)]
 -   **<big>XError_Values</big>** : returns map of key and value that is set by XError.With function.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#XError_Values)]
+    [[play](https://go.dev/play/p/ow8UISXX_Dp)]
 -   **<big>XError_StackTrace</big>** : returns stack trace which is compatible with pkg/errors.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#XError_StackTrace)]
+    [[play](https://go.dev/play/p/6FAvSQpa7pc)]
 -   **<big>XError_Info</big>** : returns information of xerror, which can be printed.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#XError_Info)]
+    [[play](https://go.dev/play/p/1ZX0ME1F-Jb)]
 -   **<big>XError_Error</big>** : implements standard error interface.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#XError_Error)]
+    [[play](https://go.dev/play/p/w4oWZts7q7f)]
 -   **<big>TryUnwrap</big>** : check if err is nil then it returns a valid value. If err is not nil, TryUnwrap panics with err.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#TryUnwrap)]
-    [[play](https://go.dev/play/p/w84d7Mb3Afk)]
+    [[play](https://go.dev/play/p/acyZVkNZEeW)]
-
 
 ## How to Contribute
 

README_zh-CN.md

@@ -4,7 +4,7 @@
 <br/>
 
 ![Go version](https://img.shields.io/badge/go-%3E%3Dv1.18-9cf)
-[![Release](https://img.shields.io/badge/release-2.1.15-green.svg)](https://github.com/duke-git/lancet/releases)
+[![Release](https://img.shields.io/badge/release-2.1.17-green.svg)](https://github.com/duke-git/lancet/releases)
 [![GoDoc](https://godoc.org/github.com/duke-git/lancet/v2?status.svg)](https://pkg.go.dev/github.com/duke-git/lancet/v2)
 [![Go Report Card](https://goreportcard.com/badge/github.com/duke-git/lancet/v2)](https://goreportcard.com/report/github.com/duke-git/lancet/v2)
 [![test](https://github.com/duke-git/lancet/actions/workflows/codecov.yml/badge.svg?branch=main&event=push)](https://github.com/duke-git/lancet/actions/workflows/codecov.yml)
@@ -37,10 +37,10 @@
 go get github.com/duke-git/lancet/v2 //安装v2最新版本v2.x.x
 ```
 
-2. <b>使用 go1.18 以下版本的用户，必须安装 v1.x.x。目前最新的 v1 版本是 v1.3.6。</b>
+2. <b>使用 go1.18 以下版本的用户，必须安装 v1.x.x。目前最新的 v1 版本是 v1.3.7。</b>
 
 ```go
-go get github.com/duke-git/lancet@v1.3.6 // 使用go1.18以下版本, 必须安装v1.x.x版本
+go get github.com/duke-git/lancet@v1.3.7 // 使用go1.18以下版本, 必须安装v1.x.x版本
 ```
 
 ## 用法
@@ -247,7 +247,10 @@ import "github.com/duke-git/lancet/v2/convertor"
     [[play](https://go.dev/play/p/zI6xsmuQRbn)]
 -   **<big>DeepClone</big>** : 创建一个传入值的深拷贝, 无法克隆结构体的非导出字段。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#DeepClone)]
-
+    [[play](https://go.dev/play/p/j4DP5dquxnk)]
+-   **<big>CopyProperties</big>** : 拷贝不同结构体之间的同名字段。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#CopyProperties)]
+    [[play](https://go.dev/play/p/FOVY3XJL-6B)]
 
 ### 5. cryptor加密包支持数据加密和解密，获取 md5，hash 值。支持 base64, md5, hmac, aes, des, rsa。
 
@@ -353,8 +356,6 @@ import "github.com/duke-git/lancet/v2/cryptor"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/cryptor_zh-CN.md#RsaDecrypt)]
     [[play](https://go.dev/play/p/uef0q1fz53I)]
 
-
-
 ### 6. datetime日期时间处理包，格式化日期，比较日期。
 
 ```go
@@ -454,8 +455,6 @@ import "github.com/duke-git/lancet/v2/datetime"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#ToIso8601)]
     [[play](https://go.dev/play/p/mkhOHQkdeA2)]
 
-
-
 ### 7. datastructure包含一些普通的数据结构实现。例如：list, linklist, stack, queue, set, tree, graph.
 
 ```go
@@ -488,9 +487,6 @@ import hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
 -   **<big>Hashmap</big>** : 哈希映射。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/datastructure/hashmap_zh-CN.md)]
 
-
-
-
 ### 8. fileutil包含文件基本操作。
 
 ```go
@@ -593,7 +589,6 @@ import "github.com/duke-git/lancet/v2/function"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/function_zh-CN.md#Watcher)]
     [[play](https://go.dev/play/p/l2yrOpCLd1I)]
 
-
 ### 11. maputil包括一些操作 map 的函数.
 
 ```go
@@ -608,12 +603,30 @@ import "github.com/duke-git/lancet/v2/maputil"
 -   **<big>Filter</big>** : 迭代 map 中的每对 key 和 value，返回 map，其中的 key 和 value 符合 predicate 函数。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#Filter)]
     [[play](https://go.dev/play/p/fSvF3wxuNG7)]
+-   **<big>FilterByKeys</big>** : 迭代 map, 返回一个新 map，其 key 都是给定的 key 值。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#FilterByKeys)]
+    [[play](https://go.dev/play/p/7ov6BJHbVqh)]
+-   **<big>FilterByValues</big>** : 迭代 map, 返回一个新 map，其 value 都是给定的 value 值。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#FilterByValues)]
+    [[play](https://go.dev/play/p/P3-9MdcXegR)]
+-   **<big>OmitBy</big>** : Filter 的反向操作, 迭代 map 中的每对 key 和 value, 删除符合 predicate 函数的 key, value, 返回新 map。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#OmitBy)]
+    [[play](https://go.dev/play/p/YJM4Hj5hNwm)]
+-   **<big>OmitByKeys</big>** : FilterByKeys 的反向操作, 迭代 map, 返回一个新 map，其 key 不包括给定的 key 值。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#OmitByKeys)]
+    [[play](https://go.dev/play/p/jXGrWDBfSRp)]
+-   **<big>OmitByValues</big>** : FilterByValues 的反向操作, 迭代 map, 返回一个新 map，其 value 不包括给定的 value 值。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#OmitByValues)]
+    [[play](https://go.dev/play/p/XB7Y10uw20_U)]
 -   **<big>Intersect</big>** : 多个 map 的交集操作。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#Intersect)]
     [[play](https://go.dev/play/p/Zld0oj3sjcC)]
 -   **<big>Keys</big>** : 返回 map 中所有 key 组成的切片。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#Keys)]
     [[play](https://go.dev/play/p/xNB5bTb97Wd)]
+-   **<big>KeysBy</big>** : 创建一个切片，其元素是每个 map 的 key 调用 mapper 函数的结果。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#KeysBy)]
+    [[play](https://go.dev/play/p/hI371iB8Up8)]
 -   **<big>Merge</big>** : 合并多个 map, 相同的 key 会被之后的 key 覆盖。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#Merge)]
     [[play](https://go.dev/play/p/H95LENF1uB-)]
@@ -623,6 +636,24 @@ import "github.com/duke-git/lancet/v2/maputil"
 -   **<big>Values</big>** : 返回 map 中所有 values 组成的切片
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#Values)]
     [[play](https://go.dev/play/p/CBKdUc5FTW6)]
+-   **<big>ValuesBy</big>** : 创建一个切片，其元素是每个 map 的 value 调用 mapper 函数的结果。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#ValuesBy)]
+    [[play](https://go.dev/play/p/sg9-oRidh8f)]
+-   **<big>MapKeys</big>** : 操作 map 的每个 key，然后转为新的 map。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#MapKeys)]
+    [[play](https://go.dev/play/p/8scDxWeBDKd)]
+-   **<big>MapValues</big>** : 操作 map 的每个 value，然后转为新的 map。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#MapValues)]
+    [[play](https://go.dev/play/p/g92aY3fc7Iw)]
+-   **<big>Entries</big>** : 将 map 转换为键/值对切片。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#Entries)]
+    [[play](https://go.dev/play/p/Ltb11LNcElY)]
+-   **<big>FromEntries</big>** : 基于键/值对的切片创建 map。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#FromEntries)]
+    [[play](https://go.dev/play/p/fTdu4sCNjQO)]
+-   **<big>Transform</big>** : 将 map 转换为其他类型的 map。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN#Transform)]
+    [[play](https://go.dev/play/p/P6ovfToM3zj)]
 -   **<big>IsDisjoint</big>** : 验证两个 map 是否具有不同的 key。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#IsDisjoint)]
     [[play](https://go.dev/play/p/N9qgYg_Ho6f)]
@@ -671,6 +702,10 @@ import "github.com/duke-git/lancet/v2/mathutil"
 -   **<big>TruncRound</big>** : 截短 n 位小数（不进行四舍五入）。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#TruncRound)]
     [[play](https://go.dev/play/p/aumarSHIGzP)]
+-   **<big>Range</big>** : 根据指定的起始值和数量，创建一个数字切片。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#Range)]
+-   **<big>RangeWithStep</big>** : 根据指定的起始值，结束值，步长，创建一个数字切片。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#RangeWithStep)]
 
 ### 13. netutil网络包支持获取 ip 地址，发送 http 请求。
 
@@ -735,9 +770,6 @@ import "github.com/duke-git/lancet/v2/netutil"
 -   **<big>ParseHttpResponse</big>** : 解析 http 响应体到目标结构体。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#ParseHttpResponse)]
 
-
-
-
 ### 14. random随机数生成器包，可以生成随机[]bytes, int, string。
 
 ```go
@@ -771,8 +803,6 @@ import "github.com/duke-git/lancet/v2/random"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/random_zh-CN.md#UUIdV4)]
     [[play](https://go.dev/play/p/_Z9SFmr28ft)]
 
-
-
 ### 15. retry重试执行函数直到函数运行成功或被 context cancel。
 
 ```go
@@ -797,8 +827,6 @@ import "github.com/duke-git/lancet/v2/retry"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/retry_zh-CN.md#RetryTimes)]
     [[play](https://go.dev/play/p/ssfVeU2SwLO)]
 
-
-
 ### 16. slice包含操作切片的方法集合。
 
 ```go
@@ -806,12 +834,16 @@ import "github.com/duke-git/lancet/v2/slice"
 ```
 
 #### 函数列表:
+
 -   **<big>AppendIfAbsent</big>** : 当前切片中不包含值时，将该值追加到切片中。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#AppendIfAbsent)]
     [[play](https://go.dev/play/p/GNdv7Jg2Taj)]
 -   **<big>Contain</big>** : 判断 slice 是否包含 value。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Contain)]
     [[play](https://go.dev/play/p/_454yEHcNjf)]
+-   **<big>ContainBy</big>** : 根据 predicate 函数判断切片是否包含某个值。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ContainBy)]
+    [[play](https://go.dev/play/p/49tkHfX4GNc)]
 -   **<big>ContainSubSlice</big>** : 判断 slice 是否包含 subslice。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ContainSubSlice)]
     [[play](https://go.dev/play/p/bcuQ3UT6Sev)]
@@ -844,13 +876,16 @@ import "github.com/duke-git/lancet/v2/slice"
     [[play](https://go.dev/play/p/pJ-d6MUWcvK)]
 -   **<big>Drop</big>** : 从切片头部删除 n 个元素。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Drop)]
-    [[play](https://go.dev/play/p/pJ-d6MUWcvK)]
+    [[play](https://go.dev/play/p/jnPO2yQsT8H)]
 -   **<big>DropRight</big>** : 从切片尾部删除 n 个元素。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#DropRight)]
+    [[play](https://go.dev/play/p/8bcXvywZezG)]
 -   **<big>DropWhile</big>** : 从切片的头部删除 n 个元素，这个 n 个元素满足 predicate 函数返回 true。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#DropWhile)]
+    [[play](https://go.dev/play/p/4rt252UV_qs)]
 -   **<big>DropRightWhile</big>** : 从切片的尾部删除 n 个元素，这个 n 个元素满足 predicate 函数返回 true。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#DropRightWhile)]
+    [[play](https://go.dev/play/p/6wyK3zMY56e)]
 -   **<big>Equal</big>** : 检查两个切片是否相等，相等条件：切片长度相同，元素顺序和值都相同。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Equal)]
     [[play](https://go.dev/play/p/WcRQJ37ifPa)]
@@ -863,6 +898,9 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>Filter</big>** : 返回切片中通过 predicate 函数真值测试的所有元素。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Filter)]
     [[play](https://go.dev/play/p/SdPna-7qK4T)]
+-   **<big>FilterMap</big>** : 返回一个将 filter 和 map 操作应用于给定切片的切片。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#FilterMap)]
+    [[play](https://go.dev/play/p/J94SZ_9MiIe)]
 -   **<big>Find</big>** : 遍历切片的元素，返回第一个通过 predicate 函数真值测试的元素。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Find)]
     [[play](https://go.dev/play/p/CBKeBoHVLgq)]
@@ -875,9 +913,14 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>FlattenDeep</big>** : 将多维切片递归展平到一层。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#FlattenDeep)]
     [[play](https://go.dev/play/p/yjYNHPyCFaF)]
+-   **<big>FlatMap</big>** : 将切片转换为其它类型切片。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#FlatMap)]
+    [[play](https://go.dev/play/p/_QARWlWs1N_F)]
 -   **<big>ForEach</big>** : 遍历切片的元素并为每个元素调用 iteratee 函数。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ForEach)]
     [[play](https://go.dev/play/p/DrPaa4YsHRF)]
+-   **<big>ForEachWithBreak</big>** : 遍历切片的元素并为每个元素调用iteratee函数，当iteratee函数返回false时，终止遍历。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ForEachWithBreak)]
 -   **<big>GroupBy</big>** : 迭代切片的元素，每个元素将按条件分组，返回两个切片。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#GroupBy)]
     [[play](https://go.dev/play/p/QVkPxzPR0iA)]
@@ -928,12 +971,16 @@ import "github.com/duke-git/lancet/v2/slice"
     [[play](https://go.dev/play/p/YHvhnWGU3Ge)]
 -   **<big>IsAscending</big>** : 检查切片元素是否按升序排列。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#IsAscending)]
+    [[play](https://go.dev/play/p/9CtsFjet4SH)]
 -   **<big>IsDescending</big>** : 检查切片元素是否按降序排列。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#IsDescending)]
+    [[play](https://go.dev/play/p/U_LljFXma14)]
 -   **<big>IsSorted</big>** : 检查切片元素是否是有序的（升序或降序）。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#IsSorted)]
+    [[play](https://go.dev/play/p/nCE8wPLwSA-)]
 -   **<big>IsSortedByKey</big>** : 通过 iteratee 函数，检查切片元素是否是有序的。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#IsSortedByKey)]
+    [[play](https://go.dev/play/p/tUoGB7DOHI4)]
 -   **<big>Sort</big>** : 对任何有序类型（数字或字符串）的切片进行排序，使用快速排序算法。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Sort)]
     [[play](https://go.dev/play/p/V9AVjzf_4Fk)]
@@ -980,8 +1027,42 @@ import "github.com/duke-git/lancet/v2/slice"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#KeyBy)]
     [[play](https://go.dev/play/p/uXod2LWD1Kg)]
 
+### 17. structs提供操作struct, tag, field的相关函数。
 
-### 17. strutil 包含字符串处理的相关函数。
+```go
+import "github.com/duke-git/lancet/v2/structs"
+```
+
+#### Function list:
+
+-   **<big>New</big>** : `Struct`结构体的构造函数。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#New)]
+-   **<big>ToMap</big>** : 将一个合法的struct对象转换为map[string]any。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#ToMap)]
+-   **<big>Fields</big>** : 获取一个struct对象的属性列表。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#Fields)]
+-   **<big>Field</big>** : 根据属性名获取一个struct对象的属性。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#Fields)]
+-   **<big>IsStruct</big>** : 判断是否为一个合法的struct对象。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#IsStruct)]
+-   **<big>Tag</big>** : 获取`Field`的`Tag`，默认的tag key是json。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#Tag)]
+-   **<big>Name</big>** : 获取属性名。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#Name)]
+-   **<big>Value</big>** : 获取`Field`属性的值。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#Value)]
+-   **<big>Kind</big>** : 获取属性Kind。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#Kind)]
+-   **<big>IsEmbedded</big>** : 判断属性是否为嵌入。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#IsEmbedded)]
+-   **<big>IsExported</big>** : 判断属性是否导出。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#IsExported)]
+-   **<big>IsZero</big>** : 判断属性是否为零值。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#IsZero)]
+-   **<big>IsSlice</big>** : 判断属性是否是切片。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#IsSlice)]
+
+### 18. strutil包含字符串处理的相关函数。
 
 ```go
 import "github.com/duke-git/lancet/v2/strutil"
@@ -1022,6 +1103,9 @@ import "github.com/duke-git/lancet/v2/strutil"
 -   **<big>UpperFirst</big>** : 将字符串的第一个字符转换为大写形式。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#UpperFirst)]
     [[play](https://go.dev/play/p/sBbBxRbs8MM)]
+-   **<big>Pad</big>** : 如果字符串长度短于 size，则在左右两侧填充字符串。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#Pad)]
+    [[play](https://go.dev/play/p/NzImQq-VF8q)]
 -   **<big>PadEnd</big>** : 如果字符串短于限制大小，则在右侧用给定字符填充字符串。 如果填充字符超出大小，它们将被截断。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#PadEnd)]
     [[play](https://go.dev/play/p/9xP8rN0vz--)]
@@ -1049,8 +1133,15 @@ import "github.com/duke-git/lancet/v2/strutil"
 -   **<big>Unwrap</big>** : 从另一个字符串中解开一个给定的字符串。 将更改源字符串。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#Unwrap)]
     [[play](https://go.dev/play/p/Ec2q4BzCpG-)]
+-   **<big>SplitWords</big>** : 将字符串拆分为单词，只支持字母字符单词。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#SplitWords)]
+    [[play](https://go.dev/play/p/KLiX4WiysMM)]
+-   **<big>WordCount</big>** : 返回有意义单词的数量，只支持字母字符单词。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#WordCount)]
+    [[play](https://go.dev/play/p/bj7_odx3vRf)]
 
-### 18. system 包含 os, runtime, shell command 的相关函数。
+
+### 19. system包含 os, runtime, shell command 的相关函数。
 
 ```go
 import "github.com/duke-git/lancet/v2/system"
@@ -1086,7 +1177,7 @@ import "github.com/duke-git/lancet/v2/system"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/system_zh-CN#GetOsBits)]
     [[play](https://go.dev/play/p/ml-_XH3gJbW)]
 
-### 19. validator 验证器包，包含常用字符串格式验证函数。
+### 20. validator验证器包，包含常用字符串格式验证函数。
 
 ```go
 import "github.com/duke-git/lancet/v2/validator"
@@ -1179,8 +1270,7 @@ import "github.com/duke-git/lancet/v2/validator"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsGBK)]
     [[play](https://go.dev/play/p/E2nt3unlmzP)]
 
-
+### 21. xerror包实现一些错误处理函数
-### 20. xerror 包实现一些错误处理函数
 
 ```go
 import "github.com/duke-git/lancet/v2/xerror"
@@ -1190,32 +1280,43 @@ import "github.com/duke-git/lancet/v2/xerror"
 
 -   **<big>New</big>** : 创建 XError 对象实例。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#New)]
+    [[play](https://go.dev/play/p/w4oWZts7q7f)]
 -   **<big>Wrap</big>** : 根据 error 对象创建 XError 对象实例，可添加 message。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#Wrap)]
+    [[play](https://go.dev/play/p/5385qT2dCi4)]
 -   **<big>Unwrap</big>** : 从 error 对象中解构出 XError。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#Unwrap)]
+    [[play](https://go.dev/play/p/LKMLep723tu)]
 -   **<big>XError_Wrap</big>** : 创建新的 XError 对象并将消息和 id 复制到新的对象中。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#XError_Wrap)]
+    [[play](https://go.dev/play/p/5385qT2dCi4)]
 -   **<big>XError_Unwrap</big>** : 解构 XEerror 为 error 对象。适配 github.com/pkg/errors。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#XError_Unwrap)]
+    [[play](https://go.dev/play/p/VUXJ8BST4c6)]
 -   **<big>XError_With</big>** : 添加与 XError 对象的键和值。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#XError_With)]
+    [[play](https://go.dev/play/p/ow8UISXX_Dp)]
 -   **<big>XError_Id</big>** : 设置 XError 对象的 id。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#XError_Id)]
+    [[play](https://go.dev/play/p/X6HBlsy58U9)]
 -   **<big>XError_Is</big>** : 检查目标 error 是否为 XError，两个错误中的 error.id 是否匹配。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#XError_Is)]
+    [[play](https://go.dev/play/p/X6HBlsy58U9)]
 -   **<big>XError_Values</big>** : 返回由 With 设置的键和值的映射。将合并所有 XError 键和值。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#XError_Values)]
+    [[play](https://go.dev/play/p/ow8UISXX_Dp)]
 -   **<big>XError_StackTrace</big>** : 返回与 pkg/error 兼容的堆栈信息。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#XError_StackTrace)]
+    [[play](https://go.dev/play/p/6FAvSQpa7pc)]
 -   **<big>XError_Info</big>** : 返回可打印的 XError 对象信息。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#XError_Info)]
+    [[play](https://go.dev/play/p/1ZX0ME1F-Jb)]
 -   **<big>XError_Error</big>** : 实现标准库的 error 接口。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#XError_Error)]
+    [[play](https://go.dev/play/p/w4oWZts7q7f)]
 -   **<big>TryUnwrap</big>** : 检查 error, 如果 err 为 nil 则展开，则它返回一个有效值，如果 err 不是 nil 则 Unwrap 使用 err 发生 panic。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#TryUnwrap)]
-    [[play](https://go.dev/play/p/w84d7Mb3Afk)]
+    [[play](https://go.dev/play/p/acyZVkNZEeW)]
-    
 
 ## 如何贡献代码
 

async/promise.go

@@ -0,0 +1,279 @@
+// Copyright 2023 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package async contain some featurese to support async programming. eg, promise, asycn/await, eventbus.
+package async
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+// Promise represents the eventual completion (or failure) of an asynchronous operation and its resulting value.
+// ref : chebyrash/promise (https://github.com/chebyrash/promise)
+// see js promise: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
+type Promise[T any] struct {
+	runnable func(resolve func(T), reject func(error))
+	result   T
+	err      error
+
+	pending bool
+
+	mu *sync.Mutex
+	wg *sync.WaitGroup
+}
+
+// New create a new promise instance.
+func New[T any](runnable func(resolve func(T), reject func(error))) *Promise[T] {
+	if runnable == nil {
+		panic("runnable function should not be nil")
+	}
+
+	p := &Promise[T]{
+		runnable: runnable,
+		pending:  true,
+		mu:       &sync.Mutex{},
+		wg:       &sync.WaitGroup{},
+	}
+
+	defer p.run()
+
+	return p
+}
+
+func (p *Promise[T]) run() {
+	p.wg.Add(1)
+
+	go func() {
+		defer func() {
+			if !p.pending {
+				return
+			}
+
+			if err := recover(); err != nil {
+				p.reject(errors.New(fmt.Sprint(err)))
+			}
+		}()
+
+		p.runnable(p.resolve, p.reject)
+	}()
+}
+
+// Resolve returns a Promise that has been resolved with a given value.
+func Resolve[T any](resolution T) *Promise[T] {
+	return &Promise[T]{
+		result:  resolution,
+		pending: false,
+		mu:      &sync.Mutex{},
+		wg:      &sync.WaitGroup{},
+	}
+}
+
+func (p *Promise[T]) resolve(value T) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if !p.pending {
+		return
+	}
+
+	p.result = value
+	p.pending = false
+
+	p.wg.Done()
+}
+
+// Reject returns a Promise that has been rejected with a given error.
+func Reject[T any](err error) *Promise[T] {
+	return &Promise[T]{
+		err:     err,
+		pending: false,
+		mu:      &sync.Mutex{},
+		wg:      &sync.WaitGroup{},
+	}
+}
+
+func (p *Promise[T]) reject(err error) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if !p.pending {
+		return
+	}
+
+	p.err = err
+	p.pending = false
+
+	p.wg.Done()
+}
+
+// Then allows chain calls to other promise methods.
+func Then[T1, T2 any](promise *Promise[T1], resolve1 func(value T1) T2) *Promise[T2] {
+	return New(func(resolve2 func(T2), reject func(error)) {
+		result, err := promise.Await()
+		if err != nil {
+			reject(err)
+			return
+		}
+		resolve2(resolve1(result))
+	})
+}
+
+// Then allows chain calls to other promise methods.
+func (p *Promise[T]) Then(resolve func(value T) T) *Promise[T] {
+	return New(func(_resolve func(T), reject func(error)) {
+		result, err := p.Await()
+		if err != nil {
+			reject(err)
+			return
+		}
+		_resolve(resolve(result))
+	})
+}
+
+// Catch allows to chain promises.
+func Catch[T any](promise *Promise[T], rejection func(err error) error) *Promise[T] {
+	return New(func(resolve func(T), reject func(error)) {
+		result, err := promise.Await()
+		if err != nil {
+			reject(rejection(err))
+			return
+		}
+		resolve(result)
+	})
+}
+
+// Catch chain an existing promise with an intermediate reject function.
+func (p *Promise[T]) Catch(reject func(error) error) *Promise[T] {
+	return New(func(resolve func(T), rej func(error)) {
+		resutl, err := p.Await()
+		if err != nil {
+			rej(reject(err))
+			return
+		}
+		resolve(resutl)
+	})
+}
+
+// Await blocks until the 'runable' to finish execution.
+func (p *Promise[T]) Await() (T, error) {
+	p.wg.Wait()
+	return p.result, p.err
+}
+
+type tuple[T1, T2 any] struct {
+	_1 T1
+	_2 T2
+}
+
+// All resolves when all of the promises have resolved, reject immediately upon any of the input promises rejecting.
+func All[T any](promises []*Promise[T]) *Promise[[]T] {
+	if len(promises) == 0 {
+		return nil
+	}
+
+	return New(func(resolve func([]T), reject func(error)) {
+		valsChan := make(chan tuple[T, int], len(promises))
+		errsChan := make(chan error, 1)
+
+		for idx, p := range promises {
+			idx := idx
+			_ = Then(p, func(data T) T {
+				valsChan <- tuple[T, int]{_1: data, _2: idx}
+				return data
+			})
+			_ = Catch(p, func(err error) error {
+				errsChan <- err
+				return err
+			})
+		}
+
+		resolutions := make([]T, len(promises))
+		for idx := 0; idx < len(promises); idx++ {
+			select {
+			case val := <-valsChan:
+				resolutions[val._2] = val._1
+			case err := <-errsChan:
+				reject(err)
+				return
+			}
+		}
+		resolve(resolutions)
+	})
+}
+
+// Race will settle the first fullfiled promise among muti promises.
+func Race[T any](promises []*Promise[T]) *Promise[T] {
+	if len(promises) == 0 {
+		return nil
+	}
+
+	return New(func(resolve func(T), reject func(error)) {
+		valsChan := make(chan T, 1)
+		errsChan := make(chan error, 1)
+
+		for _, p := range promises {
+			_ = Then(p, func(data T) T {
+				valsChan <- data
+				return data
+			})
+			_ = Catch(p, func(err error) error {
+				errsChan <- err
+				return err
+			})
+		}
+
+		select {
+		case val := <-valsChan:
+			resolve(val)
+		case err := <-errsChan:
+			reject(err)
+		}
+	})
+}
+
+// Any resolves as soon as any of the input's Promises resolve, with the value of the resolved Promise.
+// Any rejects if all of the given Promises are rejected with a combination of all errors.
+func Any[T any](promises []*Promise[T]) *Promise[T] {
+	if len(promises) == 0 {
+		return nil
+	}
+
+	return New(func(resolve func(T), reject func(error)) {
+		valsChan := make(chan T, 1)
+		errsChan := make(chan tuple[error, int], len(promises))
+
+		for idx, p := range promises {
+			idx := idx
+			_ = Then(p, func(data T) T {
+				valsChan <- data
+				return data
+			})
+			_ = Catch(p, func(err error) error {
+				errsChan <- tuple[error, int]{_1: err, _2: idx}
+				return err
+			})
+		}
+
+		errs := make([]error, len(promises))
+		for idx := 0; idx < len(promises); idx++ {
+			select {
+			case val := <-valsChan:
+				resolve(val)
+				return
+			case err := <-errsChan:
+				errs[err._2] = err._1
+			}
+		}
+
+		errCombo := errs[0]
+		for _, err := range errs[1:] {
+			errCombo = internal.JoinError(err)
+		}
+
+		reject(errCombo)
+	})
+}

async/promise_example_test.go

@@ -0,0 +1,195 @@
+package async
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func ExampleNew() {
+	p := New(func(resolve func(string), reject func(error)) {
+		resolve("hello")
+	})
+
+	val, err := p.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(val)
+
+	// Output:
+	// hello
+}
+
+func ExampleThen() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		resolve("hello ")
+	})
+
+	p2 := Then(p1, func(s string) string {
+		return s + "world"
+	})
+
+	result, err := p2.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(result)
+
+	// Output:
+	// hello world
+}
+
+func ExamplePromise_Then() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		resolve("hello ")
+	})
+
+	p2 := p1.Then(func(s string) string {
+		return s + "world"
+	})
+
+	result, err := p2.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(result)
+
+	// Output:
+	// hello world
+}
+
+func ExampleCatch() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		err := errors.New("error1")
+		reject(err)
+	})
+
+	p2 := Catch(p1, func(err error) error {
+		e := errors.New("error2")
+		return internal.JoinError(err, e)
+	})
+
+	_, err := p1.Await()
+
+	fmt.Println(err.Error())
+
+	result2, err := p2.Await()
+
+	fmt.Println(result2)
+	fmt.Println(err.Error())
+
+	// Output:
+	// error1
+	//
+	// error1
+	// error2
+}
+
+func ExamplePromise_Catch() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		err := errors.New("error1")
+		reject(err)
+	})
+
+	p2 := p1.Catch(func(err error) error {
+		e := errors.New("error2")
+		return internal.JoinError(err, e)
+	})
+
+	_, err := p1.Await()
+
+	fmt.Println(err.Error())
+
+	result2, err := p2.Await()
+
+	fmt.Println(result2)
+	fmt.Println(err.Error())
+
+	// Output:
+	// error1
+	//
+	// error1
+	// error2
+}
+
+func ExampleAll() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		resolve("a")
+	})
+	p2 := New(func(resolve func(string), reject func(error)) {
+		resolve("b")
+	})
+	p3 := New(func(resolve func(string), reject func(error)) {
+		resolve("c")
+	})
+
+	pms := []*Promise[string]{p1, p2, p3}
+	p := All(pms)
+
+	result, err := p.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(result)
+
+	// Output:
+	// [a b c]
+}
+
+func ExampleAny() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		time.Sleep(time.Millisecond * 250)
+		resolve("fast")
+	})
+	p2 := New(func(resolve func(string), reject func(error)) {
+		time.Sleep(time.Millisecond * 500)
+		resolve("slow")
+	})
+	p3 := New(func(resolve func(string), reject func(error)) {
+		reject(errors.New("error"))
+	})
+
+	pms := []*Promise[string]{p1, p2, p3}
+	p := Any(pms)
+
+	result, err := p.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(result)
+
+	// Output:
+	// fast
+}
+
+func ExampleRace() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		time.Sleep(time.Millisecond * 100)
+		resolve("fast")
+	})
+	p2 := New(func(resolve func(string), reject func(error)) {
+		time.Sleep(time.Millisecond * 300)
+		resolve("slow")
+	})
+
+	pms := []*Promise[string]{p1, p2}
+	p := Race(pms)
+
+	result, err := p.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(result)
+
+	// Output:
+	// fast
+}

async/promise_test.go

@@ -0,0 +1,302 @@
+package async
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestResolve(t *testing.T) {
+	assert := internal.NewAssert(t, "TestResolve")
+
+	p := Resolve("abc")
+
+	assert.Equal("abc", p.result)
+	assert.Equal(false, p.pending)
+}
+
+func TestReject(t *testing.T) {
+	assert := internal.NewAssert(t, "TestReject")
+
+	err := errors.New("error")
+	p := Reject[string](err)
+
+	assert.Equal("error", p.err.Error())
+	assert.Equal(false, p.pending)
+}
+
+func TestThen(t *testing.T) {
+	assert := internal.NewAssert(t, "TestThen")
+
+	p1 := New(func(resolve func(string), reject func(error)) {
+		resolve("abc")
+	})
+
+	p2 := Then(p1, func(data string) string {
+		return data + "de"
+	})
+
+	val, err := p1.Await()
+	assert.IsNil(err)
+	assert.Equal("abc", val)
+
+	val, err = p2.Await()
+	assert.IsNil(err)
+	assert.Equal("abcde", val)
+}
+
+func TestPromise_Then(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_Then")
+
+	p1 := New(func(resolve func(int), reject func(error)) {
+		resolve(1)
+	})
+
+	p2 := p1.Then(func(n int) int {
+		return n + 2
+	})
+
+	val, err := p1.Await()
+	assert.IsNil(err)
+	assert.Equal(1, val)
+
+	val, err = p2.Await()
+	assert.IsNil(err)
+	assert.Equal(3, val)
+}
+
+func TestCatch(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCatch")
+
+	p1 := New(func(resolve func(string), reject func(error)) {
+		err := errors.New("error1")
+		reject(err)
+	})
+
+	p2 := Catch(p1, func(err error) error {
+		e := errors.New("error2")
+		return internal.JoinError(err, e)
+	})
+
+	val, err := p1.Await()
+	assert.Equal("", val)
+	assert.IsNotNil(err)
+	assert.Equal("error1", err.Error())
+
+	val, err = p2.Await()
+
+	assert.Equal("", val)
+	assert.IsNotNil(err)
+	assert.Equal("error1\nerror2", err.Error())
+}
+
+func TestPromise_Catch(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_Catch")
+
+	p1 := New(func(resolve func(string), reject func(error)) {
+		err := errors.New("error1")
+		reject(err)
+	})
+
+	p2 := p1.Catch(func(err error) error {
+		e := errors.New("error2")
+		return internal.JoinError(err, e)
+	})
+
+	val, err := p1.Await()
+	assert.Equal("", val)
+	assert.IsNotNil(err)
+	assert.Equal("error1", err.Error())
+
+	val, err = p2.Await()
+
+	assert.Equal("", val)
+	assert.IsNotNil(err)
+	assert.Equal("error1\nerror2", err.Error())
+}
+
+func TestAll(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_All")
+
+	t.Run("AllPromisesFullfilled", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			resolve("a")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			resolve("b")
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			resolve("c")
+		})
+
+		p := All([]*Promise[string]{p1, p2, p3})
+
+		val, err := p.Await()
+		assert.Equal([]string{"a", "b", "c"}, val)
+		assert.IsNil(err)
+	})
+
+	t.Run("EmptyPromises", func(_ *testing.T) {
+		var empty = []*Promise[any]{}
+		p := All(empty)
+		assert.IsNil(p)
+	})
+
+	t.Run("PromisesContainRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			resolve("a")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+
+		p := All([]*Promise[string]{p1, p2, p3})
+
+		_, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+	})
+
+	t.Run("PromisesOnlyRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error3"))
+		})
+
+		p := All([]*Promise[string]{p1, p2, p3})
+
+		_, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+	})
+
+}
+
+func TestAny(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_Any")
+
+	t.Run("AnyFullfilled", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 250)
+			resolve("fast")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 500)
+			resolve("slow")
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error"))
+		})
+
+		p := Any([]*Promise[string]{p1, p2, p3})
+
+		val, err := p.Await()
+		assert.Equal("fast", val)
+		assert.IsNil(err)
+	})
+
+	t.Run("EmptyPromises", func(_ *testing.T) {
+		var empty = []*Promise[any]{}
+		p := Any(empty)
+		assert.IsNil(p)
+	})
+
+	t.Run("OnlyRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+
+		p := Any([]*Promise[string]{p1, p2})
+
+		_, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+	})
+
+}
+
+func TestRace(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_Race")
+
+	t.Run("PromisesFullfilled", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 100)
+			resolve("a")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 300)
+			resolve("b")
+		})
+
+		p := Race([]*Promise[string]{p1, p2})
+
+		val, err := p.Await()
+		assert.Equal("a", val)
+		assert.IsNil(err)
+	})
+
+	t.Run("EmptyPromises", func(_ *testing.T) {
+		var empty = []*Promise[any]{}
+		p := Race(empty)
+		assert.IsNil(p)
+	})
+
+	t.Run("PromisesContainRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 100)
+			resolve("a")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+
+		p := Race([]*Promise[string]{p1, p2, p3})
+
+		val, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+		assert.Equal("", val)
+	})
+
+	t.Run("PromisesOnlyRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error3"))
+		})
+
+		p := Race([]*Promise[string]{p1, p2, p3})
+
+		_, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+	})
+
+}

concurrency/channel.go

@@ -1,7 +1,7 @@
 // Copyright 2021 dudaodong@gmail.com. All rights reserved.
 // Use of this source code is governed by MIT license
 
-// Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel, async.
+// Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel.
 package concurrency
 
 import (

convertor/convertor.go

@@ -9,10 +9,11 @@ import (
 	"encoding/binary"
 	"encoding/gob"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
 	"math"
 	"reflect"
-	"regexp"
 	"strconv"
 	"strings"
 )
@@ -234,31 +235,7 @@ func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K
 // map key is specified same as struct field tag `json` value.
 // Play: https://go.dev/play/p/KYGYJqNUBOI
 func StructToMap(value any) (map[string]any, error) {
-	v := reflect.ValueOf(value)
+	return structs.ToMap(value)
-	t := reflect.TypeOf(value)
-
-	if t.Kind() == reflect.Ptr {
-		t = t.Elem()
-	}
-	if t.Kind() != reflect.Struct {
-		return nil, fmt.Errorf("data type %T not support, shuld be struct or pointer to struct", value)
-	}
-
-	result := make(map[string]any)
-
-	fieldNum := t.NumField()
-	pattern := `^[A-Z]`
-	regex := regexp.MustCompile(pattern)
-	for i := 0; i < fieldNum; i++ {
-		name := t.Field(i).Name
-		tag := t.Field(i).Tag.Get("json")
-		if regex.MatchString(name) && tag != "" {
-			//result[name] = v.Field(i).Interface()
-			result[tag] = v.Field(i).Interface()
-		}
-	}
-
-	return result, nil
 }
 
 // MapToSlice convert map to slice based on iteratee function.
@@ -327,7 +304,7 @@ func DecodeByte(data []byte, target any) error {
 
 // DeepClone creates a deep copy of passed item.
 // can't clone unexported field of struct
-// Play: todo
+// Play: https://go.dev/play/p/j4DP5dquxnk
 func DeepClone[T any](src T) T {
 	c := cloner{
 		ptrs: map[reflect.Type]map[uintptr]reflect.Value{},
@@ -340,3 +317,46 @@ func DeepClone[T any](src T) T {
 
 	return result.Interface().(T)
 }
+
+// CopyProperties copies each field from the source into the destination. It recursively copies struct pointers and interfaces that contain struct pointers.
+// 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)
+
+	if dstType.Kind() != reflect.Ptr || dstType.Elem().Kind() != reflect.Struct {
+		return errors.New("CopyProperties: param dst should be struct pointer")
+	}
+
+	if srcType.Kind() == reflect.Ptr {
+		srcType, srcValue = srcType.Elem(), srcValue.Elem()
+	}
+	if srcType.Kind() != reflect.Struct {
+		return errors.New("CopyProperties: param 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)
+		}
+	}
+
+	return nil
+}

convertor/convertor_example_test.go

@@ -260,7 +260,7 @@ func ExampleDeepClone() {
 		Float float64
 		Bool  bool
 		Nil   interface{}
-		unexported string
+		// unexported string
 	}
 
 	cases := []interface{}{
@@ -295,3 +295,51 @@ func ExampleDeepClone() {
 	// map[a:1 b:2] false
 	// &{test 1 0.1 true <nil>} false
 }
+
+func ExampleCopyProperties() {
+	type Address struct {
+		Country string
+		ZipCode string
+	}
+
+	type User struct {
+		Name   string
+		Age    int
+		Role   string
+		Addr   Address
+		Hobbys []string
+		salary int
+	}
+
+	type Employee struct {
+		Name   string
+		Age    int
+		Role   string
+		Addr   Address
+		Hobbys []string
+		salary int
+	}
+
+	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
+	}
+
+	employee2 := Employee{Name: "employee001", Age: 20, Role: "User",
+		Addr: Address{Country: "UK", ZipCode: "002"}, salary: 500}
+
+	err = CopyProperties(&employee2, &user)
+	if err != nil {
+		return
+	}
+
+	fmt.Println(employee1)
+	fmt.Println(employee2)
+
+	// Output:
+	// {user001 10 Admin {CN 001} [a b] 0}
+	// {user001 10 Admin {CN 001} [a b] 500}
+}

convertor/convertor_test.go

@@ -180,6 +180,7 @@ func TestToMap(t *testing.T) {
 func TestStructToMap(t *testing.T) {
 	assert := internal.NewAssert(t, "TestStructToMap")
 
+	t.Run("StructToMap", func(_ *testing.T) {
 		type People struct {
 			Name string `json:"name"`
 			age  int
@@ -189,9 +190,26 @@ func TestStructToMap(t *testing.T) {
 			100,
 		}
 		pm, _ := StructToMap(p)
-
+		var expected = map[string]any{"name": "test"}
-	expected := map[string]any{"name": "test"}
 		assert.Equal(expected, pm)
+	})
+
+	t.Run("StructToMapWithJsonAttr", func(_ *testing.T) {
+		type People struct {
+			Name  string `json:"name,omitempty"` // json tag with attribute
+			Phone string `json:"phone"`          // json tag without attribute
+			Sex   string `json:"-"`              // ignore
+			age   int    // no tag
+		}
+		p := People{
+			Phone: "1111",
+			Sex:   "male",
+			age:   100,
+		}
+		pm, _ := StructToMap(p)
+		var expected = map[string]any{"phone": "1111"}
+		assert.Equal(expected, pm)
+	})
 }
 
 func TestMapToSlice(t *testing.T) {
@@ -264,7 +282,7 @@ func TestDeepClone(t *testing.T) {
 		Float float64
 		Bool  bool
 		Nil   interface{}
-		unexported string
+		// unexported string
 	}
 
 	cases := []interface{}{
@@ -298,3 +316,53 @@ func TestDeepClone(t *testing.T) {
 		}
 	}
 }
+
+func TestCopyProperties(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCopyProperties")
+
+	type Address struct {
+		Country string
+		ZipCode string
+	}
+
+	type User struct {
+		Name   string
+		Age    int
+		Role   string
+		Addr   Address
+		Hobbys []string
+		salary int
+	}
+
+	type Employee struct {
+		Name   string
+		Age    int
+		Role   string
+		Addr   Address
+		Hobbys []string
+		salary int
+	}
+
+	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)
+
+	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)
+}

datastructure/set/set.go

@@ -171,3 +171,25 @@ func (s Set[T]) Minus(comparedSet Set[T]) Set[T] {
 
 	return set
 }
+
+// EachWithBreak iterates over elements of a set and invokes function for each element,
+// when iteratee return false, will break the for each loop.
+func (s Set[T]) EachWithBreak(iteratee func(item T) bool) {
+	for v := range s {
+		if !iteratee(v) {
+			break
+		}
+	}
+}
+
+// Pop delete the top element of set then return it, if set is empty, return nil-value of T and false.
+func (s Set[T]) Pop() (v T, ok bool) {
+	if len(s) > 0 {
+		items := s.Values()
+		item := items[len(s)-1]
+		delete(s, item)
+		return item, true
+	}
+
+	return v, false
+}

datastructure/set/set_test.go

@@ -192,3 +192,40 @@ func TestSet_Minus(t *testing.T) {
 	assert.Equal(NewSet(1), set1.Minus(set2))
 	assert.Equal(NewSet(4, 5), set2.Minus(set3))
 }
+
+func TestEachWithBreak(t *testing.T) {
+	s := NewSet(1, 2, 3, 4, 5)
+
+	var sum int
+
+	s.EachWithBreak(func(n int) bool {
+		if n > 3 {
+			return false
+		}
+		sum += n
+		return true
+	})
+
+	assert := internal.NewAssert(t, "TestEachWithBreak")
+	assert.Equal(6, sum)
+}
+
+// func TestPop(t *testing.T) {
+// 	assert := internal.NewAssert(t, "TestPop")
+
+// 	s := NewSet[int]()
+
+// 	val, ok := s.Pop()
+// 	assert.Equal(0, val)
+// 	assert.Equal(false, ok)
+
+// 	s.Add(1)
+// 	s.Add(2)
+// 	s.Add(3)
+
+// 	// s = NewSet(1, 2, 3, 4, 5)
+
+// 	val, ok = s.Pop()
+// 	assert.Equal(3, val)
+// 	assert.Equal(true, ok)
+// }

docs/concurrency.md

@@ -1,5 +1,5 @@
 # Concurrency
-Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel, async.
+Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel.
 
 <div STYLE="page-break-after: always;"></div>
 

docs/concurrency_zh-CN.md

@@ -1,5 +1,5 @@
 # Concurrency
-并发包包含一些支持并发编程的功能。例如：goroutine, channel, async等。
+并发包包含一些支持并发编程的功能。例如：goroutine, channel等。
 
 <div STYLE="page-break-after: always;"></div>
 

docs/convertor.md

@@ -39,6 +39,7 @@ import (
 -   [EncodeByte](#EncodeByte)
 -   [DecodeByte](#DecodeByte)
 -   [DeepClone](#DeepClone)
+-   [CopyProperties](#CopyProperties)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -692,3 +693,67 @@ func main() {
     // &{test 1 0.1 true <nil> } false
 }
 ```
+
+
+### <span id="CopyProperties">CopyProperties</span>
+
+<p>Copies each field from the source struct into the destination struct.</p>
+
+<b>Signature:</b>
+
+```go
+func CopyProperties[T, U any](dst T, src U) (err error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    type Address struct {
+        Country string
+        ZipCode string
+    }
+
+    type User struct {
+        Name   string
+        Age    int
+        Role   string
+        Addr   Address
+        Hobbys []string
+        salary int
+    }
+
+    type Employee struct {
+        Name   string
+        Age    int
+        Role   string
+        Addr   Address
+        Hobbys []string
+        salary int
+    }
+
+    user := User{Name: "user001", Age: 10, Role: "Admin", Addr: Address{Country: "CN", ZipCode: "001"}, Hobbys: []string{"a", "b"}, salary: 1000}
+
+    employee1 := Employee{}
+    CopyProperties(&employee1, &user)
+
+    employee2 := Employee{Name: "employee001", Age: 20, Role: "User",
+        Addr: Address{Country: "UK", ZipCode: "002"}, salary: 500}
+
+    CopyProperties(&employee2, &user)
+
+    fmt.Println(employee1)
+    fmt.Println(employee2)
+
+    // Output:
+    // {user001 10 Admin {CN 001} [a b] 0}
+    // {user001 10 Admin {CN 001} [a b] 500}
+}
+```

docs/convertor_zh-CN.md

@@ -39,6 +39,8 @@ import (
 -   [EncodeByte](#EncodeByte)
 -   [DecodeByte](#DecodeByte)
 -   [DeepClone](#DeepClone)
+-   [CopyProperties](#CopyProperties)
+
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -691,3 +693,66 @@ func main() {
     // &{test 1 0.1 true <nil> } false
 }
 ```
+
+### <span id="CopyProperties">CopyProperties</span>
+
+<p>拷贝不同结构体之间的同名字段。</p>
+
+<b>函数签名:</b>
+
+```go
+func CopyProperties[T, U any](dst T, src U) (err error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    type Address struct {
+        Country string
+        ZipCode string
+    }
+
+    type User struct {
+        Name   string
+        Age    int
+        Role   string
+        Addr   Address
+        Hobbys []string
+        salary int
+    }
+
+    type Employee struct {
+        Name   string
+        Age    int
+        Role   string
+        Addr   Address
+        Hobbys []string
+        salary int
+    }
+
+    user := User{Name: "user001", Age: 10, Role: "Admin", Addr: Address{Country: "CN", ZipCode: "001"}, Hobbys: []string{"a", "b"}, salary: 1000}
+
+    employee1 := Employee{}
+    CopyProperties(&employee1, &user)
+
+    employee2 := Employee{Name: "employee001", Age: 20, Role: "User",
+        Addr: Address{Country: "UK", ZipCode: "002"}, salary: 500}
+
+    CopyProperties(&employee2, &user)
+
+    fmt.Println(employee1)
+    fmt.Println(employee2)
+
+    // Output:
+    // {user001 10 Admin {CN 001} [a b] 0}
+    // {user001 10 Admin {CN 001} [a b] 500}
+}
+```

docs/datastructure/set.md

@@ -1,4 +1,5 @@
 # Set
+
 Set is a data container, like list, but elements of set is not duplicate.
 
 <div STYLE="page-break-after: always;"></div>
@@ -7,10 +8,10 @@ Set is a data container, like list, but elements of set is not duplicate.
 
 -   [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)
 
-
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage
+
 ```go
 import (
     set "github.com/duke-git/lancet/v2/datastructure/set"
@@ -34,19 +35,19 @@ import (
 -   [Size](#Size)
 -   [Equal](#Equal)
 -   [Iterate](#Iterate)
+-   [EachWithBreak](#EachWithBreak)
 -   [IsEmpty](#IsEmpty)
 -   [Union](#Union)
 -   [Intersection](#Intersection)
 -   [SymmetricDifference](#SymmetricDifference)
 -   [Minus](#Minus)
 
-
-
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
 ### <span id="NewSet">NewSet</span>
+
 <p>Create a set instance</p>
 
 <b>Signature:</b>
@@ -55,6 +56,7 @@ import (
 type Set[T comparable] map[T]bool
 func NewSet[T comparable](items ...T) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -71,8 +73,8 @@ func main() {
 }
 ```
 
-
 ### <span id="NewSetFromSlice">NewSetFromSlice</span>
+
 <p>Create a set from slice</p>
 
 <b>Signature:</b>
@@ -80,6 +82,7 @@ func main() {
 ```go
 func NewSetFromSlice[T comparable](items []T) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -96,9 +99,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Values">Values</span>
+
 <p>Return slice of all set data</p>
 
 <b>Signature:</b>
@@ -106,6 +108,7 @@ func main() {
 ```go
 func (s Set[T]) Values() []T
 ```
+
 <b>Example:</b>
 
 ```go
@@ -122,10 +125,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Add">Add</span>
+
 <p>Add items to set</p>
 
 <b>Signature:</b>
@@ -133,6 +134,7 @@ func main() {
 ```go
 func (s Set[T]) Add(items ...T)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -151,8 +153,8 @@ func main() {
 }
 ```
 
-
 ### <span id="AddIfNotExist">AddIfNotExist</span>
+
 <p>AddIfNotExist checks if item exists in the set, it adds the item to set and returns true if it does not exist in the set, or else it does nothing and returns false.</p>
 
 <b>Signature:</b>
@@ -160,6 +162,7 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExist(item T) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -183,8 +186,8 @@ func main() {
 }
 ```
 
-
 ### <span id="AddIfNotExistBy">AddIfNotExistBy</span>
+
 <p>AddIfNotExistBy checks if item exists in the set and pass the `checker` function it adds the item to set and returns true if it does not exists in the set and function `checker` returns true, or else it does nothing and returns false.</p>
 
 <b>Signature:</b>
@@ -192,6 +195,7 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -221,8 +225,8 @@ func main() {
 }
 ```
 
-
 ### <span id="Delete">Delete</span>
+
 <p>Delete item in set</p>
 
 <b>Signature:</b>
@@ -230,6 +234,7 @@ func main() {
 ```go
 func (s Set[T]) Delete(items ...T)
 ```
+
 <b>Example:</b>
 
 ```go
@@ -249,9 +254,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Contain">Contain</span>
+
 <p>Check if item is in set or not</p>
 
 <b>Signature:</b>
@@ -259,6 +263,7 @@ func main() {
 ```go
 func (s Set[T]) Contain(item T) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -278,10 +283,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="ContainAll">ContainAll</span>
+
 <p>Checks if set contains another set</p>
 
 <b>Signature:</b>
@@ -289,6 +292,7 @@ func main() {
 ```go
 func (s Set[T]) ContainAll(other Set[T]) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -309,9 +313,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Size">Size</span>
+
 <p>Get the number of elements in set</p>
 
 <b>Signature:</b>
@@ -319,6 +322,7 @@ func main() {
 ```go
 func (s Set[T]) Size() int
 ```
+
 <b>Example:</b>
 
 ```go
@@ -336,9 +340,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Clone">Clone</span>
+
 <p>Make a copy of set</p>
 
 <b>Signature:</b>
@@ -346,6 +349,7 @@ func main() {
 ```go
 func (s Set[T]) Clone() Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -365,10 +369,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Equal">Equal</span>
+
 <p>Check if two sets has same elements or not</p>
 
 <b>Signature:</b>
@@ -376,6 +378,7 @@ func main() {
 ```go
 func (s Set[T]) Equal(other Set[T]) bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -396,9 +399,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Iterate">Iterate</span>
+
 <p>Call function by every element of set</p>
 
 <b>Signature:</b>
@@ -406,6 +408,7 @@ func main() {
 ```go
 func (s Set[T]) Iterate(fn func(item T))
 ```
+
 <b>Example:</b>
 
 ```go
@@ -427,9 +430,45 @@ func main() {
 }
 ```
 
+### <span id="EachWithBreak">EachWithBreak</span>
 
+<p>Iterates over elements of a set and invokes function for each element, when iteratee return false, will break the for each loop.</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) EachWithBreak(iteratee func(item T) bool)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet(1, 2, 3, 4, 5)
+
+    var sum int
+
+    s.EachWithBreak(func(n int) bool {
+        if n > 3 {
+            return false
+        }
+        sum += n
+        return true
+    })
+
+    fmt.Println(sum) //6
+}
+```
 
 ### <span id="IsEmpty">IsEmpty</span>
+
 <p>Check if the set is empty or not</p>
 
 <b>Signature:</b>
@@ -437,6 +476,7 @@ func main() {
 ```go
 func (s Set[T]) IsEmpty() bool
 ```
+
 <b>Example:</b>
 
 ```go
@@ -456,9 +496,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Union">Union</span>
+
 <p>Create a new set contain all element of set s and other</p>
 
 <b>Signature:</b>
@@ -466,6 +505,7 @@ func main() {
 ```go
 func (s Set[T]) Union(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -485,9 +525,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Intersection">Intersection</span>
+
 <p>Create a new set whose element both be contained in set s and other</p>
 
 <b>Signature:</b>
@@ -495,6 +534,7 @@ func main() {
 ```go
 func (s Set[T]) Intersection(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -514,11 +554,8 @@ func main() {
 }
 ```
 
-
-
-
-
 ### <span id="SymmetricDifference">SymmetricDifference</span>
+
 <p>Create a new set whose element is in set1 or set2, but not in both set1 and set2</p>
 
 <b>Signature:</b>
@@ -526,6 +563,7 @@ func main() {
 ```go
 func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -545,11 +583,8 @@ func main() {
 }
 ```
 
-
-
-
-
 ### <span id="Minus">Minus</span>
+
 <p>Create an set of whose element in origin set but not in compared set</p>
 
 <b>Signature:</b>
@@ -557,6 +592,7 @@ func main() {
 ```go
 func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
 ```
+
 <b>Example:</b>
 
 ```go
@@ -580,5 +616,35 @@ func main() {
 }
 ```
 
+### <span id="Pop">Pop</span>
 
+<p>Delete the top element of set then return it, if set is empty, return nil-value of T and false.</p>
 
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Pop() (v T, ok bool)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet[int]()
+    s.Add(1)
+    s.Add(2)
+    s.Add(3)
+
+    val, ok = s.Pop()
+
+    fmt.Println(val) // 3
+    fmt.Println(ok) // true
+}
+```

docs/datastructure/set_zh-CN.md

@@ -1,4 +1,5 @@
 # Set
+
 Set 集合数据结构，类似列表。Set 中元素不重复。
 
 <div STYLE="page-break-after: always;"></div>
@@ -7,10 +8,10 @@ Set集合数据结构，类似列表。Set中元素不重复。
 
 -   [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)
 
-
 <div STYLE="page-break-after: always;"></div>
 
 ## 用法
+
 ```go
 import (
     set "github.com/duke-git/lancet/v2/datastructure/set"
@@ -40,13 +41,12 @@ import (
 -   [SymmetricDifference](#SymmetricDifference)
 -   [Minus](#Minus)
 
-
-
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
 ### <span id="NewSet">NewSet</span>
+
 <p>返回Set结构体对象</p>
 
 <b>函数签名:</b>
@@ -55,6 +55,7 @@ import (
 type Set[T comparable] map[T]bool
 func NewSet[T comparable](items ...T) Set[T]
 ```
+
 <b>示例:</b>
 
 ```go
@@ -71,9 +72,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="NewSetFromSlice">NewSetFromSlice</span>
+
 <p>基于切片创建集合</p>
 
 <b>函数签名:</b>
@@ -81,6 +81,7 @@ func main() {
 ```go
 func NewSetFromSlice[T comparable](items []T) Set[T]
 ```
+
 <b>示例:</b>
 
 ```go
@@ -97,9 +98,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Values">Values</span>
+
 <p>获取集合中所有元素的切片</p>
 
 <b>函数签名:</b>
@@ -107,6 +107,7 @@ func main() {
 ```go
 func (s Set[T]) Values() []T
 ```
+
 <b>示例:</b>
 
 ```go
@@ -123,10 +124,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Add">Add</span>
+
 <p>向集合中添加元素</p>
 
 <b>函数签名:</b>
@@ -134,6 +133,7 @@ func main() {
 ```go
 func (s Set[T]) Add(items ...T)
 ```
+
 <b>示例:</b>
 
 ```go
@@ -152,8 +152,8 @@ func main() {
 }
 ```
 
-
 ### <span id="AddIfNotExist">AddIfNotExist</span>
+
 <p>如果集合中不存在元素，则添加该元素返回true, 如果集合中存在元素, 不做任何操作，返回false</p>
 
 <b>函数签名:</b>
@@ -161,6 +161,7 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExist(item T) bool
 ```
+
 <b>示例:</b>
 
 ```go
@@ -184,8 +185,8 @@ func main() {
 }
 ```
 
-
 ### <span id="AddIfNotExistBy">AddIfNotExistBy</span>
+
 <p>根据checker函数判断元素是否在集合中，如果集合中不存在元素且checker返回true，则添加该元素返回true, 否则不做任何操作，返回false</p>
 
 <b>函数签名:</b>
@@ -193,6 +194,7 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool
 ```
+
 <b>示例:</b>
 
 ```go
@@ -222,9 +224,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Delete">Delete</span>
+
 <p>删除集合中元素</p>
 
 <b>函数签名:</b>
@@ -232,6 +233,7 @@ func main() {
 ```go
 func (s Set[T]) Delete(items ...T)
 ```
+
 <b>示例:</b>
 
 ```go
@@ -251,9 +253,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Contain">Contain</span>
+
 <p>判断集合是否包含某个值</p>
 
 <b>函数签名:</b>
@@ -261,6 +262,7 @@ func main() {
 ```go
 func (s Set[T]) Contain(item T) bool
 ```
+
 <b>示例:</b>
 
 ```go
@@ -280,10 +282,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="ContainAll">ContainAll</span>
+
 <p>判断集合是否包含另一个集合</p>
 
 <b>函数签名:</b>
@@ -291,6 +291,7 @@ func main() {
 ```go
 func (s Set[T]) ContainAll(other Set[T]) bool
 ```
+
 <b>示例:</b>
 
 ```go
@@ -311,9 +312,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Size">Size</span>
+
 <p>获取集合中元素的个数</p>
 
 <b>函数签名:</b>
@@ -321,6 +321,7 @@ func main() {
 ```go
 func (s Set[T]) Size() int
 ```
+
 <b>示例:</b>
 
 ```go
@@ -338,9 +339,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Clone">Clone</span>
+
 <p>克隆一个集合</p>
 
 <b>函数签名:</b>
@@ -348,6 +348,7 @@ func main() {
 ```go
 func (s Set[T]) Clone() Set[T]
 ```
+
 <b>示例:</b>
 
 ```go
@@ -367,10 +368,8 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="Equal">Equal</span>
+
 <p>比较两个集合是否相等，包含相同元素为相等</p>
 
 <b>函数签名:</b>
@@ -378,6 +377,7 @@ func main() {
 ```go
 func (s Set[T]) Equal(other Set[T]) bool
 ```
+
 <b>示例:</b>
 
 ```go
@@ -398,9 +398,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Iterate">Iterate</span>
+
 <p>迭代结合，在每个元素上调用函数</p>
 
 <b>函数签名:</b>
@@ -408,6 +407,7 @@ func main() {
 ```go
 func (s Set[T]) Iterate(fn func(item T))
 ```
+
 <b>示例:</b>
 
 ```go
@@ -429,9 +429,45 @@ func main() {
 }
 ```
 
+### <span id="EachWithBreak">EachWithBreak</span>
 
+<p>遍历集合的元素并为每个元素调用iteratee函数，当iteratee函数返回false时，终止遍历。</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) EachWithBreak(iteratee func(item T) bool)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet(1, 2, 3, 4, 5)
+
+    var sum int
+
+    s.EachWithBreak(func(n int) bool {
+        if n > 3 {
+            return false
+        }
+        sum += n
+        return true
+    })
+
+    fmt.Println(sum) //6
+}
+```
 
 ### <span id="IsEmpty">IsEmpty</span>
+
 <p>判断集合是否为空</p>
 
 <b>函数签名:</b>
@@ -439,6 +475,7 @@ func main() {
 ```go
 func (s Set[T]) IsEmpty() bool
 ```
+
 <b>示例:</b>
 
 ```go
@@ -458,9 +495,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Union">Union</span>
+
 <p>求两个集合的并集</p>
 
 <b>函数签名:</b>
@@ -468,6 +504,7 @@ func main() {
 ```go
 func (s Set[T]) Union(other Set[T]) Set[T]
 ```
+
 <b>示例:</b>
 
 ```go
@@ -487,9 +524,8 @@ func main() {
 }
 ```
 
-
-
 ### <span id="Intersection">Intersection</span>
+
 <p>求两个集合的交集</p>
 
 <b>函数签名:</b>
@@ -497,6 +533,7 @@ func main() {
 ```go
 func (s Set[T]) Intersection(other Set[T]) Set[T]
 ```
+
 <b>示例:</b>
 
 ```go
@@ -516,8 +553,8 @@ func main() {
 }
 ```
 
-
 ### <span id="SymmetricDifference">SymmetricDifference</span>
+
 <p>返回一个集合，其中元素在第一个集合或第二个集合中，且不同时存在于两个集合中</p>
 
 <b>函数签名:</b>
@@ -525,6 +562,7 @@ func main() {
 ```go
 func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
 ```
+
 <b>示例:</b>
 
 ```go
@@ -544,11 +582,8 @@ func main() {
 }
 ```
 
-
-
-
-
 ### <span id="Minus">Minus</span>
+
 <p>创建一个集合，其元素在原始集中但不在比较集中</p>
 
 <b>函数签名:</b>
@@ -556,6 +591,7 @@ func main() {
 ```go
 func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
 ```
+
 <b>示例:</b>
 
 ```go
@@ -579,5 +615,35 @@ func main() {
 }
 ```
 
+### <span id="Pop">Pop</span>
 
+<p>删除并返回集合中的顶部元素</p>
 
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Pop() (v T, ok bool)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet[int]()
+    s.Add(1)
+    s.Add(2)
+    s.Add(3)
+
+    val, ok = s.Pop()
+
+    fmt.Println(val) // 3
+    fmt.Println(ok) // true
+}
+```

docs/function.md

@@ -29,6 +29,7 @@ import (
 -   [Compose](#Compose)
 -   [Debounced](#Debounced)
 -   [Delay](#Delay)
+-   [Schedule](#Schedule)
 -   [Pipeline](#Pipeline)
 -   [Watcher](#Watcher)
 

docs/function_zh-CN.md

@@ -29,6 +29,7 @@ import (
 -   [Compose](#Compose)
 -   [Debounced](#Debounced)
 -   [Delay](#Delay)
+-   [Schedule](#Schedule)
 -   [Pipeline](#Pipeline)
 -   [Watcher](#Watcher)
 

docs/maputil.md

@@ -24,11 +24,23 @@ import (
 
 -   [ForEach](#ForEach)
 -   [Filter](#Filter)
+-   [FilterByKeys](#FilterByKeys)
+-   [FilterByValues](#FilterByValues)
+-   [OmitBy](#OmitBy)
+-   [OmitByKeys](#OmitByKeys)
+-   [OmitByValues](#OmitByValues)
 -   [Intersect](#Intersect)
 -   [Keys](#Keys)
+-   [Values](#Values)
+-   [KeysBy](#KeysBy)
+-   [ValuesBy](#ValuesBy)
+-   [MapKeys](#MapKeys)
+-   [MapValues](#MapValues)
+-   [Entries](#Entries)
+-   [FromEntries](#FromEntries)
+-   [Transform](#Transform)
 -   [Merge](#Merge)
 -   [Minus](#Minus)
--   [Values](#Values)
 -   [IsDisjoint](#IsDisjoint)
 
 <div STYLE="page-break-after: always;"></div>
@@ -121,6 +133,205 @@ func main() {
 }
 ```
 
+
+### <span id="FilterByKeys">FilterByKeys</span>
+
+<p>Iterates over map, return a new map whose keys are all given keys.</p>
+
+<b>Signature:</b>
+
+```go
+func FilterByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": 4,
+        "e": 5,
+    }
+
+    result := maputil.FilterByKeys(m, []string{"a", "b"})
+
+    fmt.Println(result)
+
+    // Output:
+    // map[a:1 b:2]
+}
+```
+
+
+### <span id="FilterByValues">FilterByValues</span>
+
+<p>Iterates over map, return a new map whose values are all given values.</p>
+
+<b>Signature:</b>
+
+```go
+func FilterByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": 4,
+        "e": 5,
+    }
+
+    result := maputil.FilterByValues(m, []int{3, 4})
+
+    fmt.Println(result)
+
+    // Output:
+    // map[c:3 d:4]
+}
+```
+
+
+### <span id="OmitBy">OmitBy</span>
+
+<p>OmitBy is the opposite of Filter, removes all the map elements for which the predicate function returns true.</p>
+
+<b>Signature:</b>
+
+```go
+func OmitBy[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": 4,
+        "e": 5,
+    }
+    isEven := func(_ string, value int) bool {
+        return value%2 == 0
+    }
+
+    result := maputil.OmitBy(m, isEven)
+
+    fmt.Println(result)
+
+    // Output:
+    // map[a:1 c:3 e:5]
+}
+```
+
+
+### <span id="OmitByKeys">OmitByKeys</span>
+
+<p>The opposite of FilterByKeys, extracts all the map elements which keys are not omitted.</p>
+
+<b>Signature:</b>
+
+```go
+func OmitByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": 4,
+        "e": 5,
+    }
+
+    result := maputil.OmitByKeys(m, []string{"a", "b"})
+
+    fmt.Println(result)
+
+    // Output:
+    // map[c:3 d:4 e:5]
+}
+```
+
+
+### <span id="OmitByValues">OmitByValues</span>
+
+<p>The opposite of FilterByValues. remov all elements whose value are in the give slice.</p>
+
+<b>Signature:</b>
+
+```go
+func OmitByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": 4,
+        "e": 5,
+    }
+
+    result := maputil.OmitByValues(m, []int{4, 5})
+
+    fmt.Println(result)
+
+    // Output:
+    // map[a:1 b:2 c:3]
+}
+```
+
+
 ### <span id="Intersect">Intersect</span>
 
 <p>Iterates over maps, return a new map of key and value pairs in all given maps.</p>
@@ -193,6 +404,7 @@ package main
 
 import (
     "fmt"
+    "sort"
     "github.com/duke-git/lancet/v2/maputil"
 )
 
@@ -313,6 +525,7 @@ package main
 
 import (
     "fmt"
+    "sort"
     "github.com/duke-git/lancet/v2/maputil"
 )
 
@@ -335,6 +548,300 @@ func main() {
 }
 ```
 
+### <span id="KeysBy">KeysBy</span>
+
+<p>Creates a slice whose element is the result of function mapper invoked by every map's key.</p>
+
+<b>Signature:</b>
+
+```go
+func KeysBy[K comparable, V any, T any](m map[K]V, mapper func(item K) T) []T
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "sort"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[int]string{
+        1: "a",
+        2: "a",
+        3: "b",
+    }
+
+    keys := maputil.KeysBy(m, func(n int) int {
+        return n + 1
+    })
+
+    sort.Ints(keys)
+
+    fmt.Println(keys)
+
+    // Output:
+    // [2 3 4]
+}
+```
+
+### <span id="ValuesBy">ValuesBy</span>
+
+<p>Creates a slice whose element is the result of function mapper invoked by every map's value.</p>
+
+<b>Signature:</b>
+
+```go
+func ValuesBy[K comparable, V any, T any](m map[K]V, mapper func(item V) T) []T
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "sort"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[int]string{
+        1: "a",
+        2: "b",
+        3: "c",
+    }
+    values := maputil.ValuesBy(m, func(v string) string {
+        switch v {
+        case "a":
+            return "a-1"
+        case "b":
+            return "b-2"
+        case "c":
+            return "c-3"
+        default:
+            return ""
+        }
+    })
+
+    sort.Strings(values)
+
+    fmt.Println(values)
+
+    // Output:
+    // [a-1 b-2 c-3]
+}
+```
+
+
+### <span id="MapKeys">MapKeys</span>
+
+<p>Transforms a map to other type map by manipulating it's keys.</p>
+
+<b>Signature:</b>
+
+```go
+func MapKeys[K comparable, V any, T comparable](m map[K]V, iteratee func(key K, value V) T) map[T]V
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "strconv"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[int]string{
+        1: "a",
+        2: "b",
+        3: "c",
+    }
+
+    result := maputil.MapKeys(m, func(k int, _ string) string {
+        return strconv.Itoa(k)
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // map[1:a 2:b 3:c]
+}
+```
+
+### <span id="MapValues">MapValues</span>
+
+<p>Transforms a map to other type map by manipulating it's values.</p>
+
+<b>Signature:</b>
+
+```go
+func MapValues[K comparable, V any, T any](m map[K]V, iteratee func(key K, value V) T) map[K]T
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "strconv"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[int]string{
+        1: "a",
+        2: "b",
+        3: "c",
+    }
+
+    result := maputil.MapValues(m, func(k int, v string) string {
+        return v + strconv.Itoa(k)
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // map[1:a1 2:b2 3:c3]
+}
+```
+
+
+### <span id="Entry">Entry</span>
+
+<p>Transforms a map into array of key/value pairs.</p>
+
+<b>Signature:</b>
+
+```go
+type Entry[K comparable, V any] struct {
+    Key   K
+    Value V
+}
+func Entries[K comparable, V any](m map[K]V) []Entry[K, V]
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "sort"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+    }
+
+    result := maputil.Entries(m)
+
+    sort.Slice(result, func(i, j int) bool {
+        return result[i].Value < result[j].Value
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // [{a 1} {b 2} {c 3}]
+}
+```
+
+
+### <span id="FromEntries">FromEntries</span>
+
+<p>Creates a map based on a slice of key/value pairs.</p>
+
+<b>Signature:</b>
+
+```go
+type Entry[K comparable, V any] struct {
+    Key   K
+    Value V
+}
+func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    result := maputil.FromEntries([]Entry[string, int]{
+        {Key: "a", Value: 1},
+        {Key: "b", Value: 2},
+        {Key: "c", Value: 3},
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // map[a:1 b:2 c:3]
+}
+```
+
+### <span id="Transform">Transform</span>
+
+<p>Transform a map to another type map.</p>
+
+<b>Signature:</b>
+
+```go
+func Transform[K1 comparable, V1 any, K2 comparable, V2 any](m map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "strconv"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+    }
+
+    result := Transform(m, func(k string, v int) (string, string) {
+        return k, strconv.Itoa(v)
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // map[a:1 b:2 c:3]
+}
+```
+
+
 ### <span id="IsDisjoint">IsDisjoint</span>
 
 <p>Checks two maps are disjoint if they have no keys in common</p>

docs/maputil_zh-CN.md

@@ -24,11 +24,23 @@ import (
 
 -   [ForEach](#ForEach)
 -   [Filter](#Filter)
+-   [FilterByKeys](#FilterByKeys)
+-   [FilterByValues](#FilterByValues)
+-   [OmitBy](#OmitBy)
+-   [OmitByKeys](#OmitByKeys)
+-   [OmitByValues](#OmitByValues)
 -   [Intersect](#Intersect)
 -   [Keys](#Keys)
+-   [Values](#Values)
+-   [KeysBy](#KeysBy)
+-   [ValuesBy](#ValuesBy)
+-   [MapKeys](#MapKeys)
+-   [MapValues](#MapValues)
+-   [Entries](#Entries)
+-   [FromEntries](#FromEntries)
+-   [Transform](#Transform)
 -   [Merge](#Merge)
 -   [Minus](#Minus)
--   [Values](#Values)
 -   [IsDisjoint](#IsDisjoint)
 
 <div STYLE="page-break-after: always;"></div>
@@ -78,7 +90,7 @@ func main() {
 
 ### <span id="Filter">Filter</span>
 
-<p>迭代map中的每对key和value, 返回符合predicate函数的key, value</p>
+<p>迭代map中的每对key和value, 返回符合predicate函数的key, value。</p>
 
 <b>函数签名:</b>
 
@@ -121,6 +133,203 @@ func main() {
 }
 ```
 
+### <span id="FilterByKeys">FilterByKeys</span>
+
+<p>迭代map, 返回一个新map，其key都是给定的key值。</p>
+
+<b>函数签名:</b>
+
+```go
+func FilterByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": 4,
+        "e": 5,
+    }
+
+    result := maputil.FilterByKeys(m, []string{"a", "b"})
+
+    fmt.Println(result)
+
+    // Output:
+    // map[a:1 b:2]
+}
+```
+
+
+### <span id="FilterByValues">FilterByValues</span>
+
+<p>迭代map, 返回一个新map，其value都是给定的value值。</p>
+
+<b>函数签名:</b>
+
+```go
+func FilterByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": 4,
+        "e": 5,
+    }
+
+    result := maputil.FilterByValues(m, []int{3, 4})
+
+    fmt.Println(result)
+
+    // Output:
+    // map[c:3 d:4]
+}
+```
+
+
+### <span id="OmitBy">OmitBy</span>
+
+<p>Filter的反向操作, 迭代map中的每对key和value, 删除符合predicate函数的key, value, 返回新map。</p>
+
+<b>函数签名:</b>
+
+```go
+func OmitBy[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": 4,
+        "e": 5,
+    }
+    isEven := func(_ string, value int) bool {
+        return value%2 == 0
+    }
+
+    result := maputil.OmitBy(m, isEven)
+
+    fmt.Println(result)
+
+    // Output:
+    // map[a:1 c:3 e:5]
+}
+```
+
+
+### <span id="OmitByKeys">OmitByKeys</span>
+
+<p>FilterByKeys的反向操作, 迭代map, 返回一个新map，其key不包括给定的key值。</p>
+
+<b>函数签名:</b>
+
+```go
+func OmitByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": 4,
+        "e": 5,
+    }
+
+    result := maputil.OmitByKeys(m, []string{"a", "b"})
+
+    fmt.Println(result)
+
+    // Output:
+    // map[c:3 d:4 e:5]
+}
+```
+
+
+### <span id="OmitByValues">OmitByValues</span>
+
+<p>FilterByValues的反向操作, 迭代map, 返回一个新map，其value不包括给定的value值。</p>
+
+<b>函数签名:</b>
+
+```go
+func OmitByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": 4,
+        "e": 5,
+    }
+
+    result := maputil.OmitByValues(m, []int{4, 5})
+
+    fmt.Println(result)
+
+    // Output:
+    // map[a:1 b:2 c:3]
+}
+```
+
 ### <span id="Intersect">Intersect</span>
 
 <p>多个map的交集操作</p>
@@ -333,6 +542,299 @@ func main() {
 }
 ```
 
+### <span id="KeysBy">KeysBy</span>
+
+<p>创建一个切片，其元素是每个map的key调用mapper函数的结果。</p>
+
+<b>函数签名:</b>
+
+```go
+func KeysBy[K comparable, V any, T any](m map[K]V, mapper func(item K) T) []T
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "sort"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[int]string{
+        1: "a",
+        2: "a",
+        3: "b",
+    }
+
+    keys := maputil.KeysBy(m, func(n int) int {
+        return n + 1
+    })
+
+    sort.Ints(keys)
+
+    fmt.Println(keys)
+
+    // Output:
+    // [2 3 4]
+}
+```
+
+### <span id="ValuesBy">ValuesBy</span>
+
+<p>创建一个切片，其元素是每个map的value调用mapper函数的结果。</p>
+
+<b>函数签名:</b>
+
+```go
+func ValuesBy[K comparable, V any, T any](m map[K]V, mapper func(item V) T) []T
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "sort"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[int]string{
+        1: "a",
+        2: "b",
+        3: "c",
+    }
+    values := maputil.ValuesBy(m, func(v string) string {
+        switch v {
+        case "a":
+            return "a-1"
+        case "b":
+            return "b-2"
+        case "c":
+            return "c-3"
+        default:
+            return ""
+        }
+    })
+
+    sort.Strings(values)
+
+    fmt.Println(values)
+
+    // Output:
+    // [a-1 b-2 c-3]
+}
+```
+
+
+### <span id="MapKeys">MapKeys</span>
+
+<p>操作map的每个key，然后转为新的map。</p>
+
+<b>函数签名:</b>
+
+```go
+func MapKeys[K comparable, V any, T comparable](m map[K]V, iteratee func(key K, value V) T) map[T]V
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "strconv"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[int]string{
+        1: "a",
+        2: "b",
+        3: "c",
+    }
+
+    result := maputil.MapKeys(m, func(k int, _ string) string {
+        return strconv.Itoa(k)
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // map[1:a 2:b 3:c]
+}
+```
+
+### <span id="MapValues">MapValues</span>
+
+<p>操作map的每个value，然后转为新的map。</p>
+
+<b>函数签名:</b>
+
+```go
+func MapValues[K comparable, V any, T any](m map[K]V, iteratee func(key K, value V) T) map[K]T
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "strconv"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[int]string{
+        1: "a",
+        2: "b",
+        3: "c",
+    }
+
+    result := maputil.MapValues(m, func(k int, v string) string {
+        return v + strconv.Itoa(k)
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // map[1:a1 2:b2 3:c3]
+}
+```
+
+
+### <span id="Entry">Entry</span>
+
+<p>将map转换为键/值对切片。</p>
+
+<b>函数签名:</b>
+
+```go
+type Entry[K comparable, V any] struct {
+    Key   K
+    Value V
+}
+func Entries[K comparable, V any](m map[K]V) []Entry[K, V]
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "sort"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+    }
+
+    result := maputil.Entries(m)
+
+    sort.Slice(result, func(i, j int) bool {
+        return result[i].Value < result[j].Value
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // [{a 1} {b 2} {c 3}]
+}
+```
+
+
+### <span id="FromEntries">FromEntries</span>
+
+<p>基于键/值对的切片创建map。</p>
+
+<b>函数签名:</b>
+
+```go
+type Entry[K comparable, V any] struct {
+    Key   K
+    Value V
+}
+func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    result := maputil.FromEntries([]Entry[string, int]{
+        {Key: "a", Value: 1},
+        {Key: "b", Value: 2},
+        {Key: "c", Value: 3},
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // map[a:1 b:2 c:3]
+}
+```
+
+### <span id="Transform">Transform</span>
+
+<p>将map转换为其他类型的map。</p>
+
+<b>函数签名:</b>
+
+```go
+func Transform[K1 comparable, V1 any, K2 comparable, V2 any](m map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "strconv"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+    }
+
+    result := Transform(m, func(k string, v int) (string, string) {
+        return k, strconv.Itoa(v)
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // map[a:1 b:2 c:3]
+}
+```
+
 ### <span id="IsDisjoint">IsDisjoint</span>
 
 <p>验证两个map是否具有不同的key</p>

docs/mathutil.md

@@ -34,6 +34,8 @@ import (
 -   [RoundToFloat](#RoundToFloat)
 -   [RoundToString](#RoundToString)
 -   [TruncRound](#TruncRound)
+-   [Range](#Range)
+-   [RangeWithStep](#RangeWithStep)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -476,3 +478,81 @@ func main() {
     // 0.125
 }
 ```
+
+### <span id="Range">Range</span>
+
+<p>Creates a slice of numbers from start with specified count, element step is 1.</p>
+
+<b>Signature:</b>
+
+```go
+func Range[T constraints.Integer | constraints.Float](start T, count int) []T
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.Range(1, 4)
+	result2 := mathutil.Range(1, -4)
+	result3 := mathutil.Range(-4, 4)
+	result4 := mathutil.Range(1.0, 4)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// [1 2 3 4]
+	// [1 2 3 4]
+	// [-4 -3 -2 -1]
+	// [1 2 3 4]
+}
+```
+
+### <span id="RangeWithStep">RangeWithStep</span>
+
+<p>Creates a slice of numbers from start to end with specified step.</p>
+
+<b>Signature:</b>
+
+```go
+func RangeWithStep[T constraints.Integer | constraints.Float](start, end, step T) []T
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.RangeWithStep(1, 4, 1)
+	result2 := mathutil.RangeWithStep(1, -1, 0)
+	result3 := mathutil.RangeWithStep(-4, 1, 2)
+	result4 := mathutil.RangeWithStep(1.0, 4.0, 1.1)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// [1 2 3]
+	// []
+	// [-4 -2 0]
+	// [1 2.1 3.2]
+}
+```

docs/mathutil_zh-CN.md

@@ -34,6 +34,8 @@ import (
 -   [RoundToFloat](#RoundToFloat)
 -   [RoundToString](#RoundToString)
 -   [TruncRound](#TruncRound)
+-   [Range](#Range)
+-   [RangeWithStep](#RangeWithStep)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -476,3 +478,81 @@ func main() {
     // 0.125
 }
 ```
+
+### <span id="Range">Range</span>
+
+<p>根据指定的起始值和数量，创建一个数字切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func Range[T constraints.Integer | constraints.Float](start T, count int) []T
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.Range(1, 4)
+	result2 := mathutil.Range(1, -4)
+	result3 := mathutil.Range(-4, 4)
+	result4 := mathutil.Range(1.0, 4)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// [1 2 3 4]
+	// [1 2 3 4]
+	// [-4 -3 -2 -1]
+	// [1 2 3 4]
+}
+```
+
+### <span id="RangeWithStep">RangeWithStep</span>
+
+<p>根据指定的起始值，结束值，步长，创建一个数字切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func RangeWithStep[T constraints.Integer | constraints.Float](start, end, step T) []T
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.RangeWithStep(1, 4, 1)
+	result2 := mathutil.RangeWithStep(1, -1, 0)
+	result3 := mathutil.RangeWithStep(-4, 1, 2)
+	result4 := mathutil.RangeWithStep(1.0, 4.0, 1.1)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// [1 2 3]
+	// []
+	// [-4 -2 0]
+	// [1 2.1 3.2]
+}
+```

docs/netutil.md

@@ -591,20 +591,28 @@ import (
 func main() {
     type TodoQuery struct {
         Id     int    `json:"id"`
-        Name string `json:"name"`
+        UserId int    `json:"userId"`
+        Name   string `json:"name,omitempty"`
+        Status string
     }
-    todoQuery := TodoQuery{
+    item := TodoQuery{
         Id:     1,
-        Name: "Test",
+        UserId: 123,
+        Name:   "test",
+        Status: "completed",
     }
-    todoValues := netutil.StructToUrlValues(todoQuery)
+    queryValues := netutil.StructToUrlValues(item)
 
     fmt.Println(todoValues.Get("id"))
+    fmt.Println(todoValues.Get("userId"))
     fmt.Println(todoValues.Get("name"))
+    fmt.Println(todoValues.Get("status"))
 
     // Output:
     // 1
-    // Test
+    // 123
+    // test
+    //
 }
 ```
 

docs/netutil_zh-CN.md

@@ -593,20 +593,28 @@ import (
 func main() {
     type TodoQuery struct {
         Id     int    `json:"id"`
-        Name string `json:"name"`
+        UserId int    `json:"userId"`
+        Name   string `json:"name,omitempty"`
+        Status string
     }
-    todoQuery := TodoQuery{
+    item := TodoQuery{
         Id:     1,
-        Name: "Test",
+        UserId: 123,
+        Name:   "test",
+        Status: "completed",
     }
-    todoValues := netutil.StructToUrlValues(todoQuery)
+    queryValues := netutil.StructToUrlValues(item)
 
     fmt.Println(todoValues.Get("id"))
+    fmt.Println(todoValues.Get("userId"))
     fmt.Println(todoValues.Get("name"))
+    fmt.Println(todoValues.Get("status"))
 
     // Output:
     // 1
-    // Test
+    // 123
+    // test
+    //
 }
 ```
 

docs/slice.md

@@ -24,6 +24,7 @@ import (
 
 -   [AppendIfAbsent](#AppendIfAbsent)
 -   [Contain](#Contain)
+-   [ContainBy](#ContainBy)
 -   [ContainSubSlice](#ContainSubSlice)
 -   [Chunk](#Chunk)
 -   [Compact](#Compact)
@@ -47,6 +48,7 @@ import (
 -   [Flatten](#Flatten)
 -   [FlattenDeep](#FlattenDeep)
 -   [ForEach](#ForEach)
+-   [ForEachWithBreak](#ForEachWithBreak)
 -   [GroupBy](#GroupBy)
 -   [GroupWith](#GroupWith)
 -   [IntSlice<sup>deprecated</sup>](#IntSlice)
@@ -56,6 +58,8 @@ import (
 -   [IndexOf](#IndexOf)
 -   [LastIndexOf](#LastIndexOf)
 -   [Map](#Map)
+-   [FilterMap](#FilterMap)
+-   [FlatMap](#FlatMap)
 -   [Merge](#Merge)
 -   [Reverse](#Reverse)
 -   [Reduce](#Reduce)
@@ -149,6 +153,51 @@ func main() {
 }
 ```
 
+### <span id="ContainBy">ContainBy</span>
+
+<p>returns true if predicate function return true.</p>
+
+<b>Signature:</b>
+
+```go
+func ContainBy[T any](slice []T, predicate func(item T) bool) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    type foo struct {
+        A string
+        B int
+    }
+
+    array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
+    result1 := slice.ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
+    result2 := slice.ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })
+
+    array2 := []string{"a", "b", "c"}
+    result3 := slice.ContainBy(array2, func(t string) bool { return t == "a" })
+    result4 := slice.ContainBy(array2, func(t string) bool { return t == "d" })
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // false
+    // true
+    // false
+}
+```
+
 ### <span id="ContainSubSlice">ContainSubSlice</span>
 
 <p>Check if the slice contain subslice or not.</p>
@@ -953,6 +1002,44 @@ func main() {
 }
 ```
 
+### <span id="ForEachWithBreak">ForEachWithBreak</span>
+
+<p>Iterates over elements of slice and invokes function for each element, when iteratee return false, will break the for each loop.</p>
+
+<b>Signature:</b>
+
+```go
+func ForEachWithBreak[T any](slice []T, iteratee func(index int, item T) bool)
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    numbers := []int{1, 2, 3, 4, 5}
+
+    var sum int
+
+    slice.ForEachWithBreak(numbers, func(_, n int) bool {
+        if n > 3 {
+            return false
+        }
+        sum += n
+        return true
+    })
+
+    fmt.Println(sum)
+
+    // Output:
+    // 6
+}
+```
+
 ### <span id="GroupBy">GroupBy</span>
 
 <p>Iterates over elements of the slice, each element will be group by criteria, returns two slices.</p>
@@ -1252,6 +1339,76 @@ func main() {
 }
 ```
 
+### <span id="FilterMap">FilterMap</span>
+
+<p>Returns a slice which apply both filtering and mapping to the given slice. iteratee callback function should returntwo values: 1, mapping result. 2, whether the result element should be included or not.</p>
+
+<b>Signature:</b>
+
+```go
+func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+    getEvenNumStr := func(i, num int) (string, bool) {
+        if num%2 == 0 {
+            return strconv.FormatInt(int64(num), 10), true
+        }
+        return "", false
+    }
+
+    result := slice.FilterMap(nums, getEvenNumStr)
+
+    fmt.Printf("%#v", result)
+
+    // Output:
+    // []string{"2", "4"}
+}
+```
+
+### <span id="FlatMap">FlatMap</span>
+
+<p>Manipulates a slice and transforms and flattens it to a slice of another type.</p>
+
+<b>Signature:</b>
+
+```go
+func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4}
+
+    result := slice.FlatMap(nums, func(i int, num int) []string {
+        s := "hi-" + strconv.FormatInt(int64(num), 10)
+        return []string{s}
+    })
+
+    fmt.Printf("%#v", result)
+
+    // Output:
+    // []string{"hi-1", "hi-2", "hi-3", "hi-4"}
+}
+```
+
 ### <span id="Merge">Merge</span>
 
 <p>Merge all given slices into one slice.</p>

docs/slice_zh-CN.md

@@ -24,6 +24,7 @@ import (
 
 -   [AppendIfAbsent](#AppendIfAbsent)
 -   [Contain](#Contain)
+-   [ContainBy](#ContainBy)
 -   [ContainSubSlice](#ContainSubSlice)
 -   [Chunk](#Chunk)
 -   [Compact](#Compact)
@@ -47,6 +48,7 @@ import (
 -   [Flatten](#Flatten)
 -   [FlattenDeep](#FlattenDeep)
 -   [ForEach](#ForEach)
+-   [ForEachWithBreak](#ForEachWithBreak)
 -   [GroupBy](#GroupBy)
 -   [GroupWith](#GroupWith)
 -   [IntSlice<sup>deprecated</sup>](#IntSlice)
@@ -56,6 +58,8 @@ import (
 -   [IndexOf](#IndexOf)
 -   [LastIndexOf](#LastIndexOf)
 -   [Map](#Map)
+-   [FilterMap](#FilterMap)
+-   [FlatMap](#FlatMap)
 -   [Merge](#Merge)
 -   [Reverse](#Reverse)
 -   [Reduce](#Reduce)
@@ -149,6 +153,51 @@ func main() {
 }
 ```
 
+### <span id="ContainBy">ContainBy</span>
+
+<p>根据predicate函数判断切片是否包含某个值。</p>
+
+<b>函数签名:</b>
+
+```go
+func ContainBy[T any](slice []T, predicate func(item T) bool) bool
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    type foo struct {
+        A string
+        B int
+    }
+
+    array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
+    result1 := slice.ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
+    result2 := slice.ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })
+
+    array2 := []string{"a", "b", "c"}
+    result3 := slice.ContainBy(array2, func(t string) bool { return t == "a" })
+    result4 := slice.ContainBy(array2, func(t string) bool { return t == "d" })
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // false
+    // true
+    // false
+}
+```
+
 ### <span id="ContainSubSlice">ContainSubSlice</span>
 
 <p>判断slice是否包含subslice</p>
@@ -493,7 +542,6 @@ func main() {
 }
 ```
 
-
 ### <span id="Drop">Drop</span>
 
 <p>从切片的头部删除n个元素。</p>
@@ -955,6 +1003,44 @@ func main() {
 }
 ```
 
+### <span id="ForEachWithBreak">ForEachWithBreak</span>
+
+<p>遍历切片的元素并为每个元素调用iteratee函数，当iteratee函数返回false时，终止遍历。</p>
+
+<b>函数签名:</b>
+
+```go
+func ForEachWithBreak[T any](slice []T, iteratee func(index int, item T) bool)
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    numbers := []int{1, 2, 3, 4, 5}
+
+    var sum int
+
+    slice.ForEachWithBreak(numbers, func(_, n int) bool {
+        if n > 3 {
+            return false
+        }
+        sum += n
+        return true
+    })
+
+    fmt.Println(sum)
+
+    // Output:
+    // 6
+}
+```
+
 ### <span id="GroupBy">GroupBy</span>
 
 <p>迭代切片的元素，每个元素将按条件分组，返回两个切片</p>
@@ -1254,6 +1340,76 @@ func main() {
 }
 ```
 
+### <span id="FilterMap">FilterMap</span>
+
+<p>返回一个将filter和map操作应用于给定切片的切片。 iteratee回调函数应该返回两个值：1，结果值。2，结果值是否应该被包含在返回的切片中。</p>
+
+<b>函数签名:</b>
+
+```go
+func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+    getEvenNumStr := func(i, num int) (string, bool) {
+        if num%2 == 0 {
+            return strconv.FormatInt(int64(num), 10), true
+        }
+        return "", false
+    }
+
+    result := slice.FilterMap(nums, getEvenNumStr)
+
+    fmt.Printf("%#v", result)
+
+    // Output:
+    // []string{"2", "4"}
+}
+```
+
+### <span id="FlatMap">FlatMap</span>
+
+<p>将切片转换为其它类型切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4}
+
+    result := slice.FlatMap(nums, func(i int, num int) []string {
+        s := "hi-" + strconv.FormatInt(int64(num), 10)
+        return []string{s}
+    })
+
+    fmt.Printf("%#v", result)
+
+    // Output:
+    // []string{"hi-1", "hi-2", "hi-3", "hi-4"}
+}
+```
+
 ### <span id="Merge">Merge</span>
 
 <p>合并多个切片（不会消除重复元素).</p>

docs/structs/field.md

@@ -0,0 +1,353 @@
+# Field
+
+Field is abstract struct field for provide several high level functions
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+-   [https://github.com/duke-git/lancet/blob/main/structs/field.go](https://github.com/duke-git/lancet/blob/main/structs/field.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/structs"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index:
+-   [Tag](#Tag)
+-   [Name](#Name)
+-   [Value](#Value)
+-   [Kind](#Kind)
+-   [IsEmbedded](#IsEmbedded)
+-   [IsExported](#IsExported)
+-   [IsZero](#IsZero)
+-   [IsSlice](#IsSlice)
+
+> Note：Since `Field` inherits from `Struct`, it also has all the methods of 'Struct', as follows:
+
+-   [ToMap](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#ToMap)
+-   [Fields](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#Fields)
+-   [Field](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#Field)
+-   [IsStruct](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#IsStruct)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation:
+
+### <span id="Tag">Tag</span>
+
+<p>Get a `Tag` of the `Field`, `Tag` is a abstract struct field tag</p>
+
+<b>Signature:</b>
+
+```go
+func (f *Field) Tag() *Tag
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string `json:"name,omitempty"`
+	}
+	p1 := &Parent{"111"}
+
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	tag := n.Tag()
+
+	fmt.Println(tag.Name)
+	
+	// Output:
+	// name
+}
+```
+
+### <span id="Value">Value</span>
+
+<p>Get the `Field` underlying value</p>
+
+<b>Signature:</b>
+
+```go
+func (f *Field) Value() any
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string `json:"name,omitempty"`
+	}
+	p1 := &Parent{"111"}
+
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	
+	fmt.Println(n.Value())
+	
+	// Output: 
+	// 111
+}
+```
+
+### <span id="IsEmbedded">IsEmbedded</span>
+
+<p>Check if the field is an embedded field</p>
+
+<b>Signature:</b>
+
+```go
+func (f *Field) IsEmbedded() bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+	}
+	type Child struct {
+		Parent
+		Age int
+	}
+	c1 := &Child{}
+	c1.Name = "111"
+	c1.Age = 11
+
+	s := structs.New(c1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+	
+	fmt.Println(n.IsEmbedded())
+	fmt.Println(a.IsEmbedded())
+	
+	// Output: 
+	// true
+	// false
+}
+```
+
+### <span id="IsExported">IsExported</span>
+
+<p>Check if the field is exported</p>
+
+<b>Signature:</b>
+
+```go
+func (f *Field) IsExported() bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+		age  int
+	}
+	p1 := &Parent{Name: "11", age: 11}
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("age")
+	
+	fmt.Println(n.IsExported())
+	fmt.Println(a.IsExported())
+	
+	// Output: 
+	// true
+	// false
+}
+```
+
+### <span id="IsZero">IsZero</span>
+
+<p>Check if the field is zero value</p>
+
+<b>Signature:</b>
+
+```go
+func (f *Field) IsZero() bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+		Age  int
+	}
+	p1 := &Parent{Age: 11}
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+	
+	fmt.Println(n.IsZero())
+	fmt.Println(a.IsZero())
+	
+	// Output: 
+	// true
+	// false
+}
+```
+
+### <span id="Name">Name</span>
+
+<p>Get the field name</p>
+
+<b>Signature:</b>
+
+```go
+func (f *Field) Name() string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+		Age  int
+	}
+	p1 := &Parent{Age: 11}
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+	
+	fmt.Println(n.Name())
+	fmt.Println(a.Name())
+	
+	// Output: 
+	// Name
+	// Age
+}
+```
+
+### <span id="Kind">Kind</span>
+
+<p>Get the field's kind</p>
+
+<b>Signature:</b>
+
+```go
+func (f *Field) Kind() reflect.Kind
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+		Age  int
+	}
+	p1 := &Parent{Age: 11}
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+	
+	fmt.Println(n.Kind())
+	fmt.Println(a.Kind())
+	
+	// Output: 
+	// string
+	// int
+}
+```
+
+### <span id="IsSlice">IsSlice</span>
+
+<p>Check if the field is a slice</p>
+
+<b>Signature:</b>
+
+```go
+func (f *Field) IsSlice() bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+		arr  []int
+	}
+
+	p1 := &Parent{arr: []int{1, 2, 3}}
+	s := structs.New(p1)
+	a, _ := s.Field("arr")
+	
+	fmt.Println(a.IsSlice())
+	
+	// Output: 
+	// true
+}
+```

docs/structs/field_zh-CN.md

@@ -0,0 +1,353 @@
+# Field
+
+Field 包封装了一个抽象的`Field`结构体，提供了操作`struct`属性的相关函数
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/structs/field.go](https://github.com/duke-git/lancet/blob/main/structs/field.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/structs"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录:
+-   [Tag](#Tag)
+-   [Name](#Name)
+-   [Value](#Value)
+-   [Kind](#Kind)
+-   [IsEmbedded](#IsEmbedded)
+-   [IsExported](#IsExported)
+-   [IsZero](#IsZero)
+-   [IsSlice](#IsSlice)
+
+> 注意：由于`Field`继承于`Struct`，所以同样拥有`Struct`所有方法，如下：
+
+-   [ToMap](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#ToMap)
+-   [Fields](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#Fields)
+-   [Field](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#Field)
+-   [IsStruct](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#IsStruct)
+
+<div STYLE="page-break-after: always;"></div>
+
+## API 文档:
+
+### <span id="Tag">Tag</span>
+
+<p>获取`Field`的`Tag`，默认的tag key是json</p>
+
+<b>函数签名:</b>
+
+```go
+func (f *Field) Tag() *Tag
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string `json:"name,omitempty"`
+	}
+	p1 := &Parent{"111"}
+
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	tag := n.Tag()
+
+	fmt.Println(tag.Name)
+	
+	// Output:
+	// name
+}
+```
+
+### <span id="Value">Value</span>
+
+<p>获取`Field`属性的值</p>
+
+<b>函数签名:</b>
+
+```go
+func (f *Field) Value() any
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string `json:"name,omitempty"`
+	}
+	p1 := &Parent{"111"}
+
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	
+	fmt.Println(n.Value())
+	
+	// Output: 
+	// 111
+}
+```
+
+### <span id="IsEmbedded">IsEmbedded</span>
+
+<p>判断属性是否为嵌入</p>
+
+<b>函数签名:</b>
+
+```go
+func (f *Field) IsEmbedded() bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+	}
+	type Child struct {
+		Parent
+		Age int
+	}
+	c1 := &Child{}
+	c1.Name = "111"
+	c1.Age = 11
+
+	s := structs.New(c1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+	
+	fmt.Println(n.IsEmbedded())
+	fmt.Println(a.IsEmbedded())
+	
+	// Output: 
+	// true
+	// false
+}
+```
+
+### <span id="IsExported">IsExported</span>
+
+<p>判断属性是否导出</p>
+
+<b>函数签名:</b>
+
+```go
+func (f *Field) IsExported() bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+		age  int
+	}
+	p1 := &Parent{Name: "11", age: 11}
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("age")
+	
+	fmt.Println(n.IsExported())
+	fmt.Println(a.IsExported())
+	
+	// Output: 
+	// true
+	// false
+}
+```
+
+### <span id="IsZero">IsZero</span>
+
+<p>判断属性是否为零值</p>
+
+<b>函数签名:</b>
+
+```go
+func (f *Field) IsZero() bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+		Age  int
+	}
+	p1 := &Parent{Age: 11}
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+	
+	fmt.Println(n.IsZero())
+	fmt.Println(a.IsZero())
+	
+	// Output: 
+	// true
+	// false
+}
+```
+
+### <span id="Name">Name</span>
+
+<p>获取属性名</p>
+
+<b>函数签名:</b>
+
+```go
+func (f *Field) Name() string
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+		Age  int
+	}
+	p1 := &Parent{Age: 11}
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+	
+	fmt.Println(n.Name())
+	fmt.Println(a.Name())
+	
+	// Output: 
+	// Name
+	// Age
+}
+```
+
+### <span id="Kind">Kind</span>
+
+<p>获取属性Kind</p>
+
+<b>函数签名:</b>
+
+```go
+func (f *Field) Kind() reflect.Kind
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+		Age  int
+	}
+	p1 := &Parent{Age: 11}
+	s := structs.New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+	
+	fmt.Println(n.Kind())
+	fmt.Println(a.Kind())
+	
+	// Output: 
+	// string
+	// int
+}
+```
+
+### <span id="IsSlice">IsSlice</span>
+
+<p>判断属性是否是切片</p>
+
+<b>函数签名:</b>
+
+```go
+func (f *Field) IsSlice() bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type Parent struct {
+		Name string
+		arr  []int
+	}
+
+	p1 := &Parent{arr: []int{1, 2, 3}}
+	s := structs.New(p1)
+	a, _ := s.Field("arr")
+	
+	fmt.Println(a.IsSlice())
+	
+	// Output: 
+	// true
+}
+```

docs/structs/struct.md

@@ -0,0 +1,213 @@
+# Structs
+
+Struct is abstract struct for provide several high level functions
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+-   [https://github.com/duke-git/lancet/blob/main/structs/struct.go](https://github.com/duke-git/lancet/blob/main/structs/struct.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/structs"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index:
+-   [New](#New)
+-   [ToMap](#ToMap)
+-   [Fields](#Fields)
+-   [Field](#Field)
+-   [IsStruct](#IsStruct)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation:
+
+### <span id="New">New</span>
+
+<p>The constructor function of the `Struct` </p>
+
+<b>Signature:</b>
+
+```go
+func New(value any, tagName ...string) *Struct
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type People struct {
+		Name string `json:"name"`
+	}
+	p1 := &People{Name: "11"}
+	s := structs.New(p1)
+	// to do something
+}
+```
+
+### <span id="ToMap">ToMap</span>
+
+<p>convert a valid struct to a map</p>
+
+<b>Signature:</b>
+
+```go
+func (s *Struct) ToMap() (map[string]any, error)
+```
+
+> In addition, provided a convenient static function ToMap
+
+```go
+func ToMap(v any) (map[string]any, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type People struct {
+		Name string `json:"name"`
+	}
+	p1 := &People{Name: "11"}
+	// use constructor function
+	s1 := structs.New(p1)
+	m1, _ := s1.ToMap()
+
+	fmt.Println(m1)
+	
+	// use static function
+	m2, _ := structs.ToMap(p1)
+	
+	fmt.Println(m2)
+	
+	// Output: 
+	// map[name:11]
+	// map[name:11]
+}
+```
+
+### <span id="Fields">Fields</span>
+
+<p>Get all fields of a given struct, that the fields are abstract struct field</p>
+
+<b>Signature:</b>
+
+```go
+func (s *Struct) Fields() []*Field
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type People struct {
+		Name string `json:"name"`
+	}
+	p1 := &People{Name: "11"}
+	s := structs.New(p1)
+	fields := s.Fields()
+
+	fmt.Println(len(fields))
+	
+	// Output: 
+	// 1
+}
+```
+
+### <span id="Field">Field</span>
+
+<p>Get an abstract field of a struct by given field name </p>
+
+<b>Signature:</b>
+
+```go
+func (s *Struct) Field(name string) *Field
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type People struct {
+		Name string `json:"name"`
+	}
+	p1 := &People{Name: "11"}
+	s := structs.New(p1)
+	f := s.Field("Name")
+
+	fmt.Println(f.Value())
+	
+	// Output: 
+	// 11
+}
+```
+
+### <span id="IsStruct">IsStruct</span>
+
+<p>Check if the struct is valid</p>
+
+<b>Signature:</b>
+
+```go
+func (s *Struct) IsStruct() bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type People struct {
+		Name string `json:"name"`
+	}
+	p1 := &People{Name: "11"}
+	s := structs.New(p1)
+
+	fmt.Println(s.IsStruct())
+	
+	// Output: 
+	// true
+}
+```

docs/structs/struct_zh-CN.md

@@ -0,0 +1,212 @@
+# Structs
+
+structs 包封装了一个抽象的`Struct`结构体，提供了操作`struct`的相关函数
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/structs/struct.go](https://github.com/duke-git/lancet/blob/main/structs/struct.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/structs"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录:
+-   [New](#New)
+-   [ToMap](#ToMap)
+-   [Fields](#Fields)
+-   [Field](#Field)
+-   [IsStruct](#IsStruct)
+
+<div STYLE="page-break-after: always;"></div>
+
+## API 文档:
+
+### <span id="New">New</span>
+
+<p>`Struct`结构体的构造函数</p>
+
+<b>函数签名:</b>
+
+```go
+func New(value any, tagName ...string) *Struct
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type People struct {
+		Name string `json:"name"`
+	}
+	p1 := &People{Name: "11"}
+	s := structs.New(p1)
+	// to do something
+}
+```
+
+### <span id="ToMap">ToMap</span>
+
+<p>将一个合法的struct对象转换为map[string]any</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) ToMap() (map[string]any, error)
+```
+
+<b>除此之外，提供一个便捷的静态方法ToMap</b>
+
+```go
+func ToMap(v any) (map[string]any, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type People struct {
+		Name string `json:"name"`
+	}
+	p1 := &People{Name: "11"}
+	s1 := structs.New(p1)
+	m1, _ := s1.ToMap()
+
+	fmt.Println(m1)
+	
+	// 如果不需要Struct更多的方法，可以直接使用ToMap
+	m2, _ := structs.ToMap(p1)
+	
+	fmt.Println(m2)
+	
+	// Output: 
+	// map[name:11]
+	// map[name:11]
+}
+```
+
+### <span id="Fields">Fields</span>
+
+<p>获取一个struct对象的属性列表</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) Fields() []*Field
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type People struct {
+		Name string `json:"name"`
+	}
+	p1 := &People{Name: "11"}
+	s := structs.New(p1)
+	fields := s.Fields()
+
+	fmt.Println(len(fields))
+	
+	// Output: 
+	// 1
+}
+```
+
+### <span id="Field">Field</span>
+
+<p>根据属性名获取一个struct对象的属性</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) Field(name string) *Field
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type People struct {
+		Name string `json:"name"`
+	}
+	p1 := &People{Name: "11"}
+	s := structs.New(p1)
+	f := s.Field("Name")
+
+	fmt.Println(f.Value())
+	
+	// Output: 
+	// 11
+}
+```
+
+### <span id="IsStruct">IsStruct</span>
+
+<p>判断是否为一个合法的struct对象</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) IsStruct() bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+	type People struct {
+		Name string `json:"name"`
+	}
+	p1 := &People{Name: "11"}
+	s := structs.New(p1)
+
+	fmt.Println(s.IsStruct())
+	
+	// Output: 
+	// true
+}
+```

docs/strutil.md

@@ -33,8 +33,9 @@ import (
 -   [UpperKebabCase](#UpperKebabCase)
 -   [LowerFirst](#LowerFirst)
 -   [UpperFirst](#UpperFirst)
--   [PadEnd](#PadEnd)
+-   [Pad](#Pad)
 -   [PadStart](#PadStart)
+-   [PadEnd](#PadEnd)
 -   [Reverse](#Reverse)
 -   [SnakeCase](#SnakeCase)
 -   [UpperSnakeCase](#UpperSnakeCase)
@@ -42,6 +43,8 @@ import (
 -   [Substring](#Substring)
 -   [Wrap](#Wrap)
 -   [Unwrap](#Unwrap)
+-   [SplitWords](#SplitWords)
+-   [WordCount](#WordCount)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -449,6 +452,51 @@ func main() {
 }
 ```
 
+### <span id="Pad">Pad</span>
+
+<p>Pads string on the left and right side if it's shorter than size.</p>
+
+<b>Signature:</b>
+
+```go
+func Pad(source string, size int, padStr string) string
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.Pad("foo", 1, "bar")
+    result2 := strutil.Pad("foo", 2, "bar")
+    result3 := strutil.Pad("foo", 3, "bar")
+    result4 := strutil.Pad("foo", 4, "bar")
+    result5 := strutil.Pad("foo", 5, "bar")
+    result6 := strutil.Pad("foo", 6, "bar")
+    result7 := strutil.Pad("foo", 7, "bar")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+    fmt.Println(result7)
+    // Output:
+    // foo
+    // foo
+    // foo
+    // foob
+    // bfoob
+    // bfooba
+    // bafooba
+}
+```
+
 ### <span id="PadEnd">PadEnd</span>
 
 <p>Pads string on the right side if it's shorter than size.</p>
@@ -802,3 +850,91 @@ func main() {
     // *foo*
 }
 ```
+
+
+### <span id="SplitWords">SplitWords</span>
+
+<p>Splits a string into words, word only contains alphabetic characters.</p>
+
+<b>Signature:</b>
+
+```go
+func SplitWords(s string) []string
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.SplitWords("a word")
+    result2 := strutil.SplitWords("I'am a programmer")
+    result3 := strutil.SplitWords("Bonjour, je suis programmeur")
+    result4 := strutil.SplitWords("a -b-c' 'd'e")
+    result5 := strutil.SplitWords("你好，我是一名码农")
+    result6 := strutil.SplitWords("こんにちは，私はプログラマーです")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // [a word]
+    // [I'am a programmer]
+    // [Bonjour je suis programmeur]
+    // [a b-c' d'e]
+    // []
+    // []
+}
+```
+
+
+### <span id="WordCount">WordCount</span>
+
+<p>Return the number of meaningful word, word only contains alphabetic characters.</p>
+
+<b>Signature:</b>
+
+```go
+func WordCount(s string) int
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.WordCount("a word")
+    result2 := strutil.WordCount("I'am a programmer")
+    result3 := strutil.WordCount("Bonjour, je suis programmeur")
+    result4 := strutil.WordCount("a -b-c' 'd'e")
+    result5 := strutil.WordCount("你好，我是一名码农")
+    result6 := strutil.WordCount("こんにちは，私はプログラマーです")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // 2
+    // 3
+    // 4
+    // 3
+    // 0
+    // 0
+}
+```

docs/strutil_zh-CN.md

@@ -33,6 +33,7 @@ import (
 -   [UpperKebabCase](#UpperKebabCase)
 -   [LowerFirst](#LowerFirst)
 -   [UpperFirst](#UpperFirst)
+-   [Pad](#Pad)
 -   [PadEnd](#PadEnd)
 -   [PadStart](#PadStart)
 -   [Reverse](#Reverse)
@@ -42,6 +43,8 @@ import (
 -   [Substring](#Substring)
 -   [Wrap](#Wrap)
 -   [Unwrap](#Unwrap)
+-   [SplitWords](#SplitWords)
+-   [WordCount](#WordCount)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -449,6 +452,51 @@ func main() {
 }
 ```
 
+### <span id="Pad">Pad</span>
+
+<p>如果字符串长度短于size，则在左右两侧填充字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func Pad(source string, size int, padStr string) string
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.Pad("foo", 1, "bar")
+    result2 := strutil.Pad("foo", 2, "bar")
+    result3 := strutil.Pad("foo", 3, "bar")
+    result4 := strutil.Pad("foo", 4, "bar")
+    result5 := strutil.Pad("foo", 5, "bar")
+    result6 := strutil.Pad("foo", 6, "bar")
+    result7 := strutil.Pad("foo", 7, "bar")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+    fmt.Println(result7)
+    // Output:
+    // foo
+    // foo
+    // foo
+    // foob
+    // bfoob
+    // bfooba
+    // bafooba
+}
+```
+
 ### <span id="PadEnd">PadEnd</span>
 
 <p>如果字符串长度短于size，则在右侧填充字符串。</p>
@@ -802,3 +850,90 @@ func main() {
     // *foo*
 }
 ```
+
+### <span id="SplitWords">SplitWords</span>
+
+<p>将字符串拆分为单词，只支持字母字符单词。</p>
+
+<b>函数签名:</b>
+
+```go
+func SplitWords(s string) []string
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.SplitWords("a word")
+    result2 := strutil.SplitWords("I'am a programmer")
+    result3 := strutil.SplitWords("Bonjour, je suis programmeur")
+    result4 := strutil.SplitWords("a -b-c' 'd'e")
+    result5 := strutil.SplitWords("你好，我是一名码农")
+    result6 := strutil.SplitWords("こんにちは，私はプログラマーです")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // [a word]
+    // [I'am a programmer]
+    // [Bonjour je suis programmeur]
+    // [a b-c' d'e]
+    // []
+    // []
+}
+```
+
+
+### <span id="WordCount">WordCount</span>
+
+<p>返回有意义单词的数量，只支持字母字符单词。</p>
+
+<b>函数签名:</b>
+
+```go
+func WordCount(s string) int
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.WordCount("a word")
+    result2 := strutil.WordCount("I'am a programmer")
+    result3 := strutil.WordCount("Bonjour, je suis programmeur")
+    result4 := strutil.WordCount("a -b-c' 'd'e")
+    result5 := strutil.WordCount("你好，我是一名码农")
+    result6 := strutil.WordCount("こんにちは，私はプログラマーです")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // 2
+    // 3
+    // 4
+    // 3
+    // 0
+    // 0
+}
+```

docs/xerror.md

@@ -133,7 +133,7 @@ func main() {
     err1 := xerror.New("error").With("level", "high")
     wrapErr := errors.Wrap(err1, "oops")
 
-    err := xerror.Unwrap(err1)
+    err := xerror.Unwrap(wrapErr)
 
     values := err.Values()
     fmt.Println(values["level"])
@@ -441,7 +441,7 @@ import (
 )
 
 func main() {
-    err := New("error")
+    err := xerror.New("error")
     fmt.Println(err.Error())
 
     // Output:

docs/xerror_zh-CN.md

@@ -133,7 +133,7 @@ func main() {
     err1 := xerror.New("error").With("level", "high")
     wrapErr := errors.Wrap(err1, "oops")
 
-    err := xerror.Unwrap(err1)
+    err := xerror.Unwrap(wrapErr)
 
     values := err.Values()
     fmt.Println(values["level"])
@@ -441,7 +441,7 @@ import (
 )
 
 func main() {
-    err := New("error")
+    err := xerror.New("error")
     fmt.Println(err.Error())
 
     // Output:

internal/assert.go

@@ -79,16 +79,18 @@ func (a *Assert) LessOrEqual(expected, actual any) {
 }
 
 // IsNil check if value is nil
-func (a *Assert) IsNil(value any) {
+func (a *Assert) IsNil(v any) {
-	if value != nil {
+	if v == nil || (reflect.ValueOf(v).Kind() == reflect.Ptr && reflect.ValueOf(v).IsNil()) {
-		makeTestFailed(a.T, a.CaseName, nil, value)
+		return
 	}
+
+	makeTestFailed(a.T, a.CaseName, nil, v)
 }
 
 // IsNotNil check if value is not nil
-func (a *Assert) IsNotNil(value any) {
+func (a *Assert) IsNotNil(v any) {
-	if value == nil {
+	if v == nil || (reflect.ValueOf(v).Kind() == reflect.Ptr && reflect.ValueOf(v).IsNil()) {
-		makeTestFailed(a.T, a.CaseName, "not nil", value)
+		makeTestFailed(a.T, a.CaseName, "not nil", v)
 	}
 }
 

internal/error_join.go

@@ -0,0 +1,51 @@
+package internal
+
+// Note: this file is copyed from the go standart repo (https://github.com/golang/go/blob/master/src/errors/join.go).
+// just in order to adapt under go1.9
+// do not use it outside lancet lib.
+
+// Join returns an error that wraps the given errors.
+// Any nil error values are discarded.
+// Join returns nil if errs contains no non-nil values.
+// The error formats as the concatenation of the strings obtained
+// by calling the Error method of each element of errs, with a newline
+// between each string.
+func JoinError(errs ...error) error {
+	n := 0
+	for _, err := range errs {
+		if err != nil {
+			n++
+		}
+	}
+	if n == 0 {
+		return nil
+	}
+	e := &joinError{
+		errs: make([]error, 0, n),
+	}
+	for _, err := range errs {
+		if err != nil {
+			e.errs = append(e.errs, err)
+		}
+	}
+	return e
+}
+
+type joinError struct {
+	errs []error
+}
+
+func (e *joinError) Error() string {
+	var b []byte
+	for i, err := range e.errs {
+		if i > 0 {
+			b = append(b, '\n')
+		}
+		b = append(b, err.Error()...)
+	}
+	return string(b)
+}
+
+func (e *joinError) Unwrap() []error {
+	return e.errs
+}

maputil/map.go

@@ -4,7 +4,11 @@
 // Package maputil includes some functions to manipulate map.
 package maputil
 
-import "reflect"
+import (
+	"reflect"
+
+	"github.com/duke-git/lancet/v2/slice"
+)
 
 // Keys returns a slice of the map's keys.
 // Play: https://go.dev/play/p/xNB5bTb97Wd
@@ -34,6 +38,30 @@ func Values[K comparable, V any](m map[K]V) []V {
 	return values
 }
 
+// KeysBy creates a slice whose element is the result of function mapper invoked by every map's key.
+// Play: https://go.dev/play/p/hI371iB8Up8
+func KeysBy[K comparable, V any, T any](m map[K]V, mapper func(item K) T) []T {
+	keys := make([]T, 0, len(m))
+
+	for k := range m {
+		keys = append(keys, mapper(k))
+	}
+
+	return keys
+}
+
+// ValuesBy creates a slice whose element is the result of function mapper invoked by every map's value.
+// Play: https://go.dev/play/p/sg9-oRidh8f
+func ValuesBy[K comparable, V any, T any](m map[K]V, mapper func(item V) T) []T {
+	keys := make([]T, 0, len(m))
+
+	for _, v := range m {
+		keys = append(keys, mapper(v))
+	}
+
+	return keys
+}
+
 // Merge maps, next key will overwrite previous key.
 // Play: https://go.dev/play/p/H95LENF1uB-
 func Merge[K comparable, V any](maps ...map[K]V) map[K]V {
@@ -69,6 +97,71 @@ func Filter[K comparable, V any](m map[K]V, predicate func(key K, value V) bool)
 	return result
 }
 
+// FilterByKeys iterates over map, return a new map whose keys are all given keys.
+// Play: https://go.dev/play/p/7ov6BJHbVqh
+func FilterByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V {
+	result := make(map[K]V)
+
+	for k, v := range m {
+		if slice.Contain(keys, k) {
+			result[k] = v
+		}
+	}
+	return result
+}
+
+// FilterByValues iterates over map, return a new map whose values are all given values.
+// Play: https://go.dev/play/p/P3-9MdcXegR
+func FilterByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V {
+	result := make(map[K]V)
+
+	for k, v := range m {
+		if slice.Contain(values, v) {
+			result[k] = v
+		}
+	}
+	return result
+}
+
+// OmitBy is the opposite of Filter, removes all the map elements for which the predicate function returns true.
+// Play: https://go.dev/play/p/YJM4Hj5hNwm
+func OmitBy[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V {
+	result := make(map[K]V)
+
+	for k, v := range m {
+		if !predicate(k, v) {
+			result[k] = v
+		}
+	}
+	return result
+}
+
+// OmitByKeys the opposite of FilterByKeys, extracts all the map elements which keys are not omitted.
+// Play: https://go.dev/play/p/jXGrWDBfSRp
+func OmitByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V {
+	result := make(map[K]V)
+
+	for k, v := range m {
+		if !slice.Contain(keys, k) {
+			result[k] = v
+		}
+	}
+	return result
+}
+
+// OmitByValues the opposite of FilterByValues. remov all elements whose value are in the give slice.
+// Play: https://go.dev/play/p/XB7Y10uw20_U
+func OmitByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V {
+	result := make(map[K]V)
+
+	for k, v := range m {
+		if !slice.Contain(values, v) {
+			result[k] = v
+		}
+	}
+	return result
+}
+
 // Intersect iterates over maps, return a new map of key and value pairs in all given maps.
 // Play: https://go.dev/play/p/Zld0oj3sjcC
 func Intersect[K comparable, V any](maps ...map[K]V) map[K]V {
@@ -126,3 +219,73 @@ func IsDisjoint[K comparable, V any](mapA, mapB map[K]V) bool {
 	}
 	return true
 }
+
+// Entry is a key/value pairs.
+type Entry[K comparable, V any] struct {
+	Key   K
+	Value V
+}
+
+// Entries transforms a map into array of key/value pairs.
+// Play: https://go.dev/play/p/Ltb11LNcElY
+func Entries[K comparable, V any](m map[K]V) []Entry[K, V] {
+	entries := make([]Entry[K, V], 0, len(m))
+
+	for k, v := range m {
+		entries = append(entries, Entry[K, V]{
+			Key:   k,
+			Value: v,
+		})
+	}
+
+	return entries
+}
+
+// FromEntries creates a map based on a slice of key/value pairs
+// Play: https://go.dev/play/p/fTdu4sCNjQO
+func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V {
+	result := make(map[K]V, len(entries))
+
+	for _, v := range entries {
+		result[v.Key] = v.Value
+	}
+
+	return result
+}
+
+// Transform a map to another type map.
+// Play: https://go.dev/play/p/P6ovfToM3zj
+func Transform[K1 comparable, V1 any, K2 comparable, V2 any](m map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2 {
+	result := make(map[K2]V2, len(m))
+
+	for k1, v1 := range m {
+		k2, v2 := iteratee(k1, v1)
+		result[k2] = v2
+	}
+
+	return result
+}
+
+// MapKeys transforms a map to other type map by manipulating it's keys.
+// Play: https://go.dev/play/p/8scDxWeBDKd
+func MapKeys[K comparable, V any, T comparable](m map[K]V, iteratee func(key K, value V) T) map[T]V {
+	result := make(map[T]V, len(m))
+
+	for k, v := range m {
+		result[iteratee(k, v)] = v
+	}
+
+	return result
+}
+
+// MapValues transforms a map to other type map by manipulating it's values.
+// Play: https://go.dev/play/p/g92aY3fc7Iw
+func MapValues[K comparable, V any, T any](m map[K]V, iteratee func(key K, value V) T) map[K]T {
+	result := make(map[K]T, len(m))
+
+	for k, v := range m {
+		result[k] = iteratee(k, v)
+	}
+
+	return result
+}

maputil/map_example_test.go

@@ -3,6 +3,7 @@ package maputil
 import (
 	"fmt"
 	"sort"
+	"strconv"
 )
 
 func ExampleKeys() {
@@ -41,6 +42,51 @@ func ExampleValues() {
 	// [a a b c d]
 }
 
+func ExampleKeysBy() {
+	m := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+	}
+
+	keys := KeysBy(m, func(n int) int {
+		return n + 1
+	})
+
+	sort.Ints(keys)
+
+	fmt.Println(keys)
+
+	// Output:
+	// [2 3 4]
+}
+
+func ExampleValuesBy() {
+	m := map[int]string{
+		1: "a",
+		2: "b",
+		3: "c",
+	}
+	values := ValuesBy(m, func(v string) string {
+		switch v {
+		case "a":
+			return "a-1"
+		case "b":
+			return "b-2"
+		case "c":
+			return "c-3"
+		default:
+			return ""
+		}
+	})
+
+	sort.Strings(values)
+
+	fmt.Println(values)
+
+	// Output:
+	// [a-1 b-2 c-3]
+}
 func ExampleMerge() {
 	m1 := map[int]string{
 		1: "a",
@@ -99,6 +145,40 @@ func ExampleFilter() {
 	// map[b:2 d:4]
 }
 
+func ExampleFilterByKeys() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+
+	result := FilterByKeys(m, []string{"a", "b"})
+
+	fmt.Println(result)
+
+	// Output:
+	// map[a:1 b:2]
+}
+
+func ExampleFilterByValues() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+
+	result := FilterByValues(m, []int{3, 4})
+
+	fmt.Println(result)
+
+	// Output:
+	// map[c:3 d:4]
+}
+
 func ExampleIntersect() {
 	m1 := map[string]int{
 		"a": 1,
@@ -179,3 +259,141 @@ func ExampleIsDisjoint() {
 	// true
 	// false
 }
+
+func ExampleEntries() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	result := Entries(m)
+
+	sort.Slice(result, func(i, j int) bool {
+		return result[i].Value < result[j].Value
+	})
+
+	fmt.Println(result)
+
+	// Output:
+	// [{a 1} {b 2} {c 3}]
+}
+
+func ExampleFromEntries() {
+
+	result := FromEntries([]Entry[string, int]{
+		{Key: "a", Value: 1},
+		{Key: "b", Value: 2},
+		{Key: "c", Value: 3},
+	})
+
+	fmt.Println(result)
+
+	// Output:
+	// map[a:1 b:2 c:3]
+}
+
+func ExampleTransform() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	result := Transform(m, func(k string, v int) (string, string) {
+		return k, strconv.Itoa(v)
+	})
+
+	fmt.Println(result)
+
+	// Output:
+	// map[a:1 b:2 c:3]
+}
+
+func ExampleMapKeys() {
+	m := map[int]string{
+		1: "a",
+		2: "b",
+		3: "c",
+	}
+
+	result := MapKeys(m, func(k int, _ string) string {
+		return strconv.Itoa(k)
+	})
+
+	fmt.Println(result)
+
+	// Output:
+	// map[1:a 2:b 3:c]
+}
+
+func ExampleMapValues() {
+	m := map[int]string{
+		1: "a",
+		2: "b",
+		3: "c",
+	}
+
+	result := MapValues(m, func(k int, v string) string {
+		return v + strconv.Itoa(k)
+	})
+
+	fmt.Println(result)
+
+	// Output:
+	// map[1:a1 2:b2 3:c3]
+}
+
+func ExampleOmitBy() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+	isEven := func(_ string, value int) bool {
+		return value%2 == 0
+	}
+
+	result := OmitBy(m, isEven)
+
+	fmt.Println(result)
+
+	// Output:
+	// map[a:1 c:3 e:5]
+}
+
+func ExampleOmitByKeys() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+
+	result := OmitByKeys(m, []string{"a", "b"})
+
+	fmt.Println(result)
+
+	// Output:
+	// map[c:3 d:4 e:5]
+}
+
+func ExampleOmitByValues() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+
+	result := OmitByValues(m, []int{4, 5})
+
+	fmt.Println(result)
+
+	// Output:
+	// map[a:1 b:2 c:3]
+}

maputil/map_test.go

@@ -2,6 +2,7 @@ package maputil
 
 import (
 	"sort"
+	"strconv"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
@@ -41,6 +42,51 @@ func TestValues(t *testing.T) {
 	assert.Equal([]string{"a", "a", "b", "c", "d"}, values)
 }
 
+func TestKeysBy(t *testing.T) {
+	assert := internal.NewAssert(t, "TestKeysBy")
+
+	m := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+	}
+
+	keys := KeysBy(m, func(n int) int {
+		return n + 1
+	})
+
+	sort.Ints(keys)
+
+	assert.Equal([]int{2, 3, 4}, keys)
+}
+
+func TestValuesBy(t *testing.T) {
+	assert := internal.NewAssert(t, "TestValuesBy")
+
+	m := map[int]string{
+		1: "a",
+		2: "b",
+		3: "c",
+	}
+
+	values := ValuesBy(m, func(v string) string {
+		switch v {
+		case "a":
+			return "a-1"
+		case "b":
+			return "b-2"
+		case "c":
+			return "c-3"
+		default:
+			return ""
+		}
+	})
+
+	sort.Strings(values)
+
+	assert.Equal([]string{"a-1", "b-2", "c-3"}, values)
+}
+
 func TestMerge(t *testing.T) {
 	assert := internal.NewAssert(t, "TestMerge")
 
@@ -104,6 +150,107 @@ func TestFilter(t *testing.T) {
 	}, acturl)
 }
 
+func TestFilterByKeys(t *testing.T) {
+	assert := internal.NewAssert(t, "TestFilterByKeys")
+
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+
+	acturl := FilterByKeys(m, []string{"a", "b"})
+
+	assert.Equal(map[string]int{
+		"a": 1,
+		"b": 2,
+	}, acturl)
+}
+
+func TestFilterByValues(t *testing.T) {
+	assert := internal.NewAssert(t, "TestFilterByValues")
+
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+
+	acturl := FilterByValues(m, []int{3, 4})
+
+	assert.Equal(map[string]int{
+		"c": 3,
+		"d": 4,
+	}, acturl)
+}
+
+func TestOmitBy(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOmitBy")
+
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+	isEven := func(_ string, value int) bool {
+		return value%2 == 0
+	}
+
+	acturl := OmitBy(m, isEven)
+
+	assert.Equal(map[string]int{
+		"a": 1,
+		"c": 3,
+		"e": 5,
+	}, acturl)
+}
+
+func TestOmitByKeys(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOmitByKeys")
+
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+
+	acturl := OmitByKeys(m, []string{"a", "b"})
+
+	assert.Equal(map[string]int{
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}, acturl)
+}
+
+func TestOmitByValues(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOmitByValues")
+
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+
+	acturl := OmitByValues(m, []int{4, 5})
+
+	assert.Equal(map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}, acturl)
+}
+
 func TestIntersect(t *testing.T) {
 	assert := internal.NewAssert(t, "TestIntersect")
 
@@ -170,3 +317,104 @@ func TestIsDisjoint(t *testing.T) {
 
 	assert.Equal(false, IsDisjoint(m1, m3))
 }
+
+func TestEntries(t *testing.T) {
+	assert := internal.NewAssert(t, "TestEntries")
+
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	result := Entries(m)
+
+	sort.Slice(result, func(i, j int) bool {
+		return result[i].Value < result[j].Value
+	})
+
+	expected := []Entry[string, int]{{Key: "a", Value: 1}, {Key: "b", Value: 2}, {Key: "c", Value: 3}}
+
+	assert.Equal(expected, result)
+}
+
+func TestFromEntries(t *testing.T) {
+	assert := internal.NewAssert(t, "TestFromEntries")
+
+	result := FromEntries([]Entry[string, int]{
+		{Key: "a", Value: 1},
+		{Key: "b", Value: 2},
+		{Key: "c", Value: 3},
+	})
+
+	assert.Equal(3, len(result))
+	assert.Equal(1, result["a"])
+	assert.Equal(2, result["b"])
+	assert.Equal(3, result["c"])
+}
+
+func TestTransform(t *testing.T) {
+	assert := internal.NewAssert(t, "TestTransform")
+
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	result := Transform(m, func(k string, v int) (string, string) {
+		return k, strconv.Itoa(v)
+	})
+
+	expected := map[string]string{
+		"a": "1",
+		"b": "2",
+		"c": "3",
+	}
+
+	assert.Equal(expected, result)
+}
+
+func TestMapKeys(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMapKeys")
+
+	m := map[int]string{
+		1: "a",
+		2: "b",
+		3: "c",
+	}
+
+	result := MapKeys(m, func(k int, _ string) string {
+		return strconv.Itoa(k)
+	})
+
+	expected := map[string]string{
+		"1": "a",
+		"2": "b",
+		"3": "c",
+	}
+
+	assert.Equal(expected, result)
+}
+
+func TestMapValues(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMapKeys")
+
+	m := map[int]string{
+		1: "a",
+		2: "b",
+		3: "c",
+	}
+
+	result := MapValues(m, func(k int, v string) string {
+		return v + strconv.Itoa(k)
+	})
+
+	expected := map[int]string{
+		1: "a1",
+		2: "b2",
+		3: "c3",
+	}
+
+	assert.Equal(expected, result)
+}

mathutil/mathutil.go

@@ -183,3 +183,36 @@ func Average[T constraints.Integer | constraints.Float](numbers ...T) T {
 	}
 	return sum / n
 }
+
+// Range creates a slice of numbers from start with specified count, element step is 1.
+// Play: todo
+func Range[T constraints.Integer | constraints.Float](start T, count int) []T {
+	size := count
+	if count < 0 {
+		size = -count
+	}
+
+	result := make([]T, size)
+
+	for i, j := 0, start; i < size; i, j = i+1, j+1 {
+		result[i] = j
+	}
+
+	return result
+}
+
+// RangeWithStep creates a slice of numbers from start to end with specified step.
+// Play: todo
+func RangeWithStep[T constraints.Integer | constraints.Float](start, end, step T) []T {
+	result := []T{}
+
+	if start >= end || step == 0 {
+		return result
+	}
+
+	for i := start; i < end; i += step {
+		result = append(result, i)
+	}
+
+	return result
+}

mathutil/mathutil_exmaple_test.go

@@ -185,3 +185,39 @@ func ExampleMinBy() {
 	// ab
 	//
 }
+
+func ExampleRange() {
+	result1 := Range(1, 4)
+	result2 := Range(1, -4)
+	result3 := Range(-4, 4)
+	result4 := Range(1.0, 4)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// [1 2 3 4]
+	// [1 2 3 4]
+	// [-4 -3 -2 -1]
+	// [1 2 3 4]
+}
+
+func ExampleRangeWithStep() {
+	result1 := RangeWithStep(1, 4, 1)
+	result2 := RangeWithStep(1, -1, 0)
+	result3 := RangeWithStep(-4, 1, 2)
+	result4 := RangeWithStep(1.0, 4.0, 1.1)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// [1 2 3]
+	// []
+	// [-4 -2 0]
+	// [1 2.1 3.2]
+}

mathutil/mathutil_test.go

@@ -137,3 +137,33 @@ func TestMinBy(t *testing.T) {
 	})
 	assert.Equal("", res3)
 }
+
+func TestRange(t *testing.T) {
+	assert := internal.NewAssert(t, "Range")
+
+	result1 := Range(1, 4)
+	result2 := Range(1, -4)
+	result3 := Range(-4, 4)
+	result4 := Range(1.0, 4)
+	result5 := Range(1, 0)
+
+	assert.Equal([]int{1, 2, 3, 4}, result1)
+	assert.Equal([]int{1, 2, 3, 4}, result2)
+	assert.Equal([]int{-4, -3, -2, -1}, result3)
+	assert.Equal([]float64{1.0, 2.0, 3.0, 4.0}, result4)
+	assert.Equal([]int{}, result5)
+}
+
+func TestRangeWithStep(t *testing.T) {
+	assert := internal.NewAssert(t, "Range")
+
+	result1 := RangeWithStep(1, 4, 1)
+	result2 := RangeWithStep(1, -1, 0)
+	result3 := RangeWithStep(-4, 1, 2)
+	result4 := RangeWithStep(1.0, 4.0, 1.1)
+
+	assert.Equal([]int{1, 2, 3}, result1)
+	assert.Equal([]int{}, result2)
+	assert.Equal([]int{-4, -2, 0}, result3)
+	assert.Equal([]float64{1.0, 2.1, 3.2}, result4)
+}

netutil/http.go

@@ -21,12 +21,11 @@ import (
 	"io"
 	"net/http"
 	"net/url"
-	"reflect"
-	"regexp"
 	"sort"
 	"strings"
 	"time"
 
+	"github.com/duke-git/lancet/v2/convertor"
 	"github.com/duke-git/lancet/v2/slice"
 )
 
@@ -219,7 +218,7 @@ func (client *HttpClient) setTLS(rawUrl string) {
 	}
 }
 
-// setHeader set http rquest header
+// setHeader set http request header
 func (client *HttpClient) setHeader(req *http.Request, headers http.Header) {
 	if headers == nil {
 		headers = make(http.Header)
@@ -278,29 +277,15 @@ func validateRequest(req *HttpRequest) error {
 // StructToUrlValues convert struct to url valuse,
 // only convert the field which is exported and has `json` tag.
 // Play: https://go.dev/play/p/pFqMkM40w9z
-func StructToUrlValues(targetStruct any) url.Values {
+func StructToUrlValues(targetStruct any) (url.Values, error) {
-	rv := reflect.ValueOf(targetStruct)
-	rt := reflect.TypeOf(targetStruct)
-
-	if rt.Kind() == reflect.Ptr {
-		rt = rt.Elem()
-	}
-	if rt.Kind() != reflect.Struct {
-		panic(fmt.Errorf("data type %T not support, shuld be struct or pointer to struct", targetStruct))
-	}
-
 	result := url.Values{}
-
+	s, err := convertor.StructToMap(targetStruct)
-	fieldNum := rt.NumField()
+	if err != nil {
-	pattern := `^[A-Z]`
+		return nil, err
-	regex := regexp.MustCompile(pattern)
-	for i := 0; i < fieldNum; i++ {
-		name := rt.Field(i).Name
-		tag := rt.Field(i).Tag.Get("json")
-		if regex.MatchString(name) && tag != "" {
-			result.Add(tag, fmt.Sprintf("%v", rv.Field(i).Interface()))
 	}
+	for k, v := range s {
+		result.Add(k, fmt.Sprintf("%v", v))
 	}
 
-	return result
+	return result, nil
 }

netutil/http_test.go

@@ -219,28 +219,29 @@ func TestStructToUrlValues(t *testing.T) {
 	type TodoQuery struct {
 		Id     int    `json:"id"`
 		UserId int    `json:"userId"`
+		Name   string `json:"name,omitempty"`
 	}
-	todoQuery := TodoQuery{
+	item1 := TodoQuery{
 		Id:     1,
-		UserId: 1,
+		UserId: 123,
+		Name:   "",
+	}
+	todoValues, err := StructToUrlValues(item1)
+	if err != nil {
+		t.Errorf("params is invalid: %v", err)
 	}
-	todoValues := StructToUrlValues(todoQuery)
 
 	assert.Equal("1", todoValues.Get("id"))
-	assert.Equal("1", todoValues.Get("userId"))
+	assert.Equal("123", todoValues.Get("userId"))
+	assert.Equal("", todoValues.Get("name"))
 
-	request := &HttpRequest{
+	item2 := TodoQuery{
-		RawURL:      "https://jsonplaceholder.typicode.com/todos",
+		Id:     2,
-		Method:      "GET",
+		UserId: 456,
-		QueryParams: todoValues,
 	}
+	queryValues2, _ := StructToUrlValues(item2)
 
-	httpClient := NewHttpClient()
+	assert.Equal("2", queryValues2.Get("id"))
-	resp, err := httpClient.SendRequest(request)
+	assert.Equal("456", queryValues2.Get("userId"))
-	if err != nil || resp.StatusCode != 200 {
+	assert.Equal("", queryValues2.Get("name"))
-		log.Fatal(err)
-	}
-
-	body, _ := io.ReadAll(resp.Body)
-	t.Log("response: ", string(body))
 }

netutil/net_example_test.go

@@ -124,20 +124,44 @@ func ExampleHttpClient_DecodeResponse() {
 func ExampleStructToUrlValues() {
 	type TodoQuery struct {
 		Id     int    `json:"id"`
-		Name string `json:"name"`
+		UserId int    `json:"userId"`
+		Name   string `json:"name,omitempty"`
+		Status string
 	}
-	todoQuery := TodoQuery{
+	item1 := TodoQuery{
 		Id:     1,
-		Name: "Test",
+		UserId: 123,
+		Name:   "test",
+		Status: "completed",
+	}
+	queryValues1, err := StructToUrlValues(item1)
+	if err != nil {
+		return
 	}
-	todoValues := StructToUrlValues(todoQuery)
 
-	fmt.Println(todoValues.Get("id"))
+	item2 := TodoQuery{
-	fmt.Println(todoValues.Get("name"))
+		Id:     2,
+		UserId: 456,
+	}
+	queryValues2, _ := StructToUrlValues(item2)
+
+	fmt.Println(queryValues1.Get("id"))
+	fmt.Println(queryValues1.Get("userId"))
+	fmt.Println(queryValues1.Get("name"))
+	fmt.Println(queryValues1.Get("status"))
+
+	fmt.Println(queryValues2.Get("id"))
+	fmt.Println(queryValues2.Get("userId"))
+	fmt.Println(queryValues2.Get("name"))
 
 	// Output:
 	// 1
-	// Test
+	// 123
+	// test
+	//
+	// 2
+	// 456
+	//
 }
 
 func ExampleConvertMapToQueryString() {

pointer/pointer.go

@@ -0,0 +1,14 @@
+package pointer
+
+import "reflect"
+
+// ExtractPointer returns the underlying value by the given interface type
+func ExtractPointer(value any) any {
+	t := reflect.TypeOf(value)
+	v := reflect.ValueOf(value)
+
+	if t.Kind() != reflect.Pointer {
+		return value
+	}
+	return ExtractPointer(v.Elem().Interface())
+}

pointer/pointer_test.go

@@ -0,0 +1,18 @@
+package pointer
+
+import (
+	"github.com/duke-git/lancet/v2/internal"
+	"testing"
+)
+
+func TestExtractPointer(t *testing.T) {
+
+	assert := internal.NewAssert(t, "TestExtractPointer")
+
+	a := 1
+	b := &a
+	c := &b
+	d := &c
+
+	assert.Equal(1, ExtractPointer(d))
+}

random/random.go

@@ -19,6 +19,10 @@ const (
 	Letters       = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 )
 
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
 // RandInt generate random int between min and max, maybe min,  not be max.
 // Play: https://go.dev/play/p/pXyyAAI5YxD
 func RandInt(min, max int) int {
@@ -28,9 +32,12 @@ func RandInt(min, max int) int {
 	if max < min {
 		min, max = max, min
 	}
-	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 
-	return r.Intn(max-min) + min
+	// fix: https://github.com/duke-git/lancet/issues/75
+	// r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	// return r.Intn(max-min) + min
+
+	return rand.Intn(max-min) + min
 }
 
 // RandBytes generate random byte slice.
@@ -81,10 +88,12 @@ func RandNumeralOrLetter(length int) string {
 // random generate a random string based on given string range.
 func random(s string, length int) string {
 	b := make([]byte, length)
-	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	// fix: https://github.com/duke-git/lancet/issues/75
+	// r := rand.New(rand.NewSource(time.Now().UnixNano()))
 
 	for i := range b {
-		b[i] = s[r.Int63()%int64(len(s))]
+		b[i] = s[rand.Int63()%int64(len(s))]
 	}
 
 	return string(b)

slice/slice.go

@@ -33,6 +33,18 @@ func Contain[T comparable](slice []T, target T) bool {
 	return false
 }
 
+// ContainBy returns true if predicate function return true.
+// Play: https://go.dev/play/p/49tkHfX4GNc
+func ContainBy[T any](slice []T, predicate func(item T) bool) bool {
+	for _, item := range slice {
+		if predicate(item) {
+			return true
+		}
+	}
+
+	return false
+}
+
 // ContainSubSlice check if the slice contain a given subslice or not.
 // Play: https://go.dev/play/p/bcuQ3UT6Sev
 func ContainSubSlice[T comparable](slice, subSlice []T) bool {
@@ -409,6 +421,16 @@ func ForEach[T any](slice []T, iteratee func(index int, item T)) {
 	}
 }
 
+// ForEachWithBreak iterates over elements of slice and invokes function for each element,
+// when iteratee return false, will break the for each loop.
+func ForEachWithBreak[T any](slice []T, iteratee func(index int, item T) bool) {
+	for i, v := range slice {
+		if !iteratee(i, v) {
+			break
+		}
+	}
+}
+
 // Map creates an slice of values by running each element of slice thru iteratee function.
 // Play: https://go.dev/play/p/biaTefqPquw
 func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U {
@@ -421,6 +443,35 @@ func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U {
 	return result
 }
 
+// FilterMap returns a slice which apply both filtering and mapping to the given slice.
+// iteratee callback function should returntwo values:
+// 1, mapping result.
+// 2, whether the result element should be included or not
+// Play: https://go.dev/play/p/J94SZ_9MiIe
+func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U {
+	result := []U{}
+
+	for i, v := range slice {
+		if a, ok := iteratee(i, v); ok {
+			result = append(result, a)
+		}
+	}
+
+	return result
+}
+
+// FlatMap manipulates a slice and transforms and flattens it to a slice of another type.
+// Play: https://go.dev/play/p/_QARWlWs1N_F
+func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U {
+	result := make([]U, 0, len(slice))
+
+	for i, v := range slice {
+		result = append(result, iteratee(i, v)...)
+	}
+
+	return result
+}
+
 // Reduce creates an slice of values by running each element of slice thru iteratee function.
 // Play: https://go.dev/play/p/_RfXJJWIsIm
 func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T {
@@ -559,7 +610,7 @@ func DeleteAt[T any](slice []T, start int, end ...int) []T {
 }
 
 // Drop drop n elements from the start of a slice.
-// Play: https://go.dev/play/p/pJ-d6MUWcvK
+// Play: https://go.dev/play/p/jnPO2yQsT8H
 func Drop[T any](slice []T, n int) []T {
 	size := len(slice)
 
@@ -577,7 +628,7 @@ func Drop[T any](slice []T, n int) []T {
 }
 
 // DropRight drop n elements from the end of a slice.
-// Play: todo
+// Play: https://go.dev/play/p/8bcXvywZezG
 func DropRight[T any](slice []T, n int) []T {
 	size := len(slice)
 
@@ -595,7 +646,7 @@ func DropRight[T any](slice []T, n int) []T {
 }
 
 // DropWhile drop n elements from the start of a slice while predicate function returns true.
-// Play: todo
+// Play: https://go.dev/play/p/4rt252UV_qs
 func DropWhile[T any](slice []T, predicate func(item T) bool) []T {
 	i := 0
 
@@ -611,7 +662,7 @@ func DropWhile[T any](slice []T, predicate func(item T) bool) []T {
 }
 
 // DropRightWhile drop n elements from the end of a slice while predicate function returns true.
-// Play: todo
+// Play: https://go.dev/play/p/6wyK3zMY56e
 func DropRightWhile[T any](slice []T, predicate func(item T) bool) []T {
 	i := len(slice) - 1
 
@@ -831,7 +882,7 @@ func Shuffle[T any](slice []T) []T {
 }
 
 // IsAscending checks if a slice is ascending order.
-// Play: todo
+// Play: https://go.dev/play/p/9CtsFjet4SH
 func IsAscending[T constraints.Ordered](slice []T) bool {
 	for i := 1; i < len(slice); i++ {
 		if slice[i-1] > slice[i] {
@@ -843,7 +894,7 @@ func IsAscending[T constraints.Ordered](slice []T) bool {
 }
 
 // IsDescending checks if a slice is descending order.
-// Play: todo
+// Play: https://go.dev/play/p/U_LljFXma14
 func IsDescending[T constraints.Ordered](slice []T) bool {
 	for i := 1; i < len(slice); i++ {
 		if slice[i-1] < slice[i] {
@@ -855,13 +906,13 @@ func IsDescending[T constraints.Ordered](slice []T) bool {
 }
 
 // IsSorted checks if a slice is sorted(ascending or descending).
-// Play: todo
+// Play: https://go.dev/play/p/nCE8wPLwSA-
 func IsSorted[T constraints.Ordered](slice []T) bool {
 	return IsAscending(slice) || IsDescending(slice)
 }
 
 // IsSortedByKey checks if a slice is sorted by iteratee function.
-// Play: todo
+// Play: https://go.dev/play/p/tUoGB7DOHI4
 func IsSortedByKey[T any, K constraints.Ordered](slice []T, iteratee func(item T) K) bool {
 	size := len(slice)
 

slice/slice_example_test.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"math"
 	"reflect"
+	"strconv"
 )
 
 func ExampleContain() {
@@ -18,6 +19,32 @@ func ExampleContain() {
 	// false
 }
 
+func ExampleContainBy() {
+	type foo struct {
+		A string
+		B int
+	}
+
+	array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
+	result1 := ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
+	result2 := ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })
+
+	array2 := []string{"a", "b", "c"}
+	result3 := ContainBy(array2, func(t string) bool { return t == "a" })
+	result4 := ContainBy(array2, func(t string) bool { return t == "d" })
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// true
+	// false
+	// true
+	// false
+}
+
 func ExampleContainSubSlice() {
 	result1 := ContainSubSlice([]string{"a", "b", "c"}, []string{"a", "b"})
 	result2 := ContainSubSlice([]string{"a", "b", "c"}, []string{"a", "d"})
@@ -352,6 +379,25 @@ func ExampleForEach() {
 	// [2 3 4]
 }
 
+func ExampleForEachWithBreak() {
+	numbers := []int{1, 2, 3, 4, 5}
+
+	var sum int
+
+	ForEachWithBreak(numbers, func(_, n int) bool {
+		if n > 3 {
+			return false
+		}
+		sum += n
+		return true
+	})
+
+	fmt.Println(sum)
+
+	// Output:
+	// 6
+}
+
 func ExampleMap() {
 	nums := []int{1, 2, 3}
 
@@ -367,6 +413,38 @@ func ExampleMap() {
 	// [2 3 4]
 }
 
+func ExampleFilterMap() {
+	nums := []int{1, 2, 3, 4, 5}
+
+	getEvenNumStr := func(i, num int) (string, bool) {
+		if num%2 == 0 {
+			return strconv.FormatInt(int64(num), 10), true
+		}
+		return "", false
+	}
+
+	result := FilterMap(nums, getEvenNumStr)
+
+	fmt.Printf("%#v", result)
+
+	// Output:
+	// []string{"2", "4"}
+}
+
+func ExampleFlatMap() {
+	nums := []int{1, 2, 3, 4}
+
+	result := FlatMap(nums, func(i int, num int) []string {
+		s := "hi-" + strconv.FormatInt(int64(num), 10)
+		return []string{s}
+	})
+
+	fmt.Printf("%#v", result)
+
+	// Output:
+	// []string{"hi-1", "hi-2", "hi-3", "hi-4"}
+}
+
 func ExampleReduce() {
 	nums := []int{1, 2, 3}
 

slice/slice_test.go

@@ -3,6 +3,7 @@ package slice
 import (
 	"fmt"
 	"math"
+	"strconv"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
@@ -19,6 +20,28 @@ func TestContain(t *testing.T) {
 	assert.Equal(true, Contain([]int{1, 2, 3}, 1))
 }
 
+func TestContainBy(t *testing.T) {
+	assert := internal.NewAssert(t, "TestContainBy")
+
+	type foo struct {
+		A string
+		B int
+	}
+
+	array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
+	result1 := ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
+	result2 := ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })
+
+	array2 := []string{"a", "b", "c"}
+	result3 := ContainBy(array2, func(t string) bool { return t == "a" })
+	result4 := ContainBy(array2, func(t string) bool { return t == "d" })
+
+	assert.Equal(true, result1)
+	assert.Equal(false, result2)
+	assert.Equal(true, result3)
+	assert.Equal(false, result4)
+}
+
 func TestContainSubSlice(t *testing.T) {
 	assert := internal.NewAssert(t, "TestContainSubSlice")
 	assert.Equal(true, ContainSubSlice([]string{"a", "a", "b", "c"}, []string{"a", "a"}))
@@ -284,6 +307,23 @@ func TestForEach(t *testing.T) {
 	assert.Equal(expected, numbersAddTwo)
 }
 
+func TestForEachWithBreak(t *testing.T) {
+	numbers := []int{1, 2, 3, 4, 5}
+
+	var sum int
+
+	ForEachWithBreak(numbers, func(_, n int) bool {
+		if n > 3 {
+			return false
+		}
+		sum += n
+		return true
+	})
+
+	assert := internal.NewAssert(t, "TestForEach")
+	assert.Equal(6, sum)
+}
+
 func TestMap(t *testing.T) {
 	nums := []int{1, 2, 3, 4}
 	multiplyTwo := func(i, num int) int {
@@ -315,6 +355,36 @@ func TestMap(t *testing.T) {
 	assert.Equal(studentsOfAdd10Aage, Map(students, mapFunc))
 }
 
+func TestFilterMap(t *testing.T) {
+	assert := internal.NewAssert(t, "TestFilterMap")
+
+	nums := []int{1, 2, 3, 4, 5}
+
+	getEvenNumStr := func(i, num int) (string, bool) {
+		if num%2 == 0 {
+			return strconv.FormatInt(int64(num), 10), true
+		}
+		return "", false
+	}
+
+	result := FilterMap(nums, getEvenNumStr)
+
+	assert.Equal([]string{"2", "4"}, result)
+}
+
+func TestFlatMap(t *testing.T) {
+	assert := internal.NewAssert(t, "TestFlatMap")
+
+	nums := []int{1, 2, 3, 4}
+
+	result := FlatMap(nums, func(i int, num int) []string {
+		s := "hi-" + strconv.FormatInt(int64(num), 10)
+		return []string{s}
+	})
+
+	assert.Equal([]string{"hi-1", "hi-2", "hi-3", "hi-4"}, result)
+}
+
 func TestReduce(t *testing.T) {
 	cases := [][]int{
 		{},

stream/stream.go

@@ -64,6 +64,7 @@ func Generate[T any](generator func() func() (item T, ok bool)) stream[T] {
 
 	var zeroValue T
 	for next, item, ok := generator(), zeroValue, true; ok; {
+
 		item, ok = next()
 		if ok {
 			source = append(source, item)
@@ -98,7 +99,7 @@ func FromRange[T constraints.Integer | constraints.Float](start, end, step T) st
 	}
 
 	l := int((end-start)/step) + 1
-	source := make([]T, l, l)
+	source := make([]T, l)
 
 	for i := 0; i < l; i++ {
 		source[i] = start + (T(i) * step)
@@ -160,7 +161,7 @@ func (s stream[T]) Filter(predicate func(item T) bool) stream[T] {
 
 // Map returns a stream consisting of the elements of this stream that apply the given function to elements of stream.
 func (s stream[T]) Map(mapper func(item T) T) stream[T] {
-	source := make([]T, s.Count(), s.Count())
+	source := make([]T, s.Count())
 
 	for i, v := range s.source {
 		source[i] = mapper(v)

structs/field.go

@@ -0,0 +1,112 @@
+package structs
+
+import (
+	"reflect"
+
+	"github.com/duke-git/lancet/v2/pointer"
+)
+
+// Field is abstract struct field for provide several high level functions
+type Field struct {
+	Struct
+	field reflect.StructField
+	tag   *Tag
+}
+
+func newField(v reflect.Value, f reflect.StructField, tagName string) *Field {
+	tag := f.Tag.Get(tagName)
+	field := &Field{
+		field: f,
+		tag:   newTag(tag),
+	}
+	field.rvalue = v
+	field.rtype = v.Type()
+	field.TagName = tagName
+	return field
+}
+
+// Tag returns the value that the key in the tag string.
+func (f *Field) Tag() *Tag {
+	return f.tag
+}
+
+// Value returns the underlying value of the field.
+func (f *Field) Value() any {
+	return f.rvalue.Interface()
+}
+
+// IsEmbedded returns true if the given field is an embedded field.
+func (f *Field) IsEmbedded() bool {
+	return len(f.field.Index) > 1
+}
+
+// IsExported returns true if the given field is exported.
+func (f *Field) IsExported() bool {
+	return f.field.IsExported()
+}
+
+// IsZero returns true if the given field is zero value.
+func (f *Field) IsZero() bool {
+	z := reflect.Zero(f.rvalue.Type()).Interface()
+	v := f.Value()
+	return reflect.DeepEqual(z, v)
+}
+
+// Name returns the name of the given field
+func (f *Field) Name() string {
+	return f.field.Name
+}
+
+// Kind returns the field's kind
+func (f *Field) Kind() reflect.Kind {
+	return f.rvalue.Kind()
+}
+
+// IsSlice check if a struct field type is slice or not
+func (f *Field) IsSlice() bool {
+	k := f.rvalue.Kind()
+	return k == reflect.Slice
+}
+
+// mapValue covert field value to map
+func (f *Field) mapValue(value any) any {
+	val := pointer.ExtractPointer(value)
+	v := reflect.ValueOf(val)
+	var ret any
+
+	switch v.Kind() {
+	case reflect.Struct:
+		s := New(val)
+		s.TagName = f.TagName
+		m, _ := s.ToMap()
+		ret = m
+	case reflect.Map:
+		mapEl := v.Type().Elem()
+		switch mapEl.Kind() {
+		case reflect.Ptr, reflect.Array, reflect.Map, reflect.Slice, reflect.Chan:
+			// iterate the map
+			m := make(map[string]any, v.Len())
+			for _, key := range v.MapKeys() {
+				m[key.String()] = f.mapValue(v.MapIndex(key).Interface())
+			}
+			ret = m
+		default:
+			ret = v.Interface()
+		}
+	case reflect.Slice, reflect.Array:
+		sEl := v.Type().Elem()
+		switch sEl.Kind() {
+		case reflect.Ptr, reflect.Array, reflect.Map, reflect.Slice, reflect.Chan:
+			slices := make([]any, v.Len())
+			for i := 0; i < v.Len(); i++ {
+				slices[i] = f.mapValue(v.Index(i).Interface())
+			}
+			ret = slices
+		default:
+			ret = v.Interface()
+		}
+	default:
+		ret = v.Interface()
+	}
+	return ret
+}

structs/field_test.go

@@ -0,0 +1,272 @@
+package structs
+
+import (
+	"github.com/duke-git/lancet/v2/internal"
+	"reflect"
+	"testing"
+)
+
+func TestField_Tag(t *testing.T) {
+	assert := internal.NewAssert(t, "TestField_Tag")
+
+	type Parent struct {
+		Name string `json:"name,omitempty"`
+	}
+	p1 := &Parent{"111"}
+
+	s := New(p1)
+	n, _ := s.Field("Name")
+	tag := n.Tag()
+	assert.Equal("name", tag.Name)
+	assert.Equal(true, tag.HasOption("omitempty"))
+}
+
+func TestField_Value(t *testing.T) {
+	assert := internal.NewAssert(t, "TestField_Value")
+
+	type Parent struct {
+		Name string `json:"name,omitempty"`
+	}
+	p1 := &Parent{"111"}
+
+	s := New(p1)
+	n, _ := s.Field("Name")
+
+	assert.Equal("111", n.Value())
+}
+
+func TestField_IsEmbedded(t *testing.T) {
+	assert := internal.NewAssert(t, "TestField_IsEmbedded")
+	type Parent struct {
+		Name string
+	}
+	type Child struct {
+		Parent
+		Age int
+	}
+	c1 := &Child{}
+	c1.Name = "111"
+	c1.Age = 11
+
+	s := New(c1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+	assert.Equal(true, n.IsEmbedded())
+	assert.Equal(false, a.IsEmbedded())
+}
+
+func TestField_IsExported(t *testing.T) {
+	assert := internal.NewAssert(t, "TestField_IsEmbedded")
+
+	type Parent struct {
+		Name string
+		age  int
+	}
+	p1 := &Parent{Name: "11", age: 11}
+	s := New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("age")
+	assert.Equal(true, n.IsExported())
+	assert.Equal(false, a.IsExported())
+}
+
+func TestField_IsZero(t *testing.T) {
+	assert := internal.NewAssert(t, "TestField_IsZero")
+
+	type Parent struct {
+		Name string
+		Age  int
+	}
+	p1 := &Parent{Age: 11}
+	s := New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+	assert.Equal(true, n.IsZero())
+	assert.Equal(false, a.IsZero())
+}
+
+func TestField_Name(t *testing.T) {
+	assert := internal.NewAssert(t, "TestField_Name")
+
+	type Parent struct {
+		Name string
+		Age  int
+	}
+	p1 := &Parent{Age: 11}
+	s := New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+
+	assert.Equal("Name", n.Name())
+	assert.Equal("Age", a.Name())
+}
+
+func TestField_Kind(t *testing.T) {
+	assert := internal.NewAssert(t, "TestField_Kind")
+
+	type Parent struct {
+		Name string
+		Age  int
+	}
+	p1 := &Parent{Age: 11}
+	s := New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("Age")
+
+	assert.Equal(reflect.String, n.Kind())
+	assert.Equal(reflect.Int, a.Kind())
+}
+
+func TestField_IsSlice(t *testing.T) {
+	assert := internal.NewAssert(t, "TestField_IsSlice")
+
+	type Parent struct {
+		Name string
+		arr  []int
+	}
+
+	p1 := &Parent{arr: []int{1, 2, 3}}
+	s := New(p1)
+	a, _ := s.Field("arr")
+
+	assert.Equal(true, a.IsSlice())
+}
+
+func TestField_MapValue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestField_MapValue")
+
+	t.Run("nested struct", func(t *testing.T) {
+		type Child struct {
+			Name string `json:"name"`
+		}
+		type Parent struct {
+			Name  string `json:"name"`
+			Child *Child `json:"child"`
+		}
+
+		c1 := &Child{"11-1"}
+		p1 := &Parent{
+			Name:  "11",
+			Child: c1,
+		}
+
+		s := New(p1)
+		f, ok := s.Field("Child")
+		val := f.mapValue(f.Value())
+
+		assert.Equal(true, ok)
+		assert.Equal(map[string]any{"name": "11-1"}, val)
+	})
+
+	t.Run("nested ptr struct", func(t *testing.T) {
+		type Child struct {
+			Name string `json:"name"`
+		}
+		type Parent struct {
+			Name  string `json:"name"`
+			Child any    `json:"child"`
+		}
+		c1 := &Child{"11-1"}
+		c2 := &c1
+		c3 := &c2
+		p1 := &Parent{
+			Name:  "11",
+			Child: c3,
+		}
+
+		s := New(p1)
+		f, ok := s.Field("Child")
+		val := f.mapValue(f.Value())
+
+		assert.Equal(true, ok)
+		assert.Equal(map[string]any{"name": "11-1"}, val)
+	})
+
+	t.Run("nested array", func(t *testing.T) {
+		type Parent struct {
+			Name  string `json:"name"`
+			Child []int  `json:"child"`
+		}
+
+		p1 := &Parent{
+			Name:  "11",
+			Child: []int{1, 2, 3},
+		}
+
+		s := New(p1)
+		f, ok := s.Field("Child")
+		val := f.mapValue(f.Value())
+
+		assert.Equal(true, ok)
+		assert.Equal([]int{1, 2, 3}, val)
+	})
+
+	t.Run("nested array struct", func(t *testing.T) {
+		type Child struct {
+			Name string `json:"name"`
+		}
+		type Parent struct {
+			Name  string   `json:"name"`
+			Child []*Child `json:"child"`
+		}
+
+		c1 := &Child{"11-1"}
+		c2 := &Child{"11-2"}
+
+		p1 := &Parent{
+			Name:  "11",
+			Child: []*Child{c1, c2},
+		}
+
+		s := New(p1)
+		f, ok := s.Field("Child")
+		val := f.mapValue(f.Value())
+
+		assert.Equal(true, ok)
+		arr := []any{map[string]any{"name": "11-1"}, map[string]any{"name": "11-2"}}
+		assert.Equal(arr, val)
+	})
+
+	t.Run("nested ptr array struct", func(t *testing.T) {
+		type Child struct {
+			Name string `json:"name"`
+		}
+		type Parent struct {
+			Name  string    `json:"name"`
+			Child *[]*Child `json:"child"`
+		}
+
+		c1 := &Child{"11-1"}
+		c2 := &Child{"11-2"}
+
+		p1 := &Parent{
+			Name:  "11",
+			Child: &[]*Child{c1, c2},
+		}
+
+		s := New(p1)
+		f, ok := s.Field("Child")
+		val := f.mapValue(f.Value())
+
+		assert.Equal(true, ok)
+		arr := []any{map[string]any{"name": "11-1"}, map[string]any{"name": "11-2"}}
+		assert.Equal(arr, val)
+	})
+
+	t.Run("nested map in struct", func(t *testing.T) {
+		type Parent struct {
+			Name  string         `json:"name"`
+			Child map[string]any `json:"child"`
+		}
+		p1 := &Parent{
+			Name:  "11",
+			Child: map[string]any{"a": 1, "b": map[string]any{"name": "11-1"}},
+		}
+
+		s := New(p1)
+		f, ok := s.Field("Child")
+		val := f.mapValue(f.Value())
+		assert.Equal(true, ok)
+		assert.Equal(map[string]any{"a": 1, "b": map[string]any{"name": "11-1"}}, val)
+	})
+}

structs/struct.go

@@ -0,0 +1,117 @@
+// Package structs provide several high level functions to manipulate struct, tag, and field.
+package structs
+
+import (
+	"reflect"
+
+	"github.com/duke-git/lancet/v2/pointer"
+)
+
+// defaultTagName is the default tag for struct fields to lookup.
+var defaultTagName = "json"
+
+// Struct is abstract struct for provide several high level functions
+type Struct struct {
+	raw     any
+	rtype   reflect.Type
+	rvalue  reflect.Value
+	TagName string
+}
+
+// New returns a new *Struct
+func New(value any, tagName ...string) *Struct {
+	value = pointer.ExtractPointer(value)
+	v := reflect.ValueOf(value)
+	t := reflect.TypeOf(value)
+
+	tn := defaultTagName
+
+	if len(tagName) > 0 {
+		tn = tagName[0]
+	}
+
+	// if need: can also set defaultTagName to tn across structs package level
+	// defaultTagName = tn
+
+	return &Struct{
+		raw:     value,
+		rtype:   t,
+		rvalue:  v,
+		TagName: tn,
+	}
+}
+
+// ToMap converts the given struct to a map[string]any, where the keys
+// of the keys are the field names and the values of the map are the values
+// of the fields. The default map key is the struct field name, but you can
+// change it. The `json` key is the default tag key. Example:
+//
+//		// default
+//		Name string `json:"name"`
+//
+//		// ignore the field
+//		Name string							// no tag
+//	 	Age string `json:"-"`				// json ignore tag
+//		sex string							// unexported field
+//	 	Goal int   `json:"goal,omitempty"`  // omitempty if the field is zero value
+//
+//	 	// custom map key
+//	 	Name string `json:"myName"`
+//
+// ToMap convert the exported fields of a struct to map.
+func (s *Struct) ToMap() (map[string]any, error) {
+	if !s.IsStruct() {
+		return nil, errInvalidStruct(s)
+	}
+
+	result := make(map[string]any)
+	fields := s.Fields()
+	for _, f := range fields {
+		if !f.IsExported() || f.tag.IsEmpty() || f.tag.Name == "-" {
+			continue
+		}
+		if f.IsZero() && f.tag.HasOption("omitempty") {
+			continue
+		}
+		result[f.tag.Name] = f.mapValue(f.Value())
+	}
+
+	return result, nil
+}
+
+// Fields returns all the struct fields within a slice
+func (s *Struct) Fields() []*Field {
+	var fields []*Field
+	fieldNum := s.rvalue.NumField()
+	for i := 0; i < fieldNum; i++ {
+		v := s.rvalue.Field(i)
+		sf := s.rtype.Field(i)
+		field := newField(v, sf, s.TagName)
+		fields = append(fields, field)
+	}
+	return fields
+}
+
+// Field returns a Field if the given field name was found
+func (s *Struct) Field(name string) (*Field, bool) {
+	f, ok := s.rtype.FieldByName(name)
+	if !ok {
+		return nil, false
+	}
+	return newField(s.rvalue.FieldByName(name), f, s.TagName), true
+}
+
+// IsStruct returns true if the given rvalue is a struct
+func (s *Struct) IsStruct() bool {
+	k := s.rvalue.Kind()
+	if k == reflect.Invalid {
+		return false
+	}
+	return k == reflect.Struct
+}
+
+// ToMap convert struct to map, only convert exported struct field
+// map key is specified same as struct field tag `json` value.
+func ToMap(v any) (map[string]any, error) {
+	return New(v).ToMap()
+}

structs/struct_internal.go

@@ -0,0 +1,7 @@
+package structs
+
+import "fmt"
+
+func errInvalidStruct(v any) error {
+	return fmt.Errorf("invalid struct %v", v)
+}

structs/struct_test.go

@@ -0,0 +1,132 @@
+package structs
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestStruct_ToMap(t *testing.T) {
+	assert := internal.NewAssert(t, "TestStruct_ToMap")
+
+	t.Run("invalid struct", func(t *testing.T) {
+		m, _ := ToMap(1)
+		var expected map[string]any
+		assert.Equal(expected, m)
+	})
+
+	t.Run("StructToMap", func(_ *testing.T) {
+		type People struct {
+			Name string `json:"name"`
+			age  int
+		}
+		p := &People{
+			"test",
+			100,
+		}
+		pm, _ := ToMap(p)
+		var expected = map[string]any{"name": "test"}
+		assert.Equal(expected, pm)
+	})
+
+	t.Run("StructToMapWithJsonAttr", func(_ *testing.T) {
+		type People struct {
+			Name      string `json:"name,omitempty"` // json tag with attribute
+			Phone     string `json:"phone"`          // json tag without attribute
+			Sex       string `json:"-"`              // ignore by "-"
+			Age       int    // ignore by no tag
+			email     string // ignore by unexported
+			IsWorking bool   `json:"is_working"`
+		}
+		p1 := People{
+			Name:  "AAA", // exist
+			Phone: "1111",
+			Sex:   "male",
+			Age:   100,
+			email: "11@gmail.com",
+		}
+		p1m, _ := ToMap(p1)
+		var expect1 = map[string]any{"name": "AAA", "phone": "1111", "is_working": false}
+		assert.Equal(expect1, p1m)
+
+		p2 := People{
+			Name:      "",
+			Phone:     "2222",
+			Sex:       "male",
+			Age:       0,
+			email:     "22@gmail.com",
+			IsWorking: true,
+		}
+		p2m, _ := ToMap(p2)
+		var expect2 = map[string]any{"phone": "2222", "is_working": true}
+		assert.Equal(expect2, p2m)
+	})
+}
+
+func TestStruct_Fields(t *testing.T) {
+	assert := internal.NewAssert(t, "TestStruct_Fields")
+
+	type Parent struct {
+		A string         `json:"a"`
+		B int            `json:"b"`
+		C []string       `json:"c"`
+		D map[string]any `json:"d"`
+	}
+
+	p1 := &Parent{
+		A: "1",
+		B: 11,
+		C: []string{"11", "22"},
+		D: map[string]any{"d1": 1, "d2": 2},
+	}
+
+	s := New(p1)
+	fields := s.Fields()
+	assert.Equal(4, len(fields))
+	assert.Equal(reflect.String, fields[0].Kind())
+	assert.Equal(reflect.Int, fields[1].Kind())
+	assert.Equal(reflect.Slice, fields[2].Kind())
+	assert.Equal(reflect.Map, fields[3].Kind())
+}
+
+func TestStruct_Field(t *testing.T) {
+	assert := internal.NewAssert(t, "TestStruct_Field")
+
+	type Parent struct {
+		A string         `json:"a"`
+		B int            `json:"b"`
+		C []string       `json:"c"`
+		D map[string]any `json:"d"`
+	}
+
+	p1 := &Parent{
+		A: "1",
+		B: 11,
+		C: []string{"11", "22"},
+		D: map[string]any{"d1": 1, "d2": 2},
+	}
+
+	s := New(p1)
+	a, ok := s.Field("A")
+	assert.Equal(true, ok)
+	assert.Equal(reflect.String, a.Kind())
+	assert.Equal("1", a.Value())
+	assert.Equal("a", a.tag.Name)
+	assert.Equal(false, a.tag.HasOption("omitempty"))
+	assert.Equal(false, a.tag.IsEmpty())
+}
+
+func TestStruct_IsStruct(t *testing.T) {
+	assert := internal.NewAssert(t, "TestStruct_Field")
+
+	type Test1 struct{}
+	t1 := &Test1{}
+	t2 := 1
+
+	s1 := New(t1)
+	s2 := New(t2)
+
+	assert.Equal(true, s1.IsStruct())
+	assert.Equal(false, s2.IsStruct())
+}

structs/tag.go

@@ -0,0 +1,36 @@
+package structs
+
+import (
+	"strings"
+
+	"github.com/duke-git/lancet/v2/validator"
+)
+
+// Tag is abstract struct field tag
+type Tag struct {
+	Name    string
+	Options []string
+}
+
+func newTag(tag string) *Tag {
+	res := strings.Split(tag, ",")
+	return &Tag{
+		Name:    res[0],
+		Options: res[1:],
+	}
+}
+
+// HasOption check if a struct field tag has option setting.
+func (t *Tag) HasOption(opt string) bool {
+	for _, o := range t.Options {
+		if o == opt {
+			return true
+		}
+	}
+	return false
+}
+
+// IsEmpty check if a struct field has tag setting.
+func (t *Tag) IsEmpty() bool {
+	return validator.IsEmptyString(t.Name)
+}

strutil/string.go

@@ -67,44 +67,25 @@ func LowerFirst(s string) string {
 	return string(r) + s[size:]
 }
 
-// PadEnd pads string on the right side if it's shorter than size.
+// PadStart pads string on the left and right side if it's shorter than size.
 // Padding characters are truncated if they exceed size.
-// Play: https://go.dev/play/p/9xP8rN0vz--
+// Play: https://go.dev/play/p/NzImQq-VF8q
-func PadEnd(source string, size int, padStr string) string {
+func Pad(source string, size int, padStr string) string {
-	len1 := len(source)
+	return padAtPosition(source, size, padStr, 0)
-	len2 := len(padStr)
-
-	if len1 >= size {
-		return source
-	}
-
-	fill := ""
-	if len2 >= size-len1 {
-		fill = padStr[0 : size-len1]
-	} else {
-		fill = strings.Repeat(padStr, size-len1)
-	}
-	return source + fill[0:size-len1]
 }
 
 // PadStart pads string on the left side if it's shorter than size.
 // Padding characters are truncated if they exceed size.
 // Play: https://go.dev/play/p/xpTfzArDfvT
 func PadStart(source string, size int, padStr string) string {
-	len1 := len(source)
+	return padAtPosition(source, size, padStr, 1)
-	len2 := len(padStr)
-
-	if len1 >= size {
-		return source
 }
 
-	fill := ""
+// PadEnd pads string on the right side if it's shorter than size.
-	if len2 >= size-len1 {
+// Padding characters are truncated if they exceed size.
-		fill = padStr[0 : size-len1]
+// Play: https://go.dev/play/p/9xP8rN0vz--
-	} else {
+func PadEnd(source string, size int, padStr string) string {
-		fill = strings.Repeat(padStr, size-len1)
+	return padAtPosition(source, size, padStr, 2)
-	}
-	return fill[0:size-len1] + source
 }
 
 // KebabCase coverts string to kebab-case, non letters and numbers will be ignored.
@@ -306,3 +287,76 @@ func Substring(s string, offset int, length uint) string {
 
 	return strings.Replace(str, "\x00", "", -1)
 }
+
+// SplitWords splits a string into words, word only contains alphabetic characters.
+// Play: https://go.dev/play/p/KLiX4WiysMM
+func SplitWords(s string) []string {
+	var word string
+	var words []string
+	var r rune
+	var size, pos int
+
+	isWord := false
+
+	for len(s) > 0 {
+		r, size = utf8.DecodeRuneInString(s)
+
+		switch {
+		case isLetter(r):
+			if !isWord {
+				isWord = true
+				word = s
+				pos = 0
+			}
+
+		case isWord && (r == '\'' || r == '-'):
+			// is word
+
+		default:
+			if isWord {
+				isWord = false
+				words = append(words, word[:pos])
+			}
+		}
+
+		pos += size
+		s = s[size:]
+	}
+
+	if isWord {
+		words = append(words, word[:pos])
+	}
+
+	return words
+}
+
+// WordCount return the number of meaningful word, word only contains alphabetic characters.
+// Play: https://go.dev/play/p/bj7_odx3vRf
+func WordCount(s string) int {
+	var r rune
+	var size, count int
+
+	isWord := false
+
+	for len(s) > 0 {
+		r, size = utf8.DecodeRuneInString(s)
+
+		switch {
+		case isLetter(r):
+			if !isWord {
+				isWord = true
+				count++
+			}
+
+		case isWord && (r == '\'' || r == '-'):
+			// is word
+
+		default:
+			isWord = false
+		}
+
+		s = s[size:]
+	}
+
+	return count
+}

strutil/string_example_test.go

@@ -186,6 +186,33 @@ func ExampleUpperFirst() {
 	// Bar大
 }
 
+func ExamplePad() {
+	result1 := Pad("foo", 1, "bar")
+	result2 := Pad("foo", 2, "bar")
+	result3 := Pad("foo", 3, "bar")
+	result4 := Pad("foo", 4, "bar")
+	result5 := Pad("foo", 5, "bar")
+	result6 := Pad("foo", 6, "bar")
+	result7 := Pad("foo", 7, "bar")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+	fmt.Println(result7)
+
+	// Output:
+	// foo
+	// foo
+	// foo
+	// foob
+	// bfoob
+	// bfooba
+	// bafooba
+}
+
 func ExamplePadEnd() {
 	result1 := PadEnd("foo", 1, "bar")
 	result2 := PadEnd("foo", 2, "bar")
@@ -361,3 +388,53 @@ func ExampleSubstring() {
 	// de
 	// 你好
 }
+
+func ExampleSplitWords() {
+
+	result1 := SplitWords("a word")
+	result2 := SplitWords("I'am a programmer")
+	result3 := SplitWords("Bonjour, je suis programmeur")
+	result4 := SplitWords("a -b-c' 'd'e")
+	result5 := SplitWords("你好，我是一名码农")
+	result6 := SplitWords("こんにちは，私はプログラマーです")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+
+	// Output:
+	// [a word]
+	// [I'am a programmer]
+	// [Bonjour je suis programmeur]
+	// [a b-c' d'e]
+	// []
+	// []
+}
+
+func ExampleWordCount() {
+
+	result1 := WordCount("a word")
+	result2 := WordCount("I'am a programmer")
+	result3 := WordCount("Bonjour, je suis programmeur")
+	result4 := WordCount("a -b-c' 'd'e")
+	result5 := WordCount("你好，我是一名码农")
+	result6 := WordCount("こんにちは，私はプログラマーです")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+
+	// Output:
+	// 2
+	// 3
+	// 4
+	// 3
+	// 0
+	// 0
+}

strutil/string_internal.go

@@ -98,3 +98,73 @@ func toUpperAll(rs []rune) []rune {
 	}
 	return rs
 }
+
+// padWithPosition pads string
+func padAtPosition(str string, length int, padStr string, position int) string {
+	if len(str) >= length {
+		return str
+	}
+
+	if padStr == "" {
+		padStr = " "
+	}
+
+	length = length - len(str)
+	startPadLen := 0
+	if position == 0 {
+		startPadLen = length / 2
+	} else if position == 1 {
+		startPadLen = length
+	}
+	endPadLen := length - startPadLen
+
+	charLen := len(padStr)
+	leftPad := ""
+	cur := 0
+	for cur < startPadLen {
+		leftPad += string(padStr[cur%charLen])
+		cur++
+	}
+
+	cur = 0
+	rightPad := ""
+	for cur < endPadLen {
+		rightPad += string(padStr[cur%charLen])
+		cur++
+	}
+
+	return leftPad + str + rightPad
+}
+
+// isLetter checks r is a letter but not CJK character.
+func isLetter(r rune) bool {
+	if !unicode.IsLetter(r) {
+		return false
+	}
+
+	switch {
+	// cjk char: /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uff66-\uff9f]/
+
+	// hiragana and katakana (Japanese only)
+	case r >= '\u3034' && r < '\u30ff':
+		return false
+
+	// CJK unified ideographs extension A (Chinese, Japanese, and Korean)
+	case r >= '\u3400' && r < '\u4dbf':
+		return false
+
+	// CJK unified ideographs (Chinese, Japanese, and Korean)
+	case r >= '\u4e00' && r < '\u9fff':
+		return false
+
+	// CJK compatibility ideographs (Chinese, Japanese, and Korean)
+	case r >= '\uf900' && r < '\ufaff':
+		return false
+
+	// half-width katakana (Japanese only)
+	case r >= '\uff66' && r < '\uff9f':
+		return false
+	}
+
+	return true
+}

strutil/string_test.go

@@ -168,9 +168,19 @@ func TestLowerFirst(t *testing.T) {
 	}
 }
 
+func TestPad(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPad")
+
+	assert.Equal("a ", Pad("a", 2, ""))
+	assert.Equal("a", Pad("a", 1, "b"))
+	assert.Equal("ab", Pad("a", 2, "b"))
+	assert.Equal("mabcdm", Pad("abcd", 6, "m"))
+}
+
 func TestPadEnd(t *testing.T) {
 	assert := internal.NewAssert(t, "TestPadEnd")
 
+	assert.Equal("a ", PadEnd("a", 2, " "))
 	assert.Equal("a", PadEnd("a", 1, "b"))
 	assert.Equal("ab", PadEnd("a", 2, "b"))
 	assert.Equal("abcdmn", PadEnd("abcd", 6, "mno"))
@@ -298,3 +308,37 @@ func TestSubstring(t *testing.T) {
 	assert.Equal("de", Substring("abcde", -2, 3))
 	assert.Equal("你好", Substring("你好，欢迎你", 0, 2))
 }
+
+func TestSplitWords(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSplitWords")
+
+	cases := map[string][]string{
+		"a word":                       {"a", "word"},
+		"I'am a programmer":            {"I'am", "a", "programmer"},
+		"Bonjour, je suis programmeur": {"Bonjour", "je", "suis", "programmeur"},
+		"a -b-c' 'd'e":                 {"a", "b-c'", "d'e"},
+		"你好，我是一名码农":                    nil,
+		"こんにちは，私はプログラマーです": nil,
+	}
+
+	for k, v := range cases {
+		assert.Equal(v, SplitWords(k))
+	}
+}
+
+func TestWordCount(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSplitWords")
+
+	cases := map[string]int{
+		"a word":                       2, //   {"a", "word"},
+		"I'am a programmer":            3, //   {"I'am", "a", "programmer"},
+		"Bonjour, je suis programmeur": 4, // {"Bonjour", "je", "suis", "programmeur"},
+		"a -b-c' 'd'e":                 3, // {"a", "b-c'", "d'e"},
+		"你好，我是一名码农":                    0, // nil,
+		"こんにちは，私はプログラマーです": 0, // nil,
+	}
+
+	for k, v := range cases {
+		assert.Equal(v, WordCount(k))
+	}
+}