fix: test failed

fix: test failed in promise test
release v2.1.17
2026-03-01 00:35:28 +08:00 · 2023-03-20 16:39:56 +08:00 · 2023-03-20 16:26:21 +08:00 · 2023-03-20 16:17:52 +08:00 · 2023-03-20 16:12:58 +08:00 · 2023-03-20 11:10:35 +08:00
49 changed files with 4505 additions and 678 deletions
--- a/README.md
+++ b/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
@@ -249,7 +249,9 @@ import "github.com/duke-git/lancet/v2/convertor"
 -   **<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.

@@ -454,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
@@ -591,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
@@ -606,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-)]
@@ -621,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)]
@@ -669,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.

@@ -733,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
@@ -806,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)]
@@ -860,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)]
@@ -872,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)]
@@ -981,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"
@@ -1021,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--)]
@@ -1048,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.

@@ -1085,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"
@@ -1178,13 +1268,14 @@ 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)]
@@ -1225,7 +1316,6 @@ import "github.com/duke-git/lancet/v2/xerror"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#TryUnwrap)]
    [[play](https://go.dev/play/p/acyZVkNZEeW)]

-
 ## How to Contribute

 I really appreciate any code commits which make lancet lib powerful. Please follow the rules below to create your pull request.
--- a/README_zh-CN.md
+++ b/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版本
 ```

 ## 用法
@@ -248,8 +248,9 @@ import "github.com/duke-git/lancet/v2/convertor"
 -   **<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。

@@ -355,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
@@ -456,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
@@ -490,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
@@ -595,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
@@ -610,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-)]
@@ -625,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)]
@@ -673,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 请求。

@@ -737,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
@@ -773,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
@@ -799,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
@@ -808,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)]
@@ -868,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)]
@@ -880,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)]
@@ -989,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"
@@ -1031,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--)]
@@ -1058,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"
@@ -1095,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"
@@ -1188,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)]

-
-### 20. xerror 包实现一些错误处理函数
+### 21. xerror包实现一些错误处理函数

 ```go
 import "github.com/duke-git/lancet/v2/xerror"
@@ -1237,7 +1318,6 @@ import "github.com/duke-git/lancet/v2/xerror"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#TryUnwrap)]
    [[play](https://go.dev/play/p/acyZVkNZEeW)]

-
 ## 如何贡献代码

 非常感激任何的代码提交以使 lancet 的功能越来越强大。创建 pull request 时请遵守以下规则。
--- a/async/promise.go
+++ b/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)
+	})
+}
--- a/async/promise_example_test.go
+++ b/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
+}
--- a/async/promise_test.go
+++ b/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())
+	})
+
+}
--- a/concurrency/channel.go
+++ b/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 (
--- a/convertor/convertor.go
+++ b/convertor/convertor.go
@@ -11,9 +11,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/duke-git/lancet/v2/structs"
 	"math"
 	"reflect"
-	"regexp"
 	"strconv"
 	"strings"
 )
@@ -235,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)
-	t := reflect.TypeOf(value)
-
-	if t.Kind() == reflect.Ptr {
-		t = t.Elem()
-	}
-	if t.Kind() != reflect.Struct {
-		return nil, fmt.Errorf("data type %T not support, shuld be struct or pointer to struct", value)
-	}
-
-	result := make(map[string]any)
-
-	fieldNum := t.NumField()
-	pattern := `^[A-Z]`
-	regex := regexp.MustCompile(pattern)
-	for i := 0; i < fieldNum; i++ {
-		name := t.Field(i).Name
-		tag := t.Field(i).Tag.Get("json")
-		if regex.MatchString(name) && tag != "" {
-			//result[name] = v.Field(i).Interface()
-			result[tag] = v.Field(i).Interface()
-		}
-	}
-
-	return result, nil
+	return structs.ToMap(value)
 }

 // MapToSlice convert map to slice based on iteratee function.
@@ -343,11 +319,11 @@ func DeepClone[T any](src T) T {
 }

 // CopyProperties copies each field from the source into the destination. It recursively copies struct pointers and interfaces that contain struct pointers.
-// Play: todo
+// 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 = errors.New(fmt.Sprintf("%v", e))
+			err = fmt.Errorf("%v", e)
 		}
 	}()

