release v2.3.8

Merge branch 'rc' of github.com:duke-git/lancet into rc
doc: add enum and update overview index
2026-02-09 15:12:26 +08:00 · 2025-11-01 19:39:46 +08:00 · 2025-10-31 14:59:25 +08:00 · 2025-10-31 14:57:54 +08:00 · 2025-10-31 14:48:32 +08:00 · 2025-10-31 14:48:22 +08:00
32 changed files with 3306 additions and 411 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.3.7-green.svg)](https://github.com/duke-git/lancet/releases)
+[![Release](https://img.shields.io/badge/release-2.3.8-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)
@@ -1125,6 +1125,9 @@ import "github.com/duke-git/lancet/v2/maputil"
 -   **<big>FindValuesBy</big>** : returns a slice of values from the map that satisfy the given predicate function.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/maputil.md#FindValuesBy)]
    [[play](https://go.dev/play/p/bvNwNBZDm6v)]
+-   **<big>ToMarkdownTable</big>** : Convert a map slice data to a Markdown table string. It supports custom header display names and column display order.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/maputil.md#ToMarkdownTable)]
+    [[play](https://go.dev/play/p/todo)]

 <h3 id="mathutil"> 13. Mathutil package implements some functions for math calculation. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a></h3>

@@ -1461,6 +1464,9 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>ContainSubSlice</big>** : check if the slice contain a given subslice or not.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#ContainSubSlice)]
    [[play](https://go.dev/play/p/bcuQ3UT6Sev)]
+-   **<big>ContainAny</big>** : check if the slice contains any element from the targets slice.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#ContainAny)]
+    [[play](https://go.dev/play/p/4xoxhc9XSSw)]
 -   **<big>Chunk</big>** : creates a slice of elements split into groups the length of size.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#Chunk)]
    [[play](https://go.dev/play/p/b4Pou5j2L_C)]
@@ -1819,30 +1825,49 @@ import "github.com/duke-git/lancet/v2/structs"

 -   **<big>New</big>** : creates a `Struct` instance.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#New)]
+    [[play](https://go.dev/play/p/O29l8kk-Z17)]
 -   **<big>ToMap</big>** : converts a valid struct to a map.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#ToMap)]
+    [[play](https://go.dev/play/p/qQbLySBgerZ)]
 -   **<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/en/api/packages/struct.md#Fields)]
+    [[play](https://go.dev/play/p/w3Kk_CyVY7D)]
+-   **<big>Field</big>** : get an abstract field of a struct by given field name
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Field)]
+    [[play](https://go.dev/play/p/KocZMSYarza)]
 -   **<big>IsStruct</big>** : check if the struct is valid.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsStruct)]
+    [[play](https://go.dev/play/p/bU2FSdkbK1C)]
 -   **<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/en/api/packages/struct.md#Tag)]
+    [[play](https://go.dev/play/p/DVrx5HvvUJr)]
 -   **<big>Name</big>** : get the field name.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#Name)]
+    [[play](https://go.dev/play/p/zfIGlqsatee)]
 -   **<big>Value</big>** : get the `Field` underlying value.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#Value)]
+    [[play](https://go.dev/play/p/qufYEU2o4Oi)]
 -   **<big>Kind</big>** : get the field's kind.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#Kind)]
+    [[play](https://go.dev/play/p/wg4NlcUNG5o)]
 -   **<big>IsEmbedded</big>** : check if the field is an embedded field.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsEmbedded)]
+    [[play](https://go.dev/play/p/wV2PrbYm3Ec)]
 -   **<big>IsExported</big>** : check if the field is exported.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsExported)]
+    [[play](https://go.dev/play/p/csK4AXYaNbJ)]
 -   **<big>IsZero</big>** : check if the field is zero value.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsZero)]
+    [[play](https://go.dev/play/p/RzqpGISf87r)]
 -   **<big>IsSlice</big>** : check if the field is a slice.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsSlice)]
+    [[play](https://go.dev/play/p/MKz4CgBIUrU)]
 -   **<big>IsTargetType</big>** : check if the field is target type.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsTargetType)]
+    [[play](https://go.dev/play/p/Ig75P-agN39)]
+-   **<big>TypeName</big>** : Return struct type name.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#TypeName)]
+    [[play](https://go.dev/play/p/todo)]

 <h3 id="strutil"> 21. Strutil package contains some functions to manipulate string. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a></h3>

@@ -2301,6 +2326,12 @@ import "github.com/duke-git/lancet/v2/validator"
 -   **<big>IsChinaUnionPay</big>** : check if a give string is a valid china union pay number or not.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/validator.md#IsChinaUnionPay)]
    [[play](https://go.dev/play/p/yafpdxLiymu)]
+-   **<big>IsPassport</big>** : Passport validation(using regex).
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/validator.md#IsPassport)]
+    [[play](https://go.dev/play/p/todo)]
+-   **<big>IsChineseHMPassport</big>** : Mainland travel permit for Hong Kong, Macao validation (using regex).
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/validator.md#IsChineseHMPassport)]
+    [[play](https://go.dev/play/p/todo)]

 <h3 id="xerror"> 25. Xerror package implements helpers for errors. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a></h3>

--- 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.3.7-green.svg)](https://github.com/duke-git/lancet/releases)
+[![Release](https://img.shields.io/badge/release-2.3.8-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)
@@ -1135,6 +1135,9 @@ import "github.com/duke-git/lancet/v2/maputil"
 -   **<big>FindValuesBy</big>** : 返回一个切片，包含满足给定谓词判断函数的 map 中的值。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/maputil.md#FindValuesBy)]
    [[play](https://go.dev/play/p/bvNwNBZDm6v)]
+-   **<big>ToMarkdownTable</big>** : 将一个 map 切片数据转换为 Markdown 表格字符串。支持自定义表头显示名称和列的显示顺序。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/maputil.md#ToMarkdownTable)]
+    [[play](https://go.dev/play/p/todo)]

 <h3 id="mathutil"> 14. mathutil 包实现了一些数学计算的函数。&nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">回到目录</a></h3>

@@ -1468,6 +1471,9 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>ContainSubSlice</big>** : 判断 slice 是否包含 subslice。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/slice.md#ContainSubSlice)]
    [[play](https://go.dev/play/p/bcuQ3UT6Sev)]
+-   **<big>ContainAny</big>** : 判断 slice 是否包含 targets 切片中的任意一个元素。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/slice.md#ContainAny)]
+    [[play](https://go.dev/play/p/4xoxhc9XSSw)]
 -   **<big>Chunk</big>** : 按照 size 参数均分 slice。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/slice.md#Chunk)]
    [[play](https://go.dev/play/p/b4Pou5j2L_C)]
@@ -1825,32 +1831,49 @@ import "github.com/duke-git/lancet/v2/structs"

 -   **<big>New</big>** : `Struct`结构体的构造函数。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#New)]
+    [[play](https://go.dev/play/p/O29l8kk-Z17)]
 -   **<big>ToMap</big>** : 将一个合法的 struct 对象转换为 map[string]any。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#ToMap)]
+    [[play](https://go.dev/play/p/qQbLySBgerZ)]
 -   **<big>Fields</big>** : 获取一个 struct 对象的属性列表。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Fields)]
+    [[play](https://go.dev/play/p/w3Kk_CyVY7D)]
 -   **<big>Field</big>** : 根据属性名获取一个 struct 对象的属性。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Fields)]
+    [[play](https://go.dev/play/p/KocZMSYarza)]
 -   **<big>IsStruct</big>** : 判断是否为一个合法的 struct 对象。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsStruct)]
+    [[play](https://go.dev/play/p/bU2FSdkbK1C)]
 -   **<big>Tag</big>** : 获取`Field`的`Tag`，默认的 tag key 是 json。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Tag)]
+    [[play](https://go.dev/play/p/DVrx5HvvUJr)]
 -   **<big>Name</big>** : 获取属性名。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Name)]
+    [[play](https://go.dev/play/p/zfIGlqsatee)]
 -   **<big>Value</big>** : 获取`Field`属性的值。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Value)]
+    [[play](https://go.dev/play/p/qufYEU2o4Oi)]
 -   **<big>Kind</big>** : 获取属性 Kind。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Kind)]
+    [[play](https://go.dev/play/p/wg4NlcUNG5o)]
 -   **<big>IsEmbedded</big>** : 判断属性是否为嵌入。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsEmbedded)]
+    [[play](https://go.dev/play/p/wV2PrbYm3Ec)]
 -   **<big>IsExported</big>** : 判断属性是否导出。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsExported)]
+    [[play](https://go.dev/play/p/csK4AXYaNbJ)]
 -   **<big>IsZero</big>** : 判断属性是否为零值。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsZero)]
+    [[play](https://go.dev/play/p/RzqpGISf87r)]
 -   **<big>IsSlice</big>** : 判断属性是否是切片。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsSlice)]
+    [[play](https://go.dev/play/p/MKz4CgBIUrU)]
 -   **<big>IsTargetType</big>** : 判断属性是否是目标类型。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsTargetType)]
+    [[play](https://go.dev/play/p/Ig75P-agN39)]
+-   **<big>TypeName</big>** : 获取结构体类型名。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#TypeName)]
+    [[play](https://go.dev/play/p/todo)]

 <h3 id="strutil"> 22. strutil 包含字符串处理的相关函数。&nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">回到目录</a></h3>

@@ -2310,7 +2333,12 @@ import "github.com/duke-git/lancet/v2/validator"
 -   **<big>IsChinaUnionPay</big>** : 检查字符串是否是有效的中国银联卡号。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/validator.md#IsChinaUnionPay)]
    [[play](https://go.dev/play/p/yafpdxLiymu)]
-
+-   **<big>IsPassport</big>** : 判断护照(正则判断)。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/validator.md#IsPassport)]
+    [[play](https://go.dev/play/p/todo)]
+-   **<big>IsChineseHMPassport</big>** : 判断港澳台通行证(正则判断)。
+[[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/validator.md#IsChineseHMPassport)]
+[[play](https://go.dev/play/p/todo)]
 <h3 id="xerror"> 26. xerror 包实现一些错误处理函数。&nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">回到目录</a></h3>

 ```go
--- a/cryptor/rsa_private_example.pem
+++ b/cryptor/rsa_private_example.pem
@@ -1,51 +1,51 @@
 -----BEGIN rsa private key-----
-MIIJKAIBAAKCAgEAxBXtNRZ18uz+ujnKC/CB6bYjOHn0++xX1tbqRoRfP4VP01R/
-k9d28sI9cqQa9Oqo3TPehKAyR4m3p9ZJ+pOgNLpe7QEPWSGqIvPILRqS/4NnnjBu
-KvRHRTqiQwiuzTo/BBTxJCtF028Q7yRKmloEdtrdFryqsZmTrtMIvaNneTa/Bnx3
-3s4vfAm76wNKF5li0AN7NsmKfWjOG7/f29qp9rTJEBnCIKImrwTFY9BWrx83LPDA
-Uq8tpn8zevEe0c/42yZNlBprea4FIdZs8A/3gDZE7kltYjdybox0XWjR9znWPLmH
-3De+1xJ0woJ53f3jYDJ3REwmm8+sX26FIT3WPN/ksVgHsoaj2IZ3MaEkxf4E4GEp
-9sMSP8b+ans/B5gmcZi2pO8nx/ASVlxCthUSaK92CsoKHzqTotaZ+/dt689qT4zu
-qUWZpnlLIUKd0t1G485S8km15GgPcMY5vXe13i8dmsxVRIjgYclSClKCnDBTTAV5
-GUSPnanPU4N0dlKpO0UxzILixaw227yw7zDy+rQ8ixchQ+ROQ6I4bdced7FuVXfE
-Aa2gVuzm3uZ1J/xDnV6xwLYye2SitlzAL0wA/mFAF6koSa6+MYV+tzdPta2Xkw9x
-mO3a5PKwhCvOUbEMBJfLI2GPAfTuPh1LH4MZqFUgzYHUiBCI21N3kMVPGAUCAwEA
-AQKCAgBV6jGL4DJ/5P1bRTTU9GVHrKlT9oOz2gNGu9XcXeWJ5HRsaQqZEYApr5fS
-4jp5c1PX0AFAZRyCocHZhRfW9dXtJHexKpS5/fkY5W2g7ZLY54+ADUJICc4sdBti
-eax1eX7g3/gkW911XaWy0ljptmVcWlsiujmkJWFC6W5cAPu2bZlXUzQGaJr/oxg2
-SbOuEWPtNolHIRlQB5q/J9wC7ZUo5l9ucYrQV5vRdaqzKDbC9k9rnnT2BZFf8T3y
-MTHKxnAIPYkiSk0q/Gd9QwFqUeSkxaKAMaX+scKu01WtE99jjnDjHHt9ruMsQwbr
-rtWMwdBddt8xCpikDmM9USR9wyVZtC6ARo8DBZGdua+Le76IN6hvxoux3qEsZyzf
-WJj1kE9KOd+FAGfaXr7R2LKZpdbDF1bRkZWarxiYipZU+jSO+T4Ml9Rgb+qeU/H5
-C6G0zP16N6WGumhaPE7tqGjIFq1MYdq35elQkHFeVQ+jp/deLlzNl2Icfpnk4bLf
-2LBU/7LInSDtA5s+AOin3wgNcVrsY9tmMlt07aG9CO7aVrLMIQsdiR+w5b8/Pu5X
-nrmAWHMaHLQ6b2vuVhMxcgZGjRS0meNH93js0vxsyt6VNrEmxk3/qD8Y17YEVqLD
-ZMUqbKi2l4QO4mAPyioylE+lUtW7RRiDkUvPW4d5q8ZKVNbS5QKCAQEA7Pyg1EFX
-ylFc1sz6w4ZTyRwLyYb+PMuB251Q5gNotnYkf0ruHMrQR4zHqB8eOci9dqV4NADH
-HfTCKNlMQ4L6fAdZByTMXZhXLq9Y2xMUkLk2YRxIb+ES/rGFJ4bY7tOUPoN1StAR
-SpwHkA0icJgi8AqWDuil5CqVsBVpYdt6DA68law2CPrna8c5xG0YaO/tdH4j4bek
-5ckOxU6YOpidpHt3h6pfSJ7HcZeH2j+zmfqDCcjdRZWMv+ntB23ooHEDi7/rGjQK
-E3t5svnP+eC4arTiuYr+CrUCbNNEqGyRuy8O+UrAWFjwo7+BsiUZvg9HOERBu/Yy
-YK/omoLgeurGAwKCAQEA09E/FlRJxhQi81QwpjOv2oV3dtwxmwxh9wdtGvMDiCVM
-q3+kB3agmtynVzY/53roejVi8tVSVBjwW+KxWzKjGwP7XVl1KpeeKwmAlk3tzUud
-LFAqoa7DH6C2n/zScRFntxtrTCSiqJ32DHYseHwKK4wjCfmtirh21vNAlfmcdr9d
-h+FJzPv1JQQU6EfdS2/Bz36NUHty7POSHCZiUKvOKLw2K2SjQ6u+KPtReZ+9s/Zv
-pJmD4YeZrDAjdsqikuRLMLjZat3HjiBVh5VjAdviYwSVsdq4Y7BIs//f3b3HnHgb
-w+dmADmkI7lcWkv6UXsw/XI+f2Y9uo5cnXGgFOPvVwKCAQAECRlEBAjWrSQDlGIA
-ylzK4+tfdykFKAICF1+1SwGRedmNQV1kqB972G3d8wm0ujJfvtmZKRo67FwSDgE6
-dRSG4Ckn8fx464swhFPjByQmgsDmTnD9VrvYEnXOAoHXL0sq9Vod+AUTXCzUyyR2
-/mA57jQ39MY+aGs8IGE3BWHCqs2TTudsp7khILdfHOx5fPxyK2O5CEOKli3mNjxp
-YwfsMR4L9V7CAdIroQTzNnp8eMOaew0pji5jZjxfEAQSF1qUGqSKQbCaPFQKNC7S
-dn0tc/8YYcGJtSNhbweQRqkEovyCSj+UQY93el9fBTq2/dOcpazo4nxhIR2449mm
-vjC5AoIBAF6glkyFb0fcaxjFvc4iPSekhJBHIqofyAwx9x4Y/rTt5Oig50imSG2m
-seOWSspA8GbYPtI5VsRXN9n01kLlxlQlXUCA3IUgovqbDiUXv2r9osPPNJxylJ0m
-kS+8JM96dRkqWK71lu05VFiQ2qEg2PJHcsfcERlt+zlgBrR5hNrP9xrjHLNExGm6
-/xQeNtCiprTp1nvkCp2s2tNUmotrlXhBTPnpxb5PlW59iBKLuJYTPCEOrAovKAny
-n4VMVYDGGIk1q3vAhIwMCem+ZTLJZsPRooaILePrNy+i2gIX7HsMdWr5j2n+VkPX
-ZVi5pKSOIn63cRA9Psp/GwUDY/6xLZUCggEBAMOy/fy6eeGy9kGizn6j+68Rg29+
-qCE2CVXLeFU9VpRnO6oSL5dWGEoEtjs6rgPUs7yWPb0c7u9LH93ba20xMFl1MStK
-LQMdYJcVtShMplJzW0NeoWK3pnT+1GfAmzGM69ZF8NAbRYuh68fwe/xanr8SrbBS
-EszhoAz5Ei7jEiWFWBCsm6MAs0wa4n2emyD2XJSTjqRULfaZwN5yThjbZ09QZ4Bq
-HfhMenWPMa+QZpiEEHebXczlULFQcOO0QXx+VfuGIiYk+UDPhUuN1E/KqhOuqR34
-f1tU3jwqz9fQ6VHH2hP/+jmEre/9E1D9c3EImqgT0wNR/gMTNtQ0t0Js2Xk=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 -----END rsa private key-----
--- a/cryptor/rsa_public_example.pem
+++ b/cryptor/rsa_public_example.pem
@@ -1,14 +1,14 @@
 -----BEGIN rsa public key-----
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBXtNRZ18uz+ujnKC/CB
-6bYjOHn0++xX1tbqRoRfP4VP01R/k9d28sI9cqQa9Oqo3TPehKAyR4m3p9ZJ+pOg
-NLpe7QEPWSGqIvPILRqS/4NnnjBuKvRHRTqiQwiuzTo/BBTxJCtF028Q7yRKmloE
-dtrdFryqsZmTrtMIvaNneTa/Bnx33s4vfAm76wNKF5li0AN7NsmKfWjOG7/f29qp
-9rTJEBnCIKImrwTFY9BWrx83LPDAUq8tpn8zevEe0c/42yZNlBprea4FIdZs8A/3
-gDZE7kltYjdybox0XWjR9znWPLmH3De+1xJ0woJ53f3jYDJ3REwmm8+sX26FIT3W
-PN/ksVgHsoaj2IZ3MaEkxf4E4GEp9sMSP8b+ans/B5gmcZi2pO8nx/ASVlxCthUS
-aK92CsoKHzqTotaZ+/dt689qT4zuqUWZpnlLIUKd0t1G485S8km15GgPcMY5vXe1
-3i8dmsxVRIjgYclSClKCnDBTTAV5GUSPnanPU4N0dlKpO0UxzILixaw227yw7zDy
-+rQ8ixchQ+ROQ6I4bdced7FuVXfEAa2gVuzm3uZ1J/xDnV6xwLYye2SitlzAL0wA
-/mFAF6koSa6+MYV+tzdPta2Xkw9xmO3a5PKwhCvOUbEMBJfLI2GPAfTuPh1LH4MZ
-qFUgzYHUiBCI21N3kMVPGAUCAwEAAQ==
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAuzBz+aC+e7Lvny2zYlcy
+AfG6AAtPkxZqJ9JkYkM+0CP87pe0xOXQh4dz9iJekOwAq7FKpasUEUzkTm6Z0PUo
+j/TWY/xpoPNXXzz/5dz3u6r/A5TumJ6BmX/7K/x8FsokIeP+lWaN1l+7uBKK8rgf
+m4AZOXd/plzBkTrnu6lKG/rH9cnr2leKWDqk2jcG6r15r/07MdStpWgt0OBYoHzv
+jLJWmJ08VrnF9PFtWhL939xSAIicFzJ0T9fAdmSSYmg22mKgN1zeWtZndJ/Ejv+5
+YlWmuFJ8YKvwR0+4XIRLX9qsMy7qPTh7zsZhgtKzyb7qvVqDh2pmwekGJcwxGcoC
+LHLqNKf/dD+4vXxgS+f1ObfOcJpDqBajD/U6BXtrZ/p4cvoYnZA383YR/CRG/nJ8
+jIvt2FutT4hsNSd0L6c2mfo5mTnoDOEL3mkreZ4Az+GE57jMw1Ia9jwkM1QQoy0a
+kTiW8BedNqcRnVVGT9/OS/ggyKFwxJ/Xh1DfxZXAuyCBRUJUyVl9YCr2y30zngu
+CdaTTViA9UbrjtcE2bZtnqOMAU2s08F0IiaGLKKMhrxUoXLgngXSX7gomC4aEfcg
+5hf7ft6FA+bXB9DHwGdv/UyrGr88nve5um1OT5kmyOujKpka4QZ5/rU+RznBE0UW
+DcHAyc+Zv+te0DqPUNcAW5ECAwEAAQ==
 -----END rsa public key-----
--- a/docs/.vitepress/en.ts
+++ b/docs/.vitepress/en.ts
@@ -114,6 +114,7 @@ export const enConfig: LocaleSpecificConfig<DefaultTheme.Config> = {
                            ],
                        },
                        { text: 'datetime', link: '/en/api/packages/datetime' },
+                        { text: 'enum', link: '/en/api/packages/enum' },
                        { text: 'eventbus', link: '/en/api/packages/eventbus' },
                        { text: 'fileutil', link: '/en/api/packages/fileutil' },
                        { text: 'formatter', link: '/en/api/packages/formatter' },
@@ -128,9 +129,9 @@ export const enConfig: LocaleSpecificConfig<DefaultTheme.Config> = {
                        { text: 'stream', link: '/en/api/packages/stream' },
                        { text: 'struct', link: '/en/api/packages/struct' },
                        { text: 'strutil', link: '/en/api/packages/strutil' },
-                        { text: 'system', link: '/en/api/packages/system' },
                        { text: 'tuple', link: '/en/api/packages/tuple' },
                        { text: 'validator', link: '/en/api/packages/validator' },
+                        { text: 'system', link: '/en/api/packages/system' },
                        { text: 'xerror', link: '/en/api/packages/xerror' },
                    ],
                },
--- a/docs/.vitepress/zh.ts
+++ b/docs/.vitepress/zh.ts
@@ -128,7 +128,7 @@ export const zhConfig: LocaleSpecificConfig<DefaultTheme.Config> = {
                        },
                        { text: '日期&时间', link: '/api/packages/datetime' },
                        { text: '事件总线', link: '/api/packages/eventbus' },
-                        { text: '文件', link: '/api/packages/fileutil' },
+                        { text: '文件处理', link: '/api/packages/fileutil' },
                        { text: '格式化工具', link: '/api/packages/formatter' },
                        { text: '函数', link: '/api/packages/function' },
                        { text: '数学工具', link: '/api/packages/mathutil' },
@@ -141,9 +141,10 @@ export const zhConfig: LocaleSpecificConfig<DefaultTheme.Config> = {
                        { text: '流', link: '/api/packages/stream' },
                        { text: '结构体', link: '/api/packages/struct' },
                        { text: '字符串', link: '/api/packages/strutil' },
-                        { text: '系统', link: '/api/packages/system' },
+                        { text: '枚举', link: '/api/packages/enum' },
                        { text: '元组', link: '/api/packages/tuple' },
                        { text: '验证器', link: '/api/packages/validator' },
+                        { text: '系统工具函数', link: '/api/packages/system' },
                        { text: '错误处理', link: '/api/packages/xerror' },
                    ],
                },
--- a/docs/api/overview.md
+++ b/docs/api/overview.md
@@ -46,6 +46,7 @@ outline: deep
        <div class="package-cell">cryptor</div>
        <div class="package-cell">datastructure</div>
        <div class="package-cell">datetime</div>
+        <div class="package-cell">enum</div>
        <div class="package-cell">eventbus</div>
        <div class="package-cell">fileutil</div>
        <div class="package-cell">formatter</div>
--- a/docs/api/packages/enum.md
+++ b/docs/api/packages/enum.md
@@ -0,0 +1,850 @@
+# Enum
+
+Enum实现一个简单枚举工具包。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+- [https://github.com/duke-git/lancet/blob/main/enum/enum.go](https://github.com/duke-git/lancet/blob/main/enum/enum.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/enum"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [NewItem](#NewItem)
+-   [NewItemsFromPairs](#NewItemsFromPairs)
+-   [Value](#Value)
+-   [Name](#Name)
+-   [Valid](#Valid)
+-   [MarshalJSON](#MarshalJSON)
+-   [NewRegistry](#NewRegistry)
+-   [Add](#Add)
+-   [Remove](#Remove)
+-   [Update](#Update)
+-   [GetByValue](#GetByValue)
+-   [GetByName](#GetByName)
+-   [Items](#Items)
+-   [Contains](#Contains)
+-   [Size](#Size)
+-   [Range](#Range)
+-   [SortedItems](#SortedItems)
+-   [Filter](#Filter)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="NewItem">NewItem</span>
+
+<p>创建枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func NewItem[T comparable](value T, name string) *Item[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    fmt.Println(item1.Name(), item1.Value())
+    fmt.Println(item2.Name(), item2.Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="NewItemsFromPairs">NewItemsFromPairs</span>
+
+<p>从Pair结构体的切片创建枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func NewItemsFromPairs[T comparable](pairs ...Pair[T]) []*Item[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    items := enum.NewItemsFromPairs(
+        enum.Pair[Status]{Value: Active, Name: "Active"},
+        enum.Pair[Status]{Value: Inactive, Name: "Inactive"},
+    )
+
+    fmt.Println(items[0].Name(), items[0].Value())
+    fmt.Println(items[1].Name(), items[1].Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Value">Value</span>
+
+<p>返回枚举项的值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (it *Item[T]) Value() T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    items := enum.NewItemsFromPairs(
+        enum.Pair[Status]{Value: Active, Name: "Active"},
+        enum.Pair[Status]{Value: Inactive, Name: "Inactive"},
+    )
+
+    fmt.Println(items[0].Name(), items[0].Value())
+    fmt.Println(items[1].Name(), items[1].Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Name">Name</span>
+
+<p>返回枚举项的名称。</p>
+
+<b>函数签名:</b>
+
+```go
+func (it *Item[T]) Name() string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    items := enum.NewItemsFromPairs(
+        enum.Pair[Status]{Value: Active, Name: "Active"},
+        enum.Pair[Status]{Value: Inactive, Name: "Inactive"},
+    )
+
+    fmt.Println(items[0].Name(), items[0].Value())
+    fmt.Println(items[1].Name(), items[1].Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Valid">Valid</span>
+
+<p>检查枚举项是否有效。如果提供了自定义检查函数，将使用该函数验证值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (it *Item[T]) Valid(checker ...func(T) bool) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    item := enum.NewItem(Active, "Active")
+    fmt.Println(item.Valid())
+
+    invalidItem := enum.NewItem(Unknown, "")
+    fmt.Println(invalidItem.Valid())
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="MarshalJSON">MarshalJSON</span>
+
+<p>枚举项实现json.Marshaler 接口。</p>
+
+<b>函数签名:</b>
+
+```go
+func (it *Item[T]) MarshalJSON() ([]byte, error)
+func (it *Item[T]) UnmarshalJSON(data []byte) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    item := enum.NewItem(Active, "Active")
+    data, _ := item.MarshalJSON()
+    fmt.Println(string(data))
+
+    var unmarshaledItem Item[Status]
+    _ = unmarshaledItem.UnmarshalJSON(data)
+    fmt.Println(unmarshaledItem.Name(), unmarshaledItem.Value())
+
+    // Output:
+    // {"name":"Active","value":1}
+    // Active 1
+}
+```
+
+### <span id="NewRegistry">NewRegistry</span>
+
+<p>Registry 定义了一个通用的枚举注册表结构体。</p>
+
+<b>函数签名:</b>
+
+```go
+func NewRegistry[T comparable](items ...*Item[T]) *Registry[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    registry.Add(item1, item2)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("Found by value:", item.Name())
+    }
+
+    if item, found := registry.GetByName("Inactive"); found {
+        fmt.Println("Found by name:", item.Value())
+    }
+
+    // Output:
+    // Found by value: Active
+    // Found by name: 2
+}
+```
+
+### <span id="Add">Add</span>
+
+<p>向枚举注册表添加枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Add(items ...*Item[T])
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    registry.Add(item1, item2)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("Found by value:", item.Name())
+    }
+
+    if item, found := registry.GetByName("Inactive"); found {
+        fmt.Println("Found by name:", item.Value())
+    }
+
+    // Output:
+    // Found by value: Active
+    // Found by name: 2
+}
+```
+
+### <span id="Remove">Remove</span>
+
+<p>在枚举注册表中删除枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Remove(value T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+
+    registry.Add(item1)
+    fmt.Println("Size before removal:", registry.Size())
+
+    removed := registry.Remove(Active)
+    fmt.Println("Removed:", removed)
+    fmt.Println("Size after removal:", registry.Size())
+
+    // Output:
+    // Size before removal: 1
+    // Removed: true
+    // Size after removal: 0
+}
+```
+
+### <span id="Update">Update</span>
+
+<p>在枚举注册表中更新枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Update(value T, newName string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+
+    registry.Add(item1)
+    updated := registry.Update(Active, "Activated")
+    fmt.Println("Updated:", updated)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("New name:", item.Name())
+    }
+
+    // Output:
+    // Updated: true
+    // New name: Activated
+}
+```
+
+### <span id="GetByValue">GetByValue</span>
+
+<p>在枚举注册表中通过值获取枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) GetByValue(value T) (*Item[T], bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+
+    registry.Add(item1, item2)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("Found name by value:", item.Name())
+    }
+
+    // Output:
+    // Found name by value: Active
+}
+```
+
+### <span id="GetByName">GetByName</span>
+
+<p>在枚举注册表中通过名称获取枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) GetByName(name string) (*Item[T], bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item := enum.NewItem(Active, "Active")
+
+    registry.Add(item)
+
+    if item, found := registry.GetByName("Active"); found {
+        fmt.Println("Found value by name:", item.Value())
+    }
+
+    // Output:
+    // Found value by name: 1
+}
+```
+
+### <span id="Items">Items</span>
+
+<p>返回枚举注册表中的枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Items() []*Item[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    registry.Add(item1, item2)
+
+    for _, item := range registry.Items() {
+        fmt.Println(item.Name(), item.Value())
+    }
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Contains">Contains</span>
+
+<p>检查注册表中是否存在具有给定值的枚举项。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Contains(value T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item := enum.NewItem(Active, "Active")
+    registry.Add(item)
+
+    fmt.Println(registry.Contains(Active))
+    fmt.Println(registry.Contains(Inactive))
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="Size">Size</span>
+
+<p>返回注册表中枚举项的数目。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Size() int
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    fmt.Println("Initial size:", registry.Size())
+
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+    registry.Add(item1, item2)
+
+    fmt.Println("Size after adding items:", registry.Size())
+
+    registry.Remove(Active)
+    fmt.Println("Size after removing an item:", registry.Size())
+
+    // Output:
+    // Initial size: 0
+    // Size after adding items: 2
+    // Size after removing an item: 1
+}
+```
+
+### <span id="Range">Range</span>
+
+<p>遍历注册表中的所有枚举项，并应用给定的函数。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Range(fn func(*Item[T]) bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+    registry.Add(item1, item2)
+
+    registry.Range(func(item *Item[Status]) bool {
+        fmt.Println(item.Name(), item.Value())
+        return true // continue iteration
+    })
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="SortedItems">SortedItems</span>
+
+<p>返回按给定比较函数排序的所有枚举项的切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) SortedItems(less func(*Item[T], *Item[T]) bool) []*Item[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Inactive, "Inactive")
+    item2 := enum.NewItem(Active, "Active")
+    registry.Add(item1, item2)
+
+    for _, item := range registry.SortedItems(func(i1, i2 *Item[Status]) bool {
+        return i1.value < i2.value
+    }) {
+        fmt.Println(item.Name(), item.Value())
+    }
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Filter">Filter</span>
+
+<p>返回满足给定谓词函数的枚举项切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func (r *Registry[T]) Filter(predicate func(*Item[T]) bool) []*Item[T]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+    registry.Add(item1, item2)
+
+    activeItems := registry.Filter(func(item *Item[Status]) bool {
+        return item.Value() == Active
+    })
+
+    for _, item := range activeItems {
+        fmt.Println(item.Name(), item.Value())
+    }
+
+    // Output:
+    // Active 1
+}
+```
--- a/docs/api/packages/maputil.md
+++ b/docs/api/packages/maputil.md
@@ -79,6 +79,7 @@ import (
 -   [SortByKey](#SortByKey)
 -   [GetOrDefault](#GetOrDefault)
 -   [FindValuesBy](#FindValuesBy)
+-   [ToMarkdownTable](#ToMarkdownTable)

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

@@ -2345,3 +2346,68 @@ func main() {
    // [b d]
 }
 ```
+
+### <span id="ToMarkdownTable">ToMarkdownTable</span>
+
+<p>将一个 map 切片数据转换为 Markdown 表格字符串。支持自定义表头显示名称和列的显示顺序。</p>
+
+<b>函数签名:</b>
+
+```go
+编辑
+func ToMarkdownTable(data []map[string]interface{}, headerMap map[string]string, columnOrder []string) string
+```
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    // 基本用法：自动从数据中提取列名作为表头
+    data := []map[string]interface{}{
+        {"name": "Alice", "age": 25, "salary": 50000},
+        {"name": "Bob", "age": 30, "salary": 60000},
+    }
+
+    result := maputil.ToMarkdownTable(data, nil, nil)
+    fmt.Println(result)
+
+    // 输出:
+    // |name|age|salary|
+    // |---|---|---|
+    // |Alice|25|50000|
+    // |Bob|30|60000|
+
+    // 自定义表头显示名称
+    headerMap := map[string]string{
+        "name":   "姓名",
+        "age":    "年龄",
+        "salary": "薪资",
+    }
+    result = maputil.ToMarkdownTable(data, headerMap, nil)
+    fmt.Println(result)
+
+    // 输出:
+    // |姓名|年龄|薪资|
+    // |---|---|---|
+    // |Alice|25|50000|
+    // |Bob|30|60000|
+
+    // 自定义列顺序
+    columnOrder := []string{"salary", "name"}
+    result = maputil.ToMarkdownTable(data, nil, columnOrder)
+    fmt.Println(result)
+
+    // 输出:
+    // |salary|name|
+    // |---|---|
+    // |50000|Alice|
+    // |60000|Bob|
+}
+```
--- a/docs/api/packages/slice.md
+++ b/docs/api/packages/slice.md
@@ -27,6 +27,7 @@ import (
 -   [Contain](#Contain)
 -   [ContainBy](#ContainBy)
 -   [ContainSubSlice](#ContainSubSlice)
+-   [ContainAny](#ContainAny)
 -   [Chunk](#Chunk)
 -   [Compact](#Compact)
 -   [Concat](#Concat)
@@ -256,6 +257,43 @@ func main() {
 }
 ```

+### <span id="ContainAny">ContainAny</span>
+
+<p>判断slice是否包含targets切片中的任意一个元素</p>
+
+<b>函数签名:</b>
+
+```go
+func ContainAny[T comparable](slice []T, targets []T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4xoxhc9XSSw)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.ContainAny([]string{"a", "b", "c"}, []string{"a"})
+    result2 := slice.ContainAny([]string{"a", "b", "c"}, []string{"d", "e"})
+    result3 := slice.ContainAny([]string{"a", "b", "c"}, []string{"d", "a"})
+    result4 := slice.ContainAny([]string{"a", "b", "c"}, []string{})
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // false
+    // true
+    // false
+}
+```
+
 ### <span id="Chunk">Chunk</span>

 <p>按照size参数均分slice</p>
--- a/docs/api/packages/struct.md
+++ b/docs/api/packages/struct.md
@@ -31,6 +31,7 @@ import (
 -   [IsStruct](#IsStruct)
 -   [Tag](#Tag)
 -   [Name](#Name)
+-   [TypeName](#TypeName)
 -   [Value](#Value)
 -   [Kind](#Kind)
 -   [IsEmbedded](#IsEmbedded)
@@ -53,7 +54,7 @@ import (
 func New(value any, tagName ...string) *Struct
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/O29l8kk-Z17)</span></b>

 ```go
 package main
@@ -68,7 +69,11 @@ func main() {
    }
    p1 := &People{Name: "11"}
    s := structs.New(p1)
-    // to do something
+    
+    fmt.Println(s.ToMap())
+
+    // Output:
+    // map[name:11] <nil>
 }
 ```

@@ -88,7 +93,7 @@ func (s *Struct) ToMap() (map[string]any, error)
 func ToMap(v any) (map[string]any, error)
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qQbLySBgerZ)</span></b>

 ```go
 package main
@@ -129,7 +134,7 @@ func main() {
 func (s *Struct) Fields() []*Field
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/w3Kk_CyVY7D)</span></b>

 ```go
 package main
@@ -161,10 +166,10 @@ func main() {
 <b>函数签名:</b>

 ```go
-func (s *Struct) Field(name string) *Field
+func (s *Struct) Field(name string) (*Field, bool)
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KocZMSYarza)</span></b>

 ```go
 package main
@@ -180,12 +185,14 @@ func main() {
    }
    p1 := &People{Name: "11"}
    s := structs.New(p1)
-    f := s.Field("Name")
+    f, found := s.Field("Name")

    fmt.Println(f.Value())
+    fmt.Println(found)

    // Output:
    // 11
+    // true
 }
 ```

@@ -199,7 +206,7 @@ func main() {
 func (s *Struct) IsStruct() bool
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bU2FSdkbK1C)</span></b>

 ```go
 package main
@@ -233,7 +240,7 @@ func main() {
 func (f *Field) Tag() *Tag
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DVrx5HvvUJr)</span></b>

 ```go
 package main
@@ -270,7 +277,7 @@ func main() {
 func (f *Field) Value() any
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qufYEU2o4Oi)</span></b>

 ```go
 package main
@@ -306,7 +313,7 @@ func main() {
 func (f *Field) IsEmbedded() bool
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wV2PrbYm3Ec)</span></b>

 ```go
 package main
@@ -351,7 +358,7 @@ func main() {
 func (f *Field) IsExported() bool
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/csK4AXYaNbJ)</span></b>

 ```go
 package main
@@ -390,7 +397,7 @@ func main() {
 func (f *Field) IsZero() bool
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/RzqpGISf87r)</span></b>

 ```go
 package main
@@ -429,7 +436,7 @@ func main() {
 func (f *Field) Name() string
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zfIGlqsatee)</span></b>

 ```go
 package main
@@ -468,7 +475,7 @@ func main() {
 func (f *Field) Kind() reflect.Kind
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wg4NlcUNG5o)</span></b>

 ```go
 package main
@@ -497,6 +504,42 @@ func main() {
 }
 ```

+### <span id="TypeName">TypeName</span>
+
+<p>获取结构体类型名。</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) TypeName() string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type Parent struct {
+        Name string
+        Age  int
+    }
+    
+    p := &Parent{Age: 11}
+    s := structs.New(p1)
+
+    fmt.Println(s.TypeName())
+    
+    // Output: 
+    // Parent
+}
+```
+
 ### <span id="IsSlice">IsSlice</span>

 <p>判断属性是否是切片</p>
@@ -507,7 +550,7 @@ func main() {
 func (f *Field) IsSlice() bool
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/MKz4CgBIUrU)</span></b>

 ```go
 package main
@@ -544,7 +587,7 @@ func main() {
 func (f *Field) IsTargetType(targetType reflect.Kind) bool
 ```

-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Ig75P-agN39)</span></b>

 ```go
 package main
--- a/docs/api/packages/validator.md
+++ b/docs/api/packages/validator.md
@@ -65,6 +65,8 @@ import (
 -   [IsAmericanExpress](#IsAmericanExpress)
 -   [IsUnionPay](#IsUnionPay)
 -   [IsChinaUnionPay](#IsChinaUnionPay)
+-   [IsPassport](#IsPassport)
+-   [IsChineseHMPassport](#IsChineseHMPassport)

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

@@ -844,20 +846,20 @@ import (

 func main() {
    result1 := validator.IsAlphaNumeric("ABC")
-	result2 := validator.IsAlphaNumeric("123")
-	result3 := validator.IsAlphaNumeric("abc123")
-	result4 := validator.IsAlphaNumeric("abc123@#$")
+    result2 := validator.IsAlphaNumeric("123")
+    result3 := validator.IsAlphaNumeric("abc123")
+    result4 := validator.IsAlphaNumeric("abc123@#$")

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)

-	// Output:
-	// true
-	// true
-	// true
-	// false
+    // Output:
+    // true
+    // true
+    // true
+    // false
 }
 ```

@@ -1567,3 +1569,80 @@ func main() {
    // false
 }
 ```
+
+### <span id="IsPassport">IsPassport</span>
+
+<p>判断护照(正则判断)。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsPassport(passport, country string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsPassport("P123456789", "CN")
+    result2 := validator.IsPassport("123456789", "US")
+    result3 := validator.IsPassport("AB1234567", "RU")
+    result4 := validator.IsPassport("123456789", "CN")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // true
+    // false
+}
+```
+
+### <span id="IsChineseHMPassport">IsChineseHMPassport</span>
+
+<p>判断港澳台通行证(正则判断)。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsChineseHMPassport(hmPassport string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsChineseHMPassport("C12345678")
+    result2 := validator.IsChineseHMPassport("C00000000")
+    result3 := validator.IsChineseHMPassport("M12345678")
+    result4 := validator.IsChineseHMPassport("c12345678")
+    result5 := validator.IsChineseHMPassport("C1234567")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+
+    // Output:
+    // true
+    // true
+    // true
+    // false
+    // false
+}
+```
--- a/docs/en/api/overview.md
+++ b/docs/en/api/overview.md
@@ -46,6 +46,7 @@ outline: deep
        <div class="package-cell">cryptor</div>
        <div class="package-cell">datastructure</div>
        <div class="package-cell">datetime</div>
+        <div class="package-cell">enum</div>
        <div class="package-cell">eventbus</div>
        <div class="package-cell">fileutil</div>
        <div class="package-cell">formatter</div>
--- a/docs/en/api/packages/enum.md
+++ b/docs/en/api/packages/enum.md
@@ -0,0 +1,850 @@
+# Enum
+
+Package enum provides a simple enum implementation.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+- [https://github.com/duke-git/lancet/blob/main/enum/enum.go](https://github.com/duke-git/lancet/blob/main/enum/enum.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/enum"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+-   [NewItem](#NewItem)
+-   [NewItemsFromPairs](#NewItemsFromPairs)
+-   [Value](#Value)
+-   [Name](#Name)
+-   [Valid](#Valid)
+-   [MarshalJSON](#MarshalJSON)
+-   [NewRegistry](#NewRegistry)
+-   [Add](#Add)
+-   [Remove](#Remove)
+-   [Update](#Update)
+-   [GetByValue](#GetByValue)
+-   [GetByName](#GetByName)
+-   [Items](#Items)
+-   [Contains](#Contains)
+-   [Size](#Size)
+-   [Range](#Range)
+-   [SortedItems](#SortedItems)
+-   [Filter](#Filter)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### <span id="NewItem">NewItem</span>
+
+<p>Creates a new enum item.</p>
+
+<b>Signature:</b>
+
+```go
+func NewItem[T comparable](value T, name string) *Item[T]
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    fmt.Println(item1.Name(), item1.Value())
+    fmt.Println(item2.Name(), item2.Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="NewItemsFromPairs">NewItemsFromPairs</span>
+
+<p>Creates enum items from a slice of Pair structs.</p>
+
+<b>Signature:</b>
+
+```go
+func NewItemsFromPairs[T comparable](pairs ...Pair[T]) []*Item[T]
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    items := enum.NewItemsFromPairs(
+        enum.Pair[Status]{Value: Active, Name: "Active"},
+        enum.Pair[Status]{Value: Inactive, Name: "Inactive"},
+    )
+
+    fmt.Println(items[0].Name(), items[0].Value())
+    fmt.Println(items[1].Name(), items[1].Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Value">Value</span>
+
+<p>Returns the value of the enum item.</p>
+
+<b>Signature:</b>
+
+```go
+func (it *Item[T]) Value() T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    items := enum.NewItemsFromPairs(
+        enum.Pair[Status]{Value: Active, Name: "Active"},
+        enum.Pair[Status]{Value: Inactive, Name: "Inactive"},
+    )
+
+    fmt.Println(items[0].Name(), items[0].Value())
+    fmt.Println(items[1].Name(), items[1].Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Name">Name</span>
+
+<p>Returns the name of the enum item.</p>
+
+<b>Signature:</b>
+
+```go
+func (it *Item[T]) Name() string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    items := enum.NewItemsFromPairs(
+        enum.Pair[Status]{Value: Active, Name: "Active"},
+        enum.Pair[Status]{Value: Inactive, Name: "Inactive"},
+    )
+
+    fmt.Println(items[0].Name(), items[0].Value())
+    fmt.Println(items[1].Name(), items[1].Value())
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Valid">Valid</span>
+
+<p>Checks if the enum item is valid. If a custom check function is provided, it will be used to validate the value.</p>
+
+<b>Signature:</b>
+
+```go
+func (it *Item[T]) Valid(checker ...func(T) bool) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    item := enum.NewItem(Active, "Active")
+    fmt.Println(item.Valid())
+
+    invalidItem := enum.NewItem(Unknown, "")
+    fmt.Println(invalidItem.Valid())
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="MarshalJSON">MarshalJSON</span>
+
+<p>Implementation of json.Marshaler interface.</p>
+
+<b>Signature:</b>
+
+```go
+func (it *Item[T]) MarshalJSON() ([]byte, error)
+func (it *Item[T]) UnmarshalJSON(data []byte) error
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    item := enum.NewItem(Active, "Active")
+    data, _ := item.MarshalJSON()
+    fmt.Println(string(data))
+
+    var unmarshaledItem Item[Status]
+    _ = unmarshaledItem.UnmarshalJSON(data)
+    fmt.Println(unmarshaledItem.Name(), unmarshaledItem.Value())
+
+    // Output:
+    // {"name":"Active","value":1}
+    // Active 1
+}
+```
+
+### <span id="NewRegistry">NewRegistry</span>
+
+<p>Creates a new enum registry.</p>
+
+<b>Signature:</b>
+
+```go
+func NewRegistry[T comparable](items ...*Item[T]) *Registry[T]
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    registry.Add(item1, item2)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("Found by value:", item.Name())
+    }
+
+    if item, found := registry.GetByName("Inactive"); found {
+        fmt.Println("Found by name:", item.Value())
+    }
+
+    // Output:
+    // Found by value: Active
+    // Found by name: 2
+}
+```
+
+### <span id="Add">Add</span>
+
+<p>Adds enum items to the registry.</p>
+
+<b>Signature:</b>
+
+```go
+func (r *Registry[T]) Add(items ...*Item[T])
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    registry.Add(item1, item2)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("Found by value:", item.Name())
+    }
+
+    if item, found := registry.GetByName("Inactive"); found {
+        fmt.Println("Found by name:", item.Value())
+    }
+
+    // Output:
+    // Found by value: Active
+    // Found by name: 2
+}
+```
+
+### <span id="Remove">Remove</span>
+
+<p>Removes an enum item from the registry by its value.</p>
+
+<b>Signature:</b>
+
+```go
+func (r *Registry[T]) Remove(value T) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+
+    registry.Add(item1)
+    fmt.Println("Size before removal:", registry.Size())
+
+    removed := registry.Remove(Active)
+    fmt.Println("Removed:", removed)
+    fmt.Println("Size after removal:", registry.Size())
+
+    // Output:
+    // Size before removal: 1
+    // Removed: true
+    // Size after removal: 0
+}
+```
+
+### <span id="Update">Update</span>
+
+<p>Updates the name of an enum item in the registry by its value.</p>
+
+<b>Signature:</b>
+
+```go
+func (r *Registry[T]) Update(value T, newName string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+
+    registry.Add(item1)
+    updated := registry.Update(Active, "Activated")
+    fmt.Println("Updated:", updated)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("New name:", item.Name())
+    }
+
+    // Output:
+    // Updated: true
+    // New name: Activated
+}
+```
+
+### <span id="GetByValue">GetByValue</span>
+
+<p>Retrieves an enum item by its value.</p>
+
+<b>Signature:</b>
+
+```go
+func (r *Registry[T]) GetByValue(value T) (*Item[T], bool)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+
+    registry.Add(item1, item2)
+
+    if item, found := registry.GetByValue(Active); found {
+        fmt.Println("Found name by value:", item.Name())
+    }
+
+    // Output:
+    // Found name by value: Active
+}
+```
+
+### <span id="GetByName">GetByName</span>
+
+<p>Retrieves an enum item by its name.</p>
+
+<b>Signature:</b>
+
+```go
+func (r *Registry[T]) GetByName(name string) (*Item[T], bool)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item := enum.NewItem(Active, "Active")
+
+    registry.Add(item)
+
+    if item, found := registry.GetByName("Active"); found {
+        fmt.Println("Found value by name:", item.Value())
+    }
+
+    // Output:
+    // Found value by name: 1
+}
+```
+
+### <span id="Items">Items</span>
+
+<p>Returns a slice of all enum items in the registry.</p>
+
+<b>Signature:</b>
+
+```go
+func (r *Registry[T]) Items() []*Item[T]
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+
+    registry.Add(item1, item2)
+
+    for _, item := range registry.Items() {
+        fmt.Println(item.Name(), item.Value())
+    }
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Contains">Contains</span>
+
+<p>Checks if an enum item with the given value exists in the registry.</p>
+
+<b>Signature:</b>
+
+```go
+func (r *Registry[T]) Contains(value T) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item := enum.NewItem(Active, "Active")
+    registry.Add(item)
+
+    fmt.Println(registry.Contains(Active))
+    fmt.Println(registry.Contains(Inactive))
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="Size">Size</span>
+
+<p>Returns the number of enum items in the registry.</p>
+
+<b>Signature:</b>
+
+```go
+func (r *Registry[T]) Size() int
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    fmt.Println("Initial size:", registry.Size())
+
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+    registry.Add(item1, item2)
+
+    fmt.Println("Size after adding items:", registry.Size())
+
+    registry.Remove(Active)
+    fmt.Println("Size after removing an item:", registry.Size())
+
+    // Output:
+    // Initial size: 0
+    // Size after adding items: 2
+    // Size after removing an item: 1
+}
+```
+
+### <span id="Range">Range</span>
+
+<p>Iterates over all enum items in the registry and applies the given function.</p>
+
+<b>Signature:</b>
+
+```go
+func (r *Registry[T]) Range(fn func(*Item[T]) bool)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+    registry.Add(item1, item2)
+
+    registry.Range(func(item *Item[Status]) bool {
+        fmt.Println(item.Name(), item.Value())
+        return true // continue iteration
+    })
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="SortedItems">SortedItems</span>
+
+<p>Returns a slice of all enum items sorted by the given less function.</p>
+
+<b>Signature:</b>
+
+```go
+func (r *Registry[T]) SortedItems(less func(*Item[T], *Item[T]) bool) []*Item[T]
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Inactive, "Inactive")
+    item2 := enum.NewItem(Active, "Active")
+    registry.Add(item1, item2)
+
+    for _, item := range registry.SortedItems(func(i1, i2 *Item[Status]) bool {
+        return i1.value < i2.value
+    }) {
+        fmt.Println(item.Name(), item.Value())
+    }
+
+    // Output:
+    // Active 1
+    // Inactive 2
+}
+```
+
+### <span id="Filter">Filter</span>
+
+<p>Returns a slice of enum items that satisfy the given predicate function.</p>
+
+<b>Signature:</b>
+
+```go
+func (r *Registry[T]) Filter(predicate func(*Item[T]) bool) []*Item[T]
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/enum"
+)
+
+type Status int
+
+const (
+    Unknown Status = iota
+    Active
+    Inactive
+)
+
+func main() {
+    registry := enum.NewRegistry[Status]()
+    item1 := enum.NewItem(Active, "Active")
+    item2 := enum.NewItem(Inactive, "Inactive")
+    registry.Add(item1, item2)
+
+    activeItems := registry.Filter(func(item *Item[Status]) bool {
+        return item.Value() == Active
+    })
+
+    for _, item := range activeItems {
+        fmt.Println(item.Name(), item.Value())
+    }
+
+    // Output:
+    // Active 1
+}
+```
--- a/docs/en/api/packages/maputil.md
+++ b/docs/en/api/packages/maputil.md
@@ -79,6 +79,8 @@ import (
 -   [SortByKey](#SortByKey)
 -   [GetOrDefault](#GetOrDefault)
 -   [FindValuesBy](#FindValuesBy)
+-   [ToMarkdownTable](#ToMarkdownTable)
+

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

@@ -2363,3 +2365,69 @@ func main() {
    // [b d]
 }
 ```
+
+### <span id="ToMarkdownTable">ToMarkdownTable</span>
+
+<p>Convert a map slice data to a Markdown table string. It supports custom header display names and column display order.</p>
+
+<b>Signature:</b>
+
+```go
+编辑
+func ToMarkdownTable(data []map[string]interface{}, headerMap map[string]string, columnOrder []string) string
+```
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    // basic usage: automatically extract column names from data as table headers
+
+    data := []map[string]interface{}{
+        {"name": "Alice", "age": 25, "salary": 50000},
+        {"name": "Bob", "age": 30, "salary": 60000},
+    }
+
+    result := maputil.ToMarkdownTable(data, nil, nil)
+    fmt.Println(result)
+
+    // output:
+    // |name|age|salary|
+    // |---|---|---|
+    // |Alice|25|50000|
+    // |Bob|30|60000|
+
+    // custom header name
+    headerMap := map[string]string{
+        "name":   "n",
+        "age":    "a",
+        "salary": "s",
+    }
+    result = maputil.ToMarkdownTable(data, headerMap, nil)
+    fmt.Println(result)
+
+    // ouput:
+    // |m|a|s|
+    // |---|---|---|
+    // |Alice|25|50000|
+    // |Bob|30|60000|
+
+    // custom column display order
+    columnOrder := []string{"salary", "name"}
+    result = maputil.ToMarkdownTable(data, nil, columnOrder)
+    fmt.Println(result)
+
+    // 输出:
+    // |salary|name|
+    // |---|---|
+    // |50000|Alice|
+    // |60000|Bob|
+}
+```
--- a/docs/en/api/packages/slice.md
+++ b/docs/en/api/packages/slice.md
@@ -27,6 +27,7 @@ import (
 -   [Contain](#Contain)
 -   [ContainBy](#ContainBy)
 -   [ContainSubSlice](#ContainSubSlice)
+-   [ContainAny](#ContainAny)
 -   [Chunk](#Chunk)
 -   [Compact](#Compact)
 -   [Concat](#Concat)
@@ -256,6 +257,43 @@ func main() {
 }
 ```

+### <span id="ContainAny">ContainAny</span>
+
+<p>Check if the slice contains any element from the targets slice.</p>
+
+<b>Signature:</b>
+
+```go
+func ContainAny[T comparable](slice []T, targets []T) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4xoxhc9XSSw)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.ContainAny([]string{"a", "b", "c"}, []string{"a"})
+    result2 := slice.ContainAny([]string{"a", "b", "c"}, []string{"d", "e"})
+    result3 := slice.ContainAny([]string{"a", "b", "c"}, []string{"d", "a"})
+    result4 := slice.ContainAny([]string{"a", "b", "c"}, []string{})
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // false
+    // true
+    // false
+}
+```
+
 ### <span id="Chunk">Chunk</span>

 <p>Creates an slice of elements split into groups the length of `size`.</p>
--- a/docs/en/api/packages/struct.md
+++ b/docs/en/api/packages/struct.md
@@ -31,6 +31,7 @@ import (
 -   [IsStruct](#IsStruct)
 -   [Tag](#Tag)
 -   [Name](#Name)
+-   [TypeName](#TypeName)
 -   [Value](#Value)
 -   [Kind](#Kind)
 -   [IsEmbedded](#IsEmbedded)
@@ -53,12 +54,13 @@ import (
 func New(value any, tagName ...string) *Struct
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/O29l8kk-Z17)</span></b>

 ```go
 package main

 import (
+    "fmt"
    "github.com/duke-git/lancet/v2/structs"
 )

@@ -68,7 +70,11 @@ func main() {
    }
    p1 := &People{Name: "11"}
    s := structs.New(p1)
-    // to do something
+    
+    fmt.Println(s.ToMap())
+
+    // Output:
+    // map[name:11] <nil>
 }
 ```

@@ -88,7 +94,7 @@ func (s *Struct) ToMap() (map[string]any, error)
 func ToMap(v any) (map[string]any, error)
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qQbLySBgerZ)</span></b>

 ```go
 package main
@@ -130,7 +136,7 @@ func main() {
 func (s *Struct) Fields() []*Field
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/w3Kk_CyVY7D)</span></b>

 ```go
 package main
@@ -162,10 +168,10 @@ func main() {
 <b>Signature:</b>

 ```go
-func (s *Struct) Field(name string) *Field
+func (s *Struct) Field(name string) (*Field, bool)
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/KocZMSYarza)</span></b>

 ```go
 package main
@@ -181,12 +187,14 @@ func main() {
    }
    p1 := &People{Name: "11"}
    s := structs.New(p1)
-    f := s.Field("Name")
+    f, found := s.Field("Name")

    fmt.Println(f.Value())
+    fmt.Println(found)

    // Output:
    // 11
+    // true
 }
 ```

@@ -200,7 +208,7 @@ func main() {
 func (s *Struct) IsStruct() bool
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bU2FSdkbK1C)</span></b>

 ```go
 package main
@@ -234,7 +242,7 @@ func main() {
 func (f *Field) Tag() *Tag
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/DVrx5HvvUJr)</span></b>

 ```go
 package main
@@ -271,7 +279,7 @@ func main() {
 func (f *Field) Value() any
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qufYEU2o4Oi)</span></b>

 ```go
 package main
@@ -307,7 +315,7 @@ func main() {
 func (f *Field) IsEmbedded() bool
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/wV2PrbYm3Ec)</span></b>

 ```go
 package main
@@ -352,7 +360,7 @@ func main() {
 func (f *Field) IsExported() bool
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/csK4AXYaNbJ)</span></b>

 ```go
 package main
@@ -391,7 +399,7 @@ func main() {
 func (f *Field) IsZero() bool
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/RzqpGISf87r)</span></b>

 ```go
 package main
@@ -430,7 +438,7 @@ func main() {
 func (f *Field) Name() string
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/zfIGlqsatee)</span></b>

 ```go
 package main
@@ -469,7 +477,7 @@ func main() {
 func (f *Field) Kind() reflect.Kind
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/wg4NlcUNG5o)</span></b>

 ```go
 package main
@@ -498,6 +506,42 @@ func main() {
 }
 ```

+### <span id="TypeName">TypeName</span>
+
+<p>Return struct type name.</p>
+
+<b>Signature:</b>
+
+```go
+func (s *Struct) TypeName() string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type Parent struct {
+        Name string
+        Age  int
+    }
+
+    p := &Parent{Age: 11}
+    s := structs.New(p1)
+
+    fmt.Println(s.TypeName())
+    
+    // Output: 
+    // Parent
+}
+```
+
 ### <span id="IsSlice">IsSlice</span>

 <p>Check if the field is a slice</p>
@@ -508,7 +552,7 @@ func main() {
 func (f *Field) IsSlice() bool
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/MKz4CgBIUrU)</span></b>

 ```go
 package main
@@ -545,7 +589,7 @@ func main() {
 func (f *Field) IsTargetType(targetType reflect.Kind) bool
 ```

-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Ig75P-agN39)</span></b>

 ```go
 package main
--- a/docs/en/api/packages/validator.md
+++ b/docs/en/api/packages/validator.md
@@ -65,6 +65,8 @@ import (
 -   [IsAmericanExpress](#IsAmericanExpress)
 -   [IsUnionPay](#IsUnionPay)
 -   [IsChinaUnionPay](#IsChinaUnionPay)
+-   [IsPassport](#IsPassport)
+-   [IsChineseHMPassport](#IsChineseHMPassport)

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

@@ -1569,3 +1571,80 @@ func main() {
    // false
 }
 ```
+
+### <span id="IsPassport">IsPassport</span>
+
+<p>Passport validation(using regex).</p>
+
+<b>Signature:</b>
+
+```go
+func IsPassport(passport, country string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsPassport("P123456789", "CN")
+    result2 := validator.IsPassport("123456789", "US")
+    result3 := validator.IsPassport("AB1234567", "RU")
+    result4 := validator.IsPassport("123456789", "CN")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // true
+    // false
+}
+```
+
+### <span id="IsChineseHMPassport">IsChineseHMPassport</span>
+
+<p>Mainland travel permit for Hong Kong, Macao validation (using regex). </p>
+
+<b>Signature:</b>
+
+```go
+func IsChineseHMPassport(hmPassport string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsChineseHMPassport("C12345678")
+    result2 := validator.IsChineseHMPassport("C00000000")
+    result3 := validator.IsChineseHMPassport("M12345678")
+    result4 := validator.IsChineseHMPassport("c12345678")
+    result5 := validator.IsChineseHMPassport("C1234567")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+
+    // Output:
+    // true
+    // true
+    // true
+    // false
+    // false
+}
+```
--- a/docs/package-lock.json
+++ b/docs/package-lock.json
--- a/enum/enum.go
+++ b/enum/enum.go
@@ -8,6 +8,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"reflect"
+	"sort"
 	"sync"
 )

@@ -15,7 +16,8 @@ import (
 type Enum[T comparable] interface {
 	Value() T
 	String() string
-	Valid() bool
+	Name() string
+	Valid(checker ...func(T) bool) bool
 }

 // Item defines a common enum item struct implement Enum interface.
@@ -24,68 +26,65 @@ type Item[T comparable] struct {
 	name  string
 }

+// NewItem creates a new enum item.
 func NewItem[T comparable](value T, name string) *Item[T] {
 	return &Item[T]{value: value, name: name}
 }

-// NewWithItems creates enum items from value-name pairs.
-// It requires an even number of arguments, where each pair consists of a value of type T and a string name.
-// If the number of arguments is odd or if any argument does not match the expected type, it will panic.
-func NewItems[T comparable](args ...any) []*Item[T] {
-	if len(args) == 0 {
+// Pair represents a value-name pair for creating enum items
+type Pair[T comparable] struct {
+	Value T
+	Name  string
+}
+
+// NewItemsFromPairs creates enum items from a slice of Pair structs.
+func NewItemsFromPairs[T comparable](pairs ...Pair[T]) []*Item[T] {
+	if len(pairs) == 0 {
 		return []*Item[T]{}
 	}
-	if len(args)%2 != 0 {
-		panic("New requires even number of arguments (value, name pairs)")
-	}

-	items := make([]*Item[T], 0, len(args)/2)
-
-	for i := 0; i < len(args); i += 2 {
-		value, ok := args[i].(T)
-		if !ok {
-			panic(fmt.Sprintf("argument %d is not of type %T", i, value))
-		}
-
-		name, ok := args[i+1].(string)
-		if !ok {
-			panic(fmt.Sprintf("argument %d is not of type string", i+1))
-		}
-
-		items = append(items, &Item[T]{value: value, name: name})
+	items := make([]*Item[T], 0, len(pairs))
+	for _, pair := range pairs {
+		items = append(items, &Item[T]{value: pair.Value, name: pair.Name})
 	}

 	return items
-
 }

-func (e *Item[T]) Value() T {
-	return e.value
+// Value returns the value of the enum item.
+func (it *Item[T]) Value() T {
+	return it.value
 }

-func (e *Item[T]) Name() string {
-	return e.name
+// Name returns the name of the enum item.
+func (it *Item[T]) Name() string {
+	return it.name
+}
+
+// String returns the string representation of the enum item.
+func (it *Item[T]) String() string {
+	return it.name
 }

 // Valid checks if the enum item is valid. If a custom check function is provided, it will be used to validate the value.
-func (e *Item[T]) Valid(check ...func(T) bool) bool {
-	if len(check) > 0 {
-		return check[0](e.value) && e.name != ""
+func (it *Item[T]) Valid(checker ...func(T) bool) bool {
+	if len(checker) > 0 {
+		return checker[0](it.value) && it.name != ""
 	}
 	var zero T
-	return e.value != zero && e.name != ""
+	return it.value != zero && it.name != ""
 }

 // MarshalJSON implements the json.Marshaler interface.
-func (e *Item[T]) MarshalJSON() ([]byte, error) {
+func (it *Item[T]) MarshalJSON() ([]byte, error) {
 	return json.Marshal(map[string]any{
-		"value": e.value,
-		"name":  e.name,
+		"value": it.value,
+		"name":  it.name,
 	})
 }

 // UnmarshalJSON implements the json.Unmarshaler interface.
-func (e *Item[T]) UnmarshalJSON(data []byte) error {
+func (it *Item[T]) UnmarshalJSON(data []byte) error {
 	type alias struct {
 		Value any    `json:"value"`
 		Name  string `json:"name"`
@@ -104,48 +103,47 @@ func (e *Item[T]) UnmarshalJSON(data []byte) error {
 			return fmt.Errorf("invalid type for value, want int family")
 		}
 		converted := reflect.ValueOf(int64(val)).Convert(rv)
-		e.value = converted.Interface().(T)
+		it.value = converted.Interface().(T)
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 		val, ok := temp.Value.(float64)
 		if !ok {
 			return fmt.Errorf("invalid type for value, want uint family")
 		}
 		converted := reflect.ValueOf(uint64(val)).Convert(rv)
-		e.value = converted.Interface().(T)
+		it.value = converted.Interface().(T)
 	case reflect.Float32, reflect.Float64:
 		val, ok := temp.Value.(float64)
 		if !ok {
 			return fmt.Errorf("invalid type for value, want float family")
 		}
 		converted := reflect.ValueOf(val).Convert(rv)
-		e.value = converted.Interface().(T)
+		it.value = converted.Interface().(T)
 	case reflect.String:
 		val, ok := temp.Value.(string)
 		if !ok {
 			return fmt.Errorf("invalid type for value, want string")
 		}
-		e.value = any(val).(T)
+		it.value = any(val).(T)
 	case reflect.Bool:
 		val, ok := temp.Value.(bool)
 		if !ok {
 			return fmt.Errorf("invalid type for value, want bool")
 		}
-		e.value = any(val).(T)
+		it.value = any(val).(T)
 	default:
-		// 枚举类型底层通常是 int，可以尝试 float64->int64->底层类型
 		val, ok := temp.Value.(float64)
 		if ok {
 			converted := reflect.ValueOf(int64(val)).Convert(rv)
-			e.value = converted.Interface().(T)
+			it.value = converted.Interface().(T)
 		} else {
 			val2, ok2 := temp.Value.(T)
 			if !ok2 {
 				return fmt.Errorf("invalid type for value")
 			}
-			e.value = val2
+			it.value = val2
 		}
 	}
-	e.name = temp.Name
+	it.name = temp.Name
 	return nil
 }

@@ -157,6 +155,7 @@ type Registry[T comparable] struct {
 	items  []*Item[T]
 }

+// NewRegistry creates a new enum registry.
 func NewRegistry[T comparable](items ...*Item[T]) *Registry[T] {
 	r := &Registry[T]{
 		values: make(map[T]*Item[T]),
@@ -255,24 +254,6 @@ func (r *Registry[T]) Contains(value T) bool {
 	return ok
 }

-// Validate checks if the given value is a valid enum item in the registry.
-func (r *Registry[T]) Validate(value T) error {
-	if !r.Contains(value) {
-		return fmt.Errorf("invalid enum value: %v", value)
-	}
-	return nil
-}
-
-// ValidateAll checks if all given values are valid enum items in the registry.
-func (r *Registry[T]) ValidateAll(values ...T) error {
-	for _, value := range values {
-		if err := r.Validate(value); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 // Size returns the number of enum items in the registry.
 func (r *Registry[T]) Size() int {
 	r.mu.RLock()
@@ -280,3 +261,38 @@ func (r *Registry[T]) Size() int {

 	return len(r.items)
 }
+
+// Range iterates over all enum items in the registry and applies the given function.
+func (r *Registry[T]) Range(fn func(*Item[T]) bool) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	for _, item := range r.items {
+		if !fn(item) {
+			break
+		}
+	}
+}
+
+// SortedItems returns a slice of all enum items sorted by the given less function.
+func (r *Registry[T]) SortedItems(less func(*Item[T], *Item[T]) bool) []*Item[T] {
+	items := r.Items()
+	sort.Slice(items, func(i, j int) bool {
+		return less(items[i], items[j])
+	})
+	return items
+}
+
+// Filter returns a slice of enum items that satisfy the given predicate function.
+func (r *Registry[T]) Filter(predicate func(*Item[T]) bool) []*Item[T] {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	var result []*Item[T]
+	for _, item := range r.items {
+		if predicate(item) {
+			result = append(result, item)
+		}
+	}
+	return result
+}
--- a/enum/enum_example_test.go
+++ b/enum/enum_example_test.go
@@ -0,0 +1,208 @@
+package enum
+
+import "fmt"
+
+func ExampleNewItem() {
+	item1 := NewItem(Active, "Active")
+	item2 := NewItem(Inactive, "Inactive")
+
+	fmt.Println(item1.Name(), item1.Value())
+	fmt.Println(item2.Name(), item2.Value())
+
+	// Output:
+	// Active 1
+	// Inactive 2
+}
+
+func ExampleNewItemsFromPairs() {
+	items := NewItemsFromPairs(
+		Pair[Status]{Value: Active, Name: "Active"},
+		Pair[Status]{Value: Inactive, Name: "Inactive"},
+	)
+
+	fmt.Println(items[0].Name(), items[0].Value())
+	fmt.Println(items[1].Name(), items[1].Value())
+
+	// Output:
+	// Active 1
+	// Inactive 2
+}
+
+func ExampleItem_Valid() {
+	item := NewItem(Active, "Active")
+	fmt.Println(item.Valid())
+
+	invalidItem := NewItem(Unknown, "")
+	fmt.Println(invalidItem.Valid())
+
+	// Output:
+	// true
+	// false
+}
+
+func ExampleItem_MarshalJSON() {
+	item := NewItem(Active, "Active")
+	data, _ := item.MarshalJSON()
+	fmt.Println(string(data))
+
+	var unmarshaledItem Item[Status]
+	_ = unmarshaledItem.UnmarshalJSON(data)
+	fmt.Println(unmarshaledItem.Name(), unmarshaledItem.Value())
+
+	// Output:
+	// {"name":"Active","value":1}
+	// Active 1
+}
+
+func ExampleRegistry_Add() {
+	registry := NewRegistry[Status]()
+	item1 := NewItem(Active, "Active")
+	item2 := NewItem(Inactive, "Inactive")
+
+	registry.Add(item1, item2)
+
+	if item, found := registry.GetByValue(Active); found {
+		fmt.Println("Found by value:", item.Name())
+	}
+
+	if item, found := registry.GetByName("Inactive"); found {
+		fmt.Println("Found by name:", item.Value())
+	}
+
+	// Output:
+	// Found by value: Active
+	// Found by name: 2
+}
+
+func ExampleRegistry_Remove() {
+	registry := NewRegistry[Status]()
+	item1 := NewItem(Active, "Active")
+
+	registry.Add(item1)
+	fmt.Println("Size before removal:", registry.Size())
+
+	removed := registry.Remove(Active)
+	fmt.Println("Removed:", removed)
+	fmt.Println("Size after removal:", registry.Size())
+
+	// Output:
+	// Size before removal: 1
+	// Removed: true
+	// Size after removal: 0
+}
+
+func ExampleRegistry_Update() {
+	registry := NewRegistry[Status]()
+	item1 := NewItem(Active, "Active")
+
+	registry.Add(item1)
+	updated := registry.Update(Active, "Activated")
+	fmt.Println("Updated:", updated)
+
+	if item, found := registry.GetByValue(Active); found {
+		fmt.Println("New name:", item.Name())
+	}
+
+	// Output:
+	// Updated: true
+	// New name: Activated
+}
+
+func ExampleRegistry_Items() {
+	registry := NewRegistry[Status]()
+	item1 := NewItem(Active, "Active")
+	item2 := NewItem(Inactive, "Inactive")
+
+	registry.Add(item1, item2)
+
+	for _, item := range registry.Items() {
+		fmt.Println(item.Name(), item.Value())
+	}
+
+	// Output:
+	// Active 1
+	// Inactive 2
+}
+
+func ExampleRegistry_Contains() {
+	registry := NewRegistry[Status]()
+	item := NewItem(Active, "Active")
+	registry.Add(item)
+
+	fmt.Println(registry.Contains(Active))
+	fmt.Println(registry.Contains(Inactive))
+
+	// Output:
+	// true
+	// false
+}
+
+func ExampleRegistry_Size() {
+	registry := NewRegistry[Status]()
+	fmt.Println("Initial size:", registry.Size())
+
+	item1 := NewItem(Active, "Active")
+	item2 := NewItem(Inactive, "Inactive")
+	registry.Add(item1, item2)
+
+	fmt.Println("Size after adding items:", registry.Size())
+
+	registry.Remove(Active)
+	fmt.Println("Size after removing an item:", registry.Size())
+
+	// Output:
+	// Initial size: 0
+	// Size after adding items: 2
+	// Size after removing an item: 1
+}
+
+func ExampleRegistry_Range() {
+	registry := NewRegistry[Status]()
+	item1 := NewItem(Active, "Active")
+	item2 := NewItem(Inactive, "Inactive")
+	registry.Add(item1, item2)
+
+	registry.Range(func(item *Item[Status]) bool {
+		fmt.Println(item.Name(), item.Value())
+		return true // continue iteration
+	})
+
+	// Output:
+	// Active 1
+	// Inactive 2
+}
+
+func ExampleRegistry_SortedItems() {
+	registry := NewRegistry[Status]()
+	item1 := NewItem(Inactive, "Inactive")
+	item2 := NewItem(Active, "Active")
+	registry.Add(item1, item2)
+
+	for _, item := range registry.SortedItems(func(i1, i2 *Item[Status]) bool {
+		return i1.value < i2.value
+	}) {
+		fmt.Println(item.Name(), item.Value())
+	}
+
+	// Output:
+	// Active 1
+	// Inactive 2
+}
+
+func ExampleRegistry_Filter() {
+	registry := NewRegistry[Status]()
+	item1 := NewItem(Active, "Active")
+	item2 := NewItem(Inactive, "Inactive")
+	registry.Add(item1, item2)
+
+	activeItems := registry.Filter(func(item *Item[Status]) bool {
+		return item.Value() == Active
+	})
+
+	for _, item := range activeItems {
+		fmt.Println(item.Name(), item.Value())
+	}
+
+	// Output:
+	// Active 1
+}
--- a/enum/enum_test.go
+++ b/enum/enum_test.go
@@ -17,13 +17,13 @@ const (
 	Inactive
 )

-func TestNewItem(t *testing.T) {
+func TestNewItemsFromPairs(t *testing.T) {
 	t.Parallel()
-	assert := internal.NewAssert(t, "TestNewItem")
+	assert := internal.NewAssert(t, "TestNewItemsFromPairs")

-	items := NewItems[Status](
-		Active, "Active",
-		Inactive, "Inactive",
+	items := NewItemsFromPairs(
+		Pair[Status]{Value: Active, Name: "Active"},
+		Pair[Status]{Value: Inactive, Name: "Inactive"},
 	)

 	assert.Equal(2, len(items))
@@ -128,36 +128,57 @@ func TestRegistry_Contains(t *testing.T) {
 	assert.Equal(false, registry.Contains(Inactive))
 }

-func TestRegistry_Validate(t *testing.T) {
+func TestRegistry_Range(t *testing.T) {
 	t.Parallel()
-	assert := internal.NewAssert(t, "TestRegistry_Validate")
+	assert := internal.NewAssert(t, "TestRegistry_Range")

 	registry := NewRegistry[Status]()
 	item1 := NewItem(Active, "Active")
 	item2 := NewItem(Inactive, "Inactive")
 	registry.Add(item1, item2)

-	err := registry.Validate(Active)
-	assert.IsNil(err)
-	err = registry.Validate(Inactive)
-	assert.IsNil(err)
+	var values []Status
+	registry.Range(func(item *Item[Status]) bool {
+		values = append(values, item.Value())
+		return true
+	})

-	err = registry.Validate(Unknown)
-	assert.IsNotNil(err)
+	assert.Equal(2, len(values))
+	assert.Equal(Active, values[0])
+	assert.Equal(Inactive, values[1])
 }

-func TestRegistry_ValidateAll(t *testing.T) {
+func TestRegistry_SortedItems(t *testing.T) {
 	t.Parallel()
-	assert := internal.NewAssert(t, "TestRegistry_ValidateAll")
+	assert := internal.NewAssert(t, "TestRegistry_SortedItems")
+
+	registry := NewRegistry[Status]()
+	item1 := NewItem(Inactive, "Inactive")
+	item2 := NewItem(Active, "Active")
+	registry.Add(item1, item2)
+
+	sortedItems := registry.SortedItems(func(i1, i2 *Item[Status]) bool {
+		return i1.value < i2.value
+	})
+
+	assert.Equal(2, len(sortedItems))
+	assert.Equal(Active, sortedItems[0].Value())
+	assert.Equal(Inactive, sortedItems[1].Value())
+}
+
+func TestRegistry_Filter(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestRegistry_Filter")

 	registry := NewRegistry[Status]()
 	item1 := NewItem(Active, "Active")
 	item2 := NewItem(Inactive, "Inactive")
 	registry.Add(item1, item2)

-	err := registry.ValidateAll(Active, Inactive)
-	assert.IsNil(err)
+	filteredItems := registry.Filter(func(item *Item[Status]) bool {
+		return item.Value() == Active
+	})

-	err = registry.ValidateAll(Active, Unknown)
-	assert.IsNotNil(err)
+	assert.Equal(1, len(filteredItems))
+	assert.Equal(Active, filteredItems[0].Value())
 }
--- a/maputil/map.go
+++ b/maputil/map.go
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"reflect"
 	"sort"
+	"strconv"
 	"strings"

 	"golang.org/x/exp/constraints"
@@ -680,3 +681,150 @@ func FindValuesBy[K comparable, V any](m map[K]V, predicate func(key K, value V)

 	return result
 }
+
+// ToMarkdownTable converts a slice of maps to a Markdown table.
+// Play: ttps://go.dev/play/p/todo
+func ToMarkdownTable(data []map[string]interface{}, headerMap map[string]string, columnOrder []string) string {
+	if len(data) == 0 {
+		return "| |\n|---|\n"
+	}
+
+	var headers []string
+
+	// 如果提供了columnOrder，则按指定顺序排列
+	if len(columnOrder) > 0 {
+		headers = make([]string, len(columnOrder))
+		copy(headers, columnOrder)
+	} else {
+		// 否则按自然顺序提取headers
+		seen := make(map[string]bool)
+		for _, row := range data {
+			for k := range row {
+				if !seen[k] {
+					seen[k] = true
+					headers = append(headers, k)
+				}
+			}
+		}
+	}
+
+	var builder strings.Builder
+
+	// Header row - 使用映射的中文标题
+	builder.WriteString("| ")
+	for i, h := range headers {
+		// 如果有映射则使用中文标题，否则使用原字段名
+		displayHeader := h
+		if headerMap != nil && headerMap[h] != "" {
+			displayHeader = headerMap[h]
+		}
+		builder.WriteString(displayHeader)
+		if i < len(headers)-1 {
+			builder.WriteString(" | ")
+		}
+	}
+	builder.WriteString(" |\n")
+
+	// Separator
+	builder.WriteString("|")
+	for i := range headers {
+		if i > 0 {
+			builder.WriteString("|")
+		}
+		builder.WriteString("---")
+	}
+	builder.WriteString("|\n")
+
+	// Data rows
+	for _, row := range data {
+		builder.WriteString("| ")
+		for i, h := range headers {
+			val, exists := row[h]
+			var cell string
+			if !exists {
+				cell = ""
+			} else {
+				cell = formatValue(val)
+			}
+			builder.WriteString(cell)
+			if i < len(headers)-1 {
+				builder.WriteString(" | ")
+			}
+		}
+		builder.WriteString(" |\n")
+	}
+
+	return builder.String()
+}
+
+// formatValue formats any value for display in Markdown table
+func formatValue(v interface{}) string {
+	switch val := v.(type) {
+	case int:
+		return commaInt64(int64(val))
+	case int8:
+		return commaInt64(int64(val))
+	case int16:
+		return commaInt64(int64(val))
+	case int32:
+		return commaInt64(int64(val))
+	case int64:
+		return commaInt64(val)
+	case uint:
+		return commaUint64(uint64(val))
+	case uint8:
+		return commaUint64(uint64(val))
+	case uint16:
+		return commaUint64(uint64(val))
+	case uint32:
+		return commaUint64(uint64(val))
+	case uint64:
+		return commaUint64(val)
+	case float32:
+		return fmt.Sprintf("%.2f", val)
+	case float64:
+		return fmt.Sprintf("%.2f", val)
+	case string:
+		return val
+	case bool:
+		return fmt.Sprintf("%t", val)
+	case nil:
+		return ""
+	default:
+		return fmt.Sprintf("%v", val)
+	}
+}
+
+// commaInt64 adds comma separators to int64
+func commaInt64(n int64) string {
+	if n == 0 {
+		return "0"
+	}
+	neg := n < 0
+	if neg {
+		n = -n
+	}
+	s := strconv.FormatInt(n, 10)
+	return addCommas(s)
+}
+
+// commaUint64 adds comma separators to uint64
+func commaUint64(n uint64) string {
+	if n == 0 {
+		return "0"
+	}
+	s := strconv.FormatUint(n, 10)
+	return addCommas(s)
+}
+
+// addCommas inserts commas every 3 digits
+func addCommas(s string) string {
+	var result strings.Builder
+	for i, c := range s {
+		if i > 0 && (len(s)-i)%3 == 0 {
+			result.WriteRune(',')
+		}
+		result.WriteRune(c)
+	}
+	return result.String()
+}
--- a/maputil/map_test.go
+++ b/maputil/map_test.go
@@ -1,6 +1,7 @@
 package maputil

 import (
+	"fmt"
 	"math/cmplx"
 	"sort"
 	"strconv"
@@ -926,3 +927,46 @@ func TestFindValuesBy(t *testing.T) {
 		assert.Equal(tt.expected, result)
 	}
 }
+
+func TestToMarkdownTable(t *testing.T) {
+	// 测试空数据
+	emptyResult := ToMarkdownTable([]map[string]interface{}{}, nil, nil)
+	expectedEmpty := "| |\n|---|\n"
+	if emptyResult != expectedEmpty {
+		t.Errorf("Expected empty table, got: %s", emptyResult)
+	}
+
+	// 测试基本数据
+	data := []map[string]interface{}{
+		{"name": "Alice", "age": 25, "salary": 50000},
+		{"name": "Bob", "age": 30, "salary": 60000},
+	}
+	result := ToMarkdownTable(data, nil, nil)
+	fmt.Printf("%s", result)
+	// 验证结果包含预期的表头和数据行
+}
+
+// 测试自定义列顺序
+func TestToMarkdownTableWithColumnOrder(t *testing.T) {
+	data := []map[string]interface{}{
+		{"name": "Alice", "age": 25, "salary": 50000},
+	}
+	columnOrder := []string{"salary", "name", "age"}
+	result := ToMarkdownTable(data, nil, columnOrder)
+	fmt.Printf("%s", result)
+	// 验证列顺序是否正确
+}
+
+// 测试自定义表头
+func TestToMarkdownTableWithHeaderMap(t *testing.T) {
+	data := []map[string]interface{}{
+		{"name": "Alice", "age": 25},
+	}
+	headerMap := map[string]string{
+		"name": "姓名",
+		"age":  "年龄",
+	}
+	result := ToMarkdownTable(data, headerMap, nil)
+	fmt.Printf("%s", result)
+	// 验证中文表头是否正确显示
+}
--- a/slice/slice.go
+++ b/slice/slice.go
@@ -74,6 +74,27 @@ func ContainSubSlice[T comparable](slice, subSlice []T) bool {
 	return true
 }

+// ContainAny check if the slice contains any element from the targets slice.
+// Play: https://go.dev/play/p/4xoxhc9XSSw
+func ContainAny[T comparable](slice []T, targets []T) bool {
+	if len(targets) == 0 {
+		return false
+	}
+
+	sliceMap := make(map[T]struct{}, len(slice))
+	for _, item := range slice {
+		sliceMap[item] = struct{}{}
+	}
+
+	for _, target := range targets {
+		if _, exists := sliceMap[target]; exists {
+			return true
+		}
+	}
+
+	return false
+}
+
 // Chunk creates a slice of elements split into groups the length of size.
 // Play: https://go.dev/play/p/b4Pou5j2L_C
 func Chunk[T any](slice []T, size int) [][]T {
--- a/slice/slice_example_test.go
+++ b/slice/slice_example_test.go
@@ -58,6 +58,24 @@ func ExampleContainSubSlice() {
 	// false
 }

+func ExampleContainAny() {
+	result1 := ContainAny([]string{"a", "b", "c"}, []string{"a"})
+	result2 := ContainAny([]string{"a", "b", "c"}, []string{"d", "e"})
+	result3 := ContainAny([]string{"a", "b", "c"}, []string{"d", "a"})
+	result4 := ContainAny([]string{"a", "b", "c"}, []string{})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// true
+	// false
+	// true
+	// false
+}
+
 func ExampleChunk() {
 	arr := []string{"a", "b", "c", "d", "e"}

--- a/slice/slice_test.go
+++ b/slice/slice_test.go
@@ -89,6 +89,46 @@ func TestContainSubSlice(t *testing.T) {
 	}
 }

+func TestContainAny(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestContainAny")
+
+	tests := []struct {
+		slice   []string
+		targets []string
+		want    bool
+	}{
+		{[]string{"a", "b", "c"}, []string{"a"}, true},
+		{[]string{"a", "b", "c"}, []string{"a", "b"}, true},
+		{[]string{"a", "b", "c"}, []string{"d", "e"}, false},
+		{[]string{"a", "b", "c"}, []string{"d", "a"}, true},
+		{[]string{"a", "b", "c"}, []string{}, false},
+		{[]string{}, []string{"a"}, false},
+		{[]string{}, []string{}, false},
+		{[]string{"a", "b", "c"}, []string{"c", "d", "e"}, true},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.want, ContainAny(tt.slice, tt.targets))
+	}
+
+	intTests := []struct {
+		slice   []int
+		targets []int
+		want    bool
+	}{
+		{[]int{1, 2, 3, 4, 5}, []int{3}, true},
+		{[]int{1, 2, 3, 4, 5}, []int{6, 7}, false},
+		{[]int{1, 2, 3, 4, 5}, []int{5, 6, 7}, true},
+		{[]int{1, 2, 3, 4, 5}, []int{}, false},
+	}
+
+	for _, tt := range intTests {
+		assert.Equal(tt.want, ContainAny(tt.slice, tt.targets))
+	}
+}
+
 func TestChunk(t *testing.T) {
 	t.Parallel()

--- a/structs/field.go
+++ b/structs/field.go
@@ -26,26 +26,31 @@ func newField(v reflect.Value, f reflect.StructField, tagName string) *Field {
 }

 // Tag returns the value that the key in the tag string.
+// Play: https://go.dev/play/p/DVrx5HvvUJr
 func (f *Field) Tag() *Tag {
 	return f.tag
 }

 // Value returns the underlying value of the field.
+// Play: https://go.dev/play/p/qufYEU2o4Oi
 func (f *Field) Value() any {
 	return f.rvalue.Interface()
 }

 // IsEmbedded returns true if the given field is an embedded field.
+// Play: https://go.dev/play/p/wV2PrbYm3Ec
 func (f *Field) IsEmbedded() bool {
 	return len(f.field.Index) > 1
 }

 // IsExported returns true if the given field is exported.
+// Play: https://go.dev/play/p/csK4AXYaNbJ
 func (f *Field) IsExported() bool {
 	return f.field.IsExported()
 }

 // IsZero returns true if the given field is zero value.
+// Play: https://go.dev/play/p/RzqpGISf87r
 func (f *Field) IsZero() bool {
 	z := reflect.Zero(f.rvalue.Type()).Interface()
 	v := f.Value()
@@ -63,22 +68,26 @@ func (f *Field) IsNil() bool {
 }

 // Name returns the name of the given field
+// Play: https://go.dev/play/p/zfIGlqsatee
 func (f *Field) Name() string {
 	return f.field.Name
 }

 // Kind returns the field's kind
+// Play: https://go.dev/play/p/wg4NlcUNG5o
 func (f *Field) Kind() reflect.Kind {
 	return f.rvalue.Kind()
 }

 // IsSlice check if a struct field type is slice or not
+// Play: https://go.dev/play/p/MKz4CgBIUrU
 func (f *Field) IsSlice() bool {
 	k := f.rvalue.Kind()
 	return k == reflect.Slice
 }

 // IsTargetType check if a struct field type is target type or not
+// Play: https://go.dev/play/p/Ig75P-agN39
 func (f *Field) IsTargetType(targetType reflect.Kind) bool {
 	return f.rvalue.Kind() == targetType
 }
--- a/structs/struct.go
+++ b/structs/struct.go
@@ -20,6 +20,7 @@ type Struct struct {
 }

 // New returns a new *Struct
+// Play: https://go.dev/play/p/O29l8kk-Z17
 func New(value any, tagName ...string) *Struct {
 	value = pointer.ExtractPointer(value)
 	v := reflect.ValueOf(value)
@@ -60,6 +61,7 @@ func New(value any, tagName ...string) *Struct {
 //	 	Name string `json:"myName"`
 //
 // ToMap convert the exported fields of a struct to map.
+// Play: https://go.dev/play/p/qQbLySBgerZ
 func (s *Struct) ToMap() (map[string]any, error) {
 	if !s.IsStruct() {
 		return nil, fmt.Errorf("invalid struct %v", s)
@@ -87,6 +89,7 @@ func (s *Struct) ToMap() (map[string]any, error) {
 }

 // Fields returns all the struct fields within a slice
+// Play: https://go.dev/play/p/w3Kk_CyVY7D
 func (s *Struct) Fields() []*Field {
 	fieldNum := s.rvalue.NumField()
 	fields := make([]*Field, 0, fieldNum)
@@ -100,6 +103,7 @@ func (s *Struct) Fields() []*Field {
 }

 // Field returns a Field if the given field name was found
+// Play: https://go.dev/play/p/KocZMSYarza
 func (s *Struct) Field(name string) (*Field, bool) {
 	f, ok := s.rtype.FieldByName(name)
 	if !ok {
@@ -109,6 +113,7 @@ func (s *Struct) Field(name string) (*Field, bool) {
 }

 // IsStruct returns true if the given rvalue is a struct
+// Play: https://go.dev/play/p/bU2FSdkbK1C
 func (s *Struct) IsStruct() bool {
 	k := s.rvalue.Kind()
 	if k == reflect.Invalid {
@@ -119,6 +124,13 @@ func (s *Struct) IsStruct() bool {

 // ToMap convert struct to map, only convert exported struct field
 // map key is specified same as struct field tag `json` value.
+// Play: https://go.dev/play/p/qQbLySBgerZ
 func ToMap(v any) (map[string]any, error) {
 	return New(v).ToMap()
 }
+
+// TypeName return struct type name
+// Play: https://go.dev/play/p/todo
+func (s *Struct) TypeName() string {
+	return s.rtype.Name()
+}
--- a/structs/struct_test.go
+++ b/structs/struct_test.go
@@ -177,3 +177,21 @@ func TestStruct_IsStruct(t *testing.T) {
 	assert.Equal(true, s1.IsStruct())
 	assert.Equal(false, s2.IsStruct())
 }
+
+func TestStruct_TypeName(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestStruct_TypeName")
+
+	type Test1 struct{}
+	t1 := &Test1{}
+
+	s1 := New(t1)
+	assert.Equal("Test1", s1.TypeName())
+
+	type Test2 struct{}
+	t2 := Test2{}
+
+	s2 := New(t2)
+	assert.Equal("Test2", s2.TypeName())
+}
--- a/validator/validator.go
+++ b/validator/validator.go
@@ -24,10 +24,8 @@ var (
 	alphaNumericMatcher *regexp.Regexp = regexp.MustCompile(`^[a-zA-Z0-9-]+$`)
 	numberRegexMatcher  *regexp.Regexp = regexp.MustCompile(`\d`)
 	intStrMatcher       *regexp.Regexp = regexp.MustCompile(`^[\+-]?\d+$`)
-	urlMatcher          *regexp.Regexp = regexp.MustCompile(`^((ftp|http|https?):\/\/)?(\S+(:\S*)?@)?((([1-9]\d?|1\d\d|2[01]\d|22[0-3])(\.(1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.([0-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(([a-zA-Z0-9]+([-\.][a-zA-Z0-9]+)*)|((www\.)?))?(([a-z\x{00a1}-\x{ffff}0-9]+-?-?)*[a-z\x{00a1}-\x{ffff}0-9]+)(?:\.([a-z\x{00a1}-\x{ffff}]{2,}))?))(:(\d{1,5}))?((\/|\?|#)[^\s]*)?$`)
-	dnsMatcher          *regexp.Regexp = regexp.MustCompile(`^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$`)
-	// emailMatcher           *regexp.Regexp = regexp.MustCompile(`^[a-z0-9._%+\-]+@[a-z0-9.\-]+\.[a-z]{2,4}$`)
-	emailMatcher             *regexp.Regexp = regexp.MustCompile(`\w+(-+.\w+)*@\w+(-.\w+)*.\w+(-.\w+)*`)
+	// dnsMatcher               *regexp.Regexp = regexp.MustCompile(`^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$`)
+	dnsMatcher               *regexp.Regexp = regexp.MustCompile(`^(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)*(?:xn--[a-zA-Z0-9\-]{1,59}|[a-zA-Z0-9](?:[a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?)$`)
 	chineseMobileMatcher     *regexp.Regexp = regexp.MustCompile(`^1(?:3\d|4[4-9]|5[0-35-9]|6[67]|7[013-8]|8\d|9\d)\d{8}$`)
 	chineseIdMatcher         *regexp.Regexp = regexp.MustCompile(`([1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx])|([1-9]\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{2}[0-9Xx])`)
 	chineseMatcher           *regexp.Regexp = regexp.MustCompile("[\u4e00-\u9fa5]")
@@ -40,7 +38,6 @@ var (
 	visaMatcher              *regexp.Regexp = regexp.MustCompile(`^4[0-9]{12}(?:[0-9]{3})?$`)
 	masterCardMatcher        *regexp.Regexp = regexp.MustCompile(`^5[1-5][0-9]{14}$`)
 	americanExpressMatcher   *regexp.Regexp = regexp.MustCompile(`^3[47][0-9]{13}$`)
-	unionPayMatcher          *regexp.Regexp = regexp.MustCompile(`^62[0-5]\\d{13,16}$`)
 	chinaUnionPayMatcher     *regexp.Regexp = regexp.MustCompile(`^62[0-9]{14,17}$`)
 	chineseHMPassportMatcher *regexp.Regexp = regexp.MustCompile(`^[CM]\d{8}$`)
 )
@@ -635,24 +632,6 @@ func IsChinaUnionPay(cardNo string) bool {
 	return chinaUnionPayMatcher.MatchString(cardNo)
 }

-// luhnCheck checks if the credit card number is valid using the Luhn algorithm.
-func luhnCheck(card string) bool {
-	var sum int
-	alt := false
-	for i := len(card) - 1; i >= 0; i-- {
-		n := int(card[i] - '0')
-		if alt {
-			n *= 2
-			if n > 9 {
-				n -= 9
-			}
-		}
-		sum += n
-		alt = !alt
-	}
-	return sum%10 == 0
-}
-
 // IsPassport checks if the passport number is valid for a given country.
 // country is a two-letter country code (ISO 3166-1 alpha-2).
 // Play: todo
--- a/validator/validator_test.go
+++ b/validator/validator_test.go
@@ -477,7 +477,8 @@ func TestIsDns(t *testing.T) {
 		{"abc.com", true},
 		{"123.cn", true},
 		{"a.b.com", true},
-		{"a.b.c", false},
+		{"a.b.c", true},
+		{"www.xn--6qq986b3xl.xn--fiqs8s.com", true},
 		{"a@b.com", false},
 		{"http://abc.com", false},
 	}
Author	SHA1	Message	Date
dudaodong	5d3964d81a	release v2.3.8	2025-11-01 19:39:46 +08:00
dudaodong	6c3dc3e7d6	Merge branch 'rc' of github.com:duke-git/lancet into rc	2025-10-31 14:59:25 +08:00
dudaodong	2a2e1ca551	doc: add enum and update overview index	2025-10-31 14:57:54 +08:00
dudaodong	e1821eed2c	doc: add docment for enum package	2025-10-31 14:48:32 +08:00
dudaodong	62f0a96d91	doc: add docment for enum package	2025-10-31 14:48:22 +08:00
dudaodong	cbdc3971dd	doc: add docment for new or fixed function	2025-10-31 13:37:41 +08:00
Javen	350450bb67	feat: add ContainAny (#338 ) Co-authored-by: Jiawen <im@linjiawen.com>	2025-10-30 19:24:45 +08:00
dudaodong	f407e51b24	fix: fix issue #335	2025-10-30 17:09:48 +08:00
dudaodong	3c6c3a14cf	Merge branch 'rc' into v2	2025-10-29 21:10:54 +08:00
dudaodong	41bafdef92	refact: remove unused code	2025-10-29 21:10:30 +08:00
wangxc	fc624195c7	feat:add map to markdown conversion in map.go (#336 ) * feat(file): add map to markdown conversion in map.go * feat(file): add map to markdown conversion in map.go	2025-10-29 21:07:18 +08:00
残念	5b3a59e785	Merge pull request #334 from duke-git/v2 Add enum package	2025-10-25 12:32:12 +08:00
chentong	74abb2d3f1	feat(struct): add struct name function (#328 ) * feat(struct): add struct name function - Add Name() method to Struct type to return the struct name - Implement unit tests for the new Name() method * refactor(structs): rename Struct.Name to Struct.TypeName - Rename method Name to TypeName for clarity and accuracy - Update corresponding test cases	2025-10-23 11:20:43 +08:00
dudaodong	3f12b34eea	fix: fix issue for PR #334 , usge Pair struct to instance enum items	2025-10-16 18:43:24 +08:00
dudaodong	cd43004a91	feat: add example for enum package	2025-10-14 16:37:02 +08:00