--- a/convertor/convertor_example_test.go
+++ b/convertor/convertor_example_test.go
@@ -260,7 +260,7 @@ func ExampleDeepClone() {
 		Float float64
 		Bool  bool
 		Nil   interface{}
-		unexported string
+		// unexported string
 	}

 	cases := []interface{}{
@@ -323,12 +323,18 @@ func ExampleCopyProperties() {
 	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)
+	err := CopyProperties(&employee1, &user)
+	if err != nil {
+		return
+	}

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

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

 	fmt.Println(employee1)
 	fmt.Println(employee2)
--- a/convertor/convertor_test.go
+++ b/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)
-
-	expected := map[string]any{"name": "test"}
+		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
+			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{}{
--- a/datastructure/set/set.go
+++ b/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
+}
--- a/datastructure/set/set_test.go
+++ b/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)
+// }
--- a/docs/concurrency.md
+++ b/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>

--- a/docs/concurrency_zh-CN.md
+++ b/docs/concurrency_zh-CN.md
@@ -1,5 +1,5 @@
 # Concurrency
-并发包包含一些支持并发编程的功能。例如：goroutine, channel, async等。
+并发包包含一些支持并发编程的功能。例如：goroutine, channel等。

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

--- a/docs/datastructure/set.md
+++ b/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
+}
+```
--- a/docs/datastructure/set_zh-CN.md
+++ b/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
+}
+```
--- a/docs/maputil_zh-CN.md
+++ b/docs/maputil_zh-CN.md
@@ -90,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>

@@ -135,7 +135,7 @@ func main() {

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

-<p>迭代map, 返回一个新map，其key都是给定的key值.</p>
+<p>迭代map, 返回一个新map，其key都是给定的key值。</p>

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

@@ -174,7 +174,7 @@ func main() {

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

-<p>迭代map, 返回一个新map，其value都是给定的value值.</p>
+<p>迭代map, 返回一个新map，其value都是给定的value值。</p>

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

@@ -213,7 +213,7 @@ func main() {

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

-<p>Filter的反向操作, 迭代map中的每对key和value, 删除符合predicate函数的key, value, 返回新map</p>
+<p>Filter的反向操作, 迭代map中的每对key和value, 删除符合predicate函数的key, value, 返回新map。</p>

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

@@ -255,7 +255,7 @@ func main() {

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

-<p>FilterByKeys的反向操作, 迭代map, 返回一个新map，其key不包括给定的key值.</p>
+<p>FilterByKeys的反向操作, 迭代map, 返回一个新map，其key不包括给定的key值。</p>

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

@@ -294,7 +294,7 @@ func main() {

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

-<p>FilterByValues的反向操作, 迭代map, 返回一个新map，其value不包括给定的value值.</p>
+<p>FilterByValues的反向操作, 迭代map, 返回一个新map，其value不包括给定的value值。</p>

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

--- a/docs/mathutil.md
+++ b/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]
+}
+```
--- a/docs/mathutil_zh-CN.md
+++ b/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]
+}
+```
--- a/docs/netutil.md
+++ b/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
+    //
 }
 ```

--- a/docs/netutil_zh-CN.md
+++ b/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
+    //
 }
 ```

--- a/docs/slice.md
+++ b/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>
--- a/docs/slice_zh-CN.md
+++ b/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>
--- a/docs/structs/field.md
+++ b/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
+}
+```
--- a/docs/structs/field_zh-CN.md
+++ b/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
+}
+```
--- a/docs/structs/struct.md
+++ b/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
+}
+```
--- a/docs/structs/struct_zh-CN.md
+++ b/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
+}
+```
--- a/internal/assert.go
+++ b/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) {
-	if value != nil {
-		makeTestFailed(a.T, a.CaseName, nil, value)
+func (a *Assert) IsNil(v any) {
+	if v == nil || (reflect.ValueOf(v).Kind() == reflect.Ptr && reflect.ValueOf(v).IsNil()) {
+		return
 	}
+
+	makeTestFailed(a.T, a.CaseName, nil, v)
 }

 // IsNotNil check if value is not nil
-func (a *Assert) IsNotNil(value any) {
-	if value == nil {
-		makeTestFailed(a.T, a.CaseName, "not nil", value)
+func (a *Assert) IsNotNil(v any) {
+	if v == nil || (reflect.ValueOf(v).Kind() == reflect.Ptr && reflect.ValueOf(v).IsNil()) {
+		makeTestFailed(a.T, a.CaseName, "not nil", v)
 	}
 }

--- a/internal/error_join.go
+++ b/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
+}
--- a/maputil/map.go
+++ b/maputil/map.go
@@ -39,7 +39,7 @@ func Values[K comparable, V any](m map[K]V) []V {
 }

 // KeysBy creates a slice whose element is the result of function mapper invoked by every map's key.
-// Play: todo
+// 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))

@@ -51,7 +51,7 @@ func KeysBy[K comparable, V any, T any](m map[K]V, mapper func(item K) T) []T {
 }

 // ValuesBy creates a slice whose element is the result of function mapper invoked by every map's value.
-// Play: todo
+// 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))

@@ -98,7 +98,7 @@ func Filter[K comparable, V any](m map[K]V, predicate func(key K, value V) bool)
 }

 // FilterByKeys iterates over map, return a new map whose keys are all given keys.
-// Play: todo
+// 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)

@@ -111,7 +111,7 @@ func FilterByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V {
 }

 // FilterByValues iterates over map, return a new map whose values are all given values.
-// Play: todo
+// 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)

@@ -124,7 +124,7 @@ func FilterByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V {
 }

 // OmitBy is the opposite of Filter, removes all the map elements for which the predicate function returns true.
-// Play: todo
+// 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)

@@ -137,7 +137,7 @@ func OmitBy[K comparable, V any](m map[K]V, predicate func(key K, value V) bool)
 }

 // OmitByKeys the opposite of FilterByKeys, extracts all the map elements which keys are not omitted.
-// Play: todo
+// 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)

@@ -150,7 +150,7 @@ func OmitByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V {
 }

 // OmitByValues the opposite of FilterByValues. remov all elements whose value are in the give slice.
-// Play: todo
+// 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)

@@ -227,7 +227,7 @@ type Entry[K comparable, V any] struct {
 }

 // Entries transforms a map into array of key/value pairs.
-// Play: todo
+// 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))

@@ -242,7 +242,7 @@ func Entries[K comparable, V any](m map[K]V) []Entry[K, V] {
 }

 // FromEntries creates a map based on a slice of key/value pairs
-// Play: todo
+// 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))

@@ -254,7 +254,7 @@ func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V {
 }

 // Transform a map to another type map.
-// Play: todo
+// 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))

@@ -267,7 +267,7 @@ func Transform[K1 comparable, V1 any, K2 comparable, V2 any](m map[K1]V1, iterat
 }

 // MapKeys transforms a map to other type map by manipulating it's keys.
-// Play: todo
+// 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))

@@ -279,7 +279,7 @@ func MapKeys[K comparable, V any, T comparable](m map[K]V, iteratee func(key K,
 }

 // MapValues transforms a map to other type map by manipulating it's values.
-// Play: todo
+// 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))

--- a/mathutil/mathutil.go
+++ b/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
+}
--- a/mathutil/mathutil_exmaple_test.go
+++ b/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]
+}
--- a/mathutil/mathutil_test.go
+++ b/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)
+}
--- a/netutil/http.go
+++ b/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 {
-	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))
-	}
-
+func StructToUrlValues(targetStruct any) (url.Values, error) {
 	result := url.Values{}
-
-	fieldNum := rt.NumField()
-	pattern := `^[A-Z]`
-	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()))
+	s, err := convertor.StructToMap(targetStruct)
+	if err != nil {
+		return nil, err
 	}
+	for k, v := range s {
+		result.Add(k, fmt.Sprintf("%v", v))
 	}

-	return result
+	return result, nil
 }
--- a/netutil/http_test.go
+++ b/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{
-		RawURL:      "https://jsonplaceholder.typicode.com/todos",
-		Method:      "GET",
-		QueryParams: todoValues,
+	item2 := TodoQuery{
+		Id:     2,
+		UserId: 456,
 	}
+	queryValues2, _ := StructToUrlValues(item2)

-	httpClient := NewHttpClient()
-	resp, err := httpClient.SendRequest(request)
-	if err != nil || resp.StatusCode != 200 {
-		log.Fatal(err)
-	}
-
-	body, _ := io.ReadAll(resp.Body)
-	t.Log("response: ", string(body))
+	assert.Equal("2", queryValues2.Get("id"))
+	assert.Equal("456", queryValues2.Get("userId"))
+	assert.Equal("", queryValues2.Get("name"))
 }
--- a/netutil/net_example_test.go
+++ b/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"))
-	fmt.Println(todoValues.Get("name"))
+	item2 := TodoQuery{
+		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() {
--- a/pointer/pointer.go
+++ b/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())
+}
--- a/pointer/pointer_test.go
+++ b/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))
+}
--- a/slice/slice.go
+++ 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 {
--- a/slice/slice_example_test.go
+++ b/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}

--- a/slice/slice_test.go
+++ b/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{
 		{},
--- a/stream/stream.go
+++ b/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)
--- a/structs/field.go
+++ b/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
+}
--- a/structs/field_test.go
+++ b/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)
+	})
+}
--- a/structs/struct.go
+++ b/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()
+}
--- a/structs/struct_internal.go
+++ b/structs/struct_internal.go
@@ -0,0 +1,7 @@
+package structs
+
+import "fmt"
+
+func errInvalidStruct(v any) error {
+	return fmt.Errorf("invalid struct %v", v)
+}
--- a/structs/struct_test.go
+++ b/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())
+}
--- a/structs/tag.go
+++ b/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)
+}
--- a/strutil/string.go
+++ b/strutil/string.go
@@ -69,7 +69,7 @@ func LowerFirst(s string) string {

 // PadStart pads string on the left and right side if it's shorter than size.
 // Padding characters are truncated if they exceed size.
-// Play: todo
+// Play: https://go.dev/play/p/NzImQq-VF8q
 func Pad(source string, size int, padStr string) string {
 	return padAtPosition(source, size, padStr, 0)
 }
@@ -289,7 +289,7 @@ func Substring(s string, offset int, length uint) string {
 }

 // SplitWords splits a string into words, word only contains alphabetic characters.
-// Play: todo
+// Play: https://go.dev/play/p/KLiX4WiysMM
 func SplitWords(s string) []string {
 	var word string
 	var words []string
@@ -331,7 +331,7 @@ func SplitWords(s string) []string {
 }

 // WordCount return the number of meaningful word, word only contains alphabetic characters.
-// Play: todo
+// Play: https://go.dev/play/p/bj7_odx3vRf
 func WordCount(s string) int {
 	var r rune
 	var size, count int
Author	SHA1	Message	Date
dudaodong	0aa41f337d	fix: test failed	2023-03-20 16:39:56 +08:00
dudaodong	48814a720a	fix: test failed in promise test	2023-03-20 16:26:21 +08:00
dudaodong	04b79b3dfe	release v2.1.17	2023-03-20 16:17:52 +08:00
dudaodong	302007ebdf	doc: update readme file for new feature	2023-03-20 16:12:58 +08:00
dudaodong	965e5fbcda	feat: add Pop for set	2023-03-20 11:10:35 +08:00
dudaodong	70d0adde42	feat: add EachWithBreak for set	2023-03-20 10:49:14 +08:00
dudaodong	0b80074bb7	refactor: remove unused code	2023-03-20 10:35:37 +08:00
dudaodong	90945a0399	Merge branch 'main' into v2	2023-03-18 19:35:48 +08:00
zm	47dccd63af	add the struct package english docs (#82 )	2023-03-18 19:33:07 +08:00
dudaodong	4ae7e59829	feat: add example for promise	2023-03-17 16:03:35 +08:00
dudaodong	8f0c60cade	test: add unit test for promise Race and Any function	2023-03-17 13:59:18 +08:00
dudaodong	3f6aef1432	fix: fix bug of IsNotNil function	2023-03-16 19:15:36 +08:00
dudaodong	a714e04470	test: add unit test for promise.All function	2023-03-16 19:11:30 +08:00
dudaodong	7456621153	fix: fix bug of IsNil function	2023-03-16 17:01:28 +08:00
dudaodong	73ac9825e9	test: add unit test for Promise	2023-03-16 16:55:32 +08:00
dudaodong	930bb9c839	feat: complete promise Any function	2023-03-16 15:59:06 +08:00
dudaodong	3d8f1be212	feat: add error_join.go to support join error under go1.19, for internal use.	2023-03-16 15:56:54 +08:00
dudaodong	13a4ed59fa	doc: update comment for concurrency package	2023-03-16 15:35:26 +08:00
dudaodong	c799d10ce9	feat: add promise All, Race, Any methods	2023-03-16 15:34:28 +08:00
dudaodong	5ab322ade2	feat: add async package, promise implemention	2023-03-16 14:49:07 +08:00
dudaodong	d0ffc61842	doc: fix doc error	2023-03-16 10:36:06 +08:00
zm	5e66bc6227	[structs] change package structutil to structs (#81 ) * refactor package structutil to structs * add structs package zh-CN docs	2023-03-15 19:14:19 +08:00
dudaodong	7261b281ad	refactor: add function comment for tag.go	2023-03-15 17:43:47 +08:00
dudaodong	f79693804b	refactor: make package variable defaultTagName unexported	2023-03-15 15:08:56 +08:00
dudaodong	534c7a0abc	refactor: make errInvalidStruct exported, change error.go to struct_internal.go	2023-03-15 14:58:34 +08:00
dudaodong	4eaff47d38	Merge branch 'main' into v2	2023-03-15 14:43:48 +08:00
dudaodong	3e019522c7	doc: add doc for ForEachWithBreak	2023-03-15 14:42:22 +08:00
dudaodong	0734f220b3	feat: add ForEachWithBreak support break for each loop	2023-03-15 14:38:33 +08:00
zm	2d2c277090	[StructUtil] add support that the Struct can nest any type to transform (#80 ) * add support json tag attribute for StructToMap function * add the structutil to provide more rich functions and fixed #77 * add support that the nested struct to map for structutil * recover code * add structutil unit test * [StructUtil] add unit test	2023-03-15 14:26:34 +08:00
dudaodong	ef1e548dfc	merge main	2023-03-13 19:44:44 +08:00
zm	924589d2da	Add StructUtil for provide more rich functions (#79 ) * add support json tag attribute for StructToMap function * add the structutil to provide more rich functions and fixed #77	2023-03-13 19:28:37 +08:00
dudaodong	77f32f4cc6	Merge branch 'main' into v2	2023-03-11 20:14:32 +08:00
zm	1755dd249b	add support json tag attribute for StructToMap function (#78 )	2023-03-11 20:08:41 +08:00
dudaodong	7a25688ec1	doc: add doc for Range and RangeWithStep	2023-03-09 17:13:51 +08:00
dudaodong	51a6912eb3	feat: add RangeWithStep function	2023-03-06 18:05:58 +08:00
dudaodong	28d0428b50	feat: add Range function	2023-03-06 17:49:56 +08:00
dudaodong	6a9eb645bb	fix: fix StructToUrlValues failed when tag contain omitempty	2023-03-06 17:07:57 +08:00
dudaodong	3857b342f6	fix: fix ExampleContext failed	2023-03-01 11:45:02 +08:00
dudaodong	71aa91a58d	doc: add go playground demo	2023-03-01 11:39:27 +08:00
dudaodong	081908bce3	fix: fix goline error	2023-03-01 11:10:12 +08:00
dudaodong	66efe61834	release v2.1.16	2023-03-01 10:08:53 +08:00
dudaodong	94f7f3e0e5	doc: add new function docs	2023-02-28 15:03:02 +08:00
dudaodong	9d2c9806d1	feat: add ContainBy function	2023-02-24 14:19:10 +08:00
dudaodong	e523d4af6e	doc: add doc for FilterMap and FlatMap	2023-02-24 11:23:02 +08:00
dudaodong	f3801bcd8f	feat: add FlatMap	2023-02-24 11:14:59 +08:00
dudaodong	5767aad303	feat: add FilterMap	2023-02-24 10:55:27 +08:00