doc: add doc for CurrentMap

cryptor/basic.go

@@ -40,7 +40,7 @@ func Md5String(s string) string {
 	return hex.EncodeToString(h.Sum(nil))
 }
 
-// Md5String return the md5 value of string.
+// Md5StringWithBase64 return the md5 value of string with base64.
 // Play: https://go.dev/play/p/Lx4gH7Vdr5_y
 func Md5StringWithBase64(s string) string {
 	h := md5.New()
@@ -56,7 +56,7 @@ func Md5Byte(data []byte) string {
 	return hex.EncodeToString(h.Sum(nil))
 }
 
-// Md5Byte return the md5 string of byte slice.
+// Md5ByteWithBase64 return the md5 string of byte slice with base64.
 // Play: https://go.dev/play/p/CkN9hYKGeAy
 func Md5ByteWithBase64(data []byte) string {
 	h := md5.New()
@@ -98,104 +98,104 @@ func Md5File(filename string) (string, error) {
 
 // HmacMd5 return the hmac hash of string use md5.
 // Play: https://go.dev/play/p/uef0q1fz53I
-func HmacMd5(data, key string) string {
+func HmacMd5(str, key string) string {
 	h := hmac.New(md5.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
 // HmacSha1 return the hmac hash of string use sha1.
 // Play: https://go.dev/play/p/1UI4oQ4WXKM
-func HmacSha1(data, key string) string {
+func HmacSha1(str, key string) string {
 	h := hmac.New(sha1.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha1 return the hmac hash of string use sha1.
+// HmacSha1WithBase64 return the hmac hash of string use sha1 with base64.
 // Play: https://go.dev/play/p/47JmmGrnF7B
-func HmacSha1WithBase64(data, key string) string {
+func HmacSha1WithBase64(str, key string) string {
 	h := hmac.New(sha1.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
 }
 
 // HmacSha256 return the hmac hash of string use sha256.
 // Play: https://go.dev/play/p/HhpwXxFhhC0
-func HmacSha256(data, key string) string {
+func HmacSha256(str, key string) string {
 	h := hmac.New(sha256.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha256 return the hmac hash of string use sha256 with base64.
+// HmacSha256WithBase64 return the hmac hash of string use sha256 with base64.
 // Play: https://go.dev/play/p/EKbkUvPTLwO
-func HmacSha256WithBase64(data, key string) string {
+func HmacSha256WithBase64(str, key string) string {
 	h := hmac.New(sha256.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
 }
 
 // HmacSha512 return the hmac hash of string use sha512.
 // Play: https://go.dev/play/p/59Od6m4A0Ud
-func HmacSha512(data, key string) string {
+func HmacSha512(str, key string) string {
 	h := hmac.New(sha512.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha512 return the hmac hash of string use sha512 with base64..
+// HmacSha512WithBase64 return the hmac hash of string use sha512 with base64.
 // Play: https://go.dev/play/p/61wBBOKO-GH
-func HmacSha512WithBase64(data, key string) string {
+func HmacSha512WithBase64(str, key string) string {
 	h := hmac.New(sha512.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
 }
 
 // Sha1 return the sha1 value (SHA-1 hash algorithm) of string.
 // Play: https://go.dev/play/p/_m_uoD1deMT
-func Sha1(data string) string {
+func Sha1(str string) string {
 	sha1 := sha1.New()
-	sha1.Write([]byte(data))
+	sha1.Write([]byte(str))
 	return hex.EncodeToString(sha1.Sum([]byte("")))
 }
 
-// Sha1 return the sha1 value (SHA-1 hash algorithm) of base64 string.
+// Sha1WithBase64 return the sha1 value (SHA-1 hash algorithm) of base64 string.
 // Play: todo
-func Sha1WithBase64(data string) string {
+func Sha1WithBase64(str string) string {
 	sha1 := sha1.New()
-	sha1.Write([]byte(data))
+	sha1.Write([]byte(str))
 	return base64.StdEncoding.EncodeToString(sha1.Sum([]byte("")))
 }
 
 // Sha256 return the sha256 value (SHA256 hash algorithm) of string.
 // Play: https://go.dev/play/p/tU9tfBMIAr1
-func Sha256(data string) string {
+func Sha256(str string) string {
 	sha256 := sha256.New()
-	sha256.Write([]byte(data))
+	sha256.Write([]byte(str))
 	return hex.EncodeToString(sha256.Sum([]byte("")))
 }
 
-// Sha256 return the sha256 value (SHA256 hash algorithm) of base64 string.
+// Sha256WithBase64 return the sha256 value (SHA256 hash algorithm) of base64 string.
 // Play: https://go.dev/play/p/85IXJHIal1k
-func Sha256WithBase64(data string) string {
+func Sha256WithBase64(str string) string {
 	sha256 := sha256.New()
-	sha256.Write([]byte(data))
+	sha256.Write([]byte(str))
 	return base64.StdEncoding.EncodeToString(sha256.Sum([]byte("")))
 }
 
 // Sha512 return the sha512 value (SHA512 hash algorithm) of string.
 // Play: https://go.dev/play/p/3WsvLYZxsHa
-func Sha512(data string) string {
+func Sha512(str string) string {
 	sha512 := sha512.New()
-	sha512.Write([]byte(data))
+	sha512.Write([]byte(str))
 	return hex.EncodeToString(sha512.Sum([]byte("")))
 }
 
-// Sha512 return the sha512 value (SHA512 hash algorithm) of base64 string.
+// Sha512WithBase64 return the sha512 value (SHA512 hash algorithm) of base64 string.
 // Play: https://go.dev/play/p/q_fY2rA-k5I
-func Sha512WithBase64(data string) string {
+func Sha512WithBase64(str string) string {
 	sha512 := sha512.New()
-	sha512.Write([]byte(data))
+	sha512.Write([]byte(str))
 	return base64.StdEncoding.EncodeToString(sha512.Sum([]byte("")))
 }

docs/cryptor.md

@@ -45,14 +45,22 @@ import (
 - [DesOfbDecrypt](#DesOfbDecrypt)
 - [HmacMd5](#HmacMd5)
 - [HmacSha1](#HmacSha1)
+- [HmacSha1WithBase64](#HmacSha1WithBase64)
 - [HmacSha256](#HmacSha256)
+- [HmacSha256WithBase64](#HmacSha256WithBase64)
 - [HmacSha512](#HmacSha512)
+- [HmacSha512WithBase64](#HmacSha512WithBase64)
 - [Md5String](#Md5String)
+- [Md5StringWithBase64](#Md5StringWithBase64)
 - [Md5Byte](#Md5Byte)
+- [Md5ByteWithBase64](#Md5ByteWithBase64)
 - [Md5File](#Md5File)
 - [Sha1](#Sha1)
+- [Sha1WithBase64](#Sha1WithBase64)
 - [Sha256](#Sha256)
+- [Sha256WithBase64](#Sha256WithBase64)
 - [Sha512](#Sha512)
+- [Sha512WithBase64](#Sha512WithBase64)
 - [GenerateRsaKey](#GenerateRsaKey)
 - [RsaEncrypt](#RsaEncrypt)
 - [RsaDecrypt](#RsaDecrypt)
@@ -761,7 +769,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func HmacSha1(data, key string) string
+func HmacSha1(str, key string) string
 ```
 
 <b>Example:</b>
@@ -785,6 +793,39 @@ func main() {
     // 5c6a9db0cccb92e36ed0323fd09b7f936de9ace0
 }
 ```
+
+### <span id="HmacSha1WithBase64">HmacSha1WithBase64</span>
+
+<p>Return the hmac hash of string use sha1 with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func HmacSha1WithBase64(str, key string) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+    key := "12345"
+
+    hms := cryptor.HmacSha1WithBase64(str, key)
+    fmt.Println(hms)
+
+    // Output:
+    // XGqdsMzLkuNu0DI/0Jt/k23prOA=
+}
+```
+
 ### <span id="HmacSha256">HmacSha256</span>
 
 <p>Get the sha256 hmac hash of string</p>
@@ -792,7 +833,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func HmacSha256(data, key string) string
+func HmacSha256(str, key string) string
 ```
 
 <b>Example:</b>
@@ -817,6 +858,38 @@ func main() {
 }
 ```
 
+### <span id="HmacSha256WithBase64">HmacSha256WithBase64</span>
+
+<p>Return the hmac hash of string use sha256 with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func HmacSha256WithBase64(str, key string) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+    key := "12345"
+
+    hms := cryptor.HmacSha256WithBase64(str, key)
+    fmt.Println(hms)
+
+    // Output:
+    // MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU=
+}
+```
+
 ### <span id="HmacSha512">HmacSha512</span>
 
 <p>Get the sha512 hmac hash of string.</p>
@@ -824,7 +897,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func HmacSha512(data, key string) string
+func HmacSha512(str, key string) string
 ```
 
 <b>Example:</b>
@@ -849,6 +922,38 @@ func main() {
 }
 ```
 
+### <span id="HmacSha512WithBase64">HmacSha512WithBase64</span>
+
+<p>Return the hmac hash of string use sha512 with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func HmacSha512WithBase64(str, key string) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+	key := "12345"
+
+	hms := cryptor.HmacSha512WithBase64(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
+}
+```
+
 
 ### <span id="Md5String">Md5String</span>
 
@@ -881,6 +986,35 @@ func main() {
 }
 ```
 
+### <span id="Md5StringWithBase64">Md5StringWithBase64</span>
+
+<p>Return the md5 value of string with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func Md5StringWithBase64(s string) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    md5Str := cryptor.Md5StringWithBase64("hello")
+	fmt.Println(md5Str)
+
+	// Output:
+	// XUFAKrxLKna5cZ2REBfFkg==
+}
+```
+
 ### <span id="Md5Byte">Md5Byte</span>
 
 <p>Return the md5 string of byte slice.</p>
@@ -910,6 +1044,35 @@ func main() {
 }
 ```
 
+### <span id="Md5ByteWithBase64">Md5ByteWithBase64</span>
+
+<p>Return the md5 string of byte slice with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func Md5ByteWithBase64(data []byte) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    md5Str := cryptor.Md5ByteWithBase64([]byte("hello"))
+	fmt.Println(md5Str)
+
+	// Output:
+	// XUFAKrxLKna5cZ2REBfFkg==
+}
+```
+
 ### <span id="Md5File">Md5File</span>
 
 <p>Get the md5 value of file.</p>
@@ -943,7 +1106,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func Sha1(data string) string
+func Sha1(str string) string
 ```
 
 <b>Example:</b>
@@ -967,6 +1130,35 @@ func main() {
 }
 ```
 
+### <span id="Sha1WithBase64">Sha1WithBase64</span>
+
+<p>Return the sha1 value (SHA-1 hash algorithm) of base64 string.</p>
+
+<b>Signature:</b>
+
+```go
+func Sha1WithBase64(str string) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha1WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
+}
+```
+
 ### <span id="Sha256">Sha256</span>
 
 <p>Get the sha256 value of string.</p>
@@ -974,7 +1166,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func Sha256(data string) string
+func Sha256(str string) string
 ```
 
 <b>Example:</b>
@@ -998,6 +1190,35 @@ func main() {
 }
 ```
 
+### <span id="Sha256WithBase64">Sha256WithBase64</span>
+
+<p>Return the sha256 value (SHA256 hash algorithm) of base64 string.</p>
+
+<b>Signature:</b>
+
+```go
+func Sha256WithBase64(str string) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha256WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
+}
+```
+
 ### <span id="Sha512">Sha512</span>
 
 <p>Get the sha512 value of string.</p>
@@ -1005,7 +1226,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func Sha512(data string) string
+func Sha512(str string) string
 ```
 
 <b>Example:</b>
@@ -1029,6 +1250,35 @@ func main() {
 }
 ```
 
+### <span id="Sha512WithBase64">Sha512WithBase64</span>
+
+<p>Get the sha512 value of string with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func Sha512WithBase64(str string) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha512WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
+}
+```
+
 ### <span id="GenerateRsaKey">GenerateRsaKey</span>
 
 <p>Create the rsa public and private key file in current directory.</p>

docs/cryptor_zh-CN.md

@@ -42,14 +42,22 @@ import (
 - [DesOfbDecrypt](#DesOfbDecrypt)
 - [HmacMd5](#HmacMd5)
 - [HmacSha1](#HmacSha1)
+- [HmacSha1WithBase64](#HmacSha1WithBase64)
 - [HmacSha256](#HmacSha256)
+- [HmacSha256WithBase64](#HmacSha256WithBase64)
 - [HmacSha512](#HmacSha512)
+- [HmacSha512WithBase64](#HmacSha512WithBase64)
 - [Md5String](#Md5String)
+- [Md5StringWithBase64](#Md5StringWithBase64)
 - [Md5Byte](#Md5Byte)
+- [Md5ByteWithBase64](#Md5ByteWithBase64)
 - [Md5File](#Md5File)
 - [Sha1](#Sha1)
+- [Sha1WithBase64](#Sha1WithBase64)
 - [Sha256](#Sha256)
+- [Sha256WithBase64](#Sha256WithBase64)
 - [Sha512](#Sha512)
+- [Sha512WithBase64](#Sha512WithBase64)
 - [GenerateRsaKey](#GenerateRsaKey)
 - [RsaEncrypt](#RsaEncrypt)
 - [RsaDecrypt](#RsaDecrypt)
@@ -755,12 +763,12 @@ func main() {
 ```
 ### <span id="HmacSha1">HmacSha1</span>
 
-<p>获取字符串sha1 hmac值。</p>
+<p>获取字符串的sha1 hmac值。</p>
 
 <b>函数签名:</b>
 
 ```go
-func HmacSha1(data, key string) string
+func HmacSha1(str, key string) string
 ```
 
 <b>示例:</b>
@@ -784,6 +792,40 @@ func main() {
     // 5c6a9db0cccb92e36ed0323fd09b7f936de9ace0
 }
 ```
+
+### <span id="HmacSha1WithBase64">HmacSha1WithBase64</span>
+
+<p>获取字符串的sha1 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func HmacSha1WithBase64(str, key string) string
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+    key := "12345"
+
+    hms := cryptor.HmacSha1WithBase64(str, key)
+    fmt.Println(hms)
+
+    // Output:
+    // XGqdsMzLkuNu0DI/0Jt/k23prOA=
+}
+```
+
+
 ### <span id="HmacSha256">HmacSha256</span>
 
 <p>获取字符串sha256 hmac值。</p>
@@ -791,7 +833,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func HmacSha256(data, key string) string
+func HmacSha256(str, key string) string
 ```
 
 <b>示例:</b>
@@ -816,6 +858,38 @@ func main() {
 }
 ```
 
+### <span id="HmacSha256WithBase64">HmacSha256WithBase64</span>
+
+<p>获取字符串sha256 hmac base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func HmacSha256WithBase64(str, key string) string
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+    key := "12345"
+
+    hms := cryptor.HmacSha256WithBase64(str, key)
+    fmt.Println(hms)
+
+    // Output:
+    // MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU=
+}
+```
+
 ### <span id="HmacSha512">HmacSha512</span>
 
 <p>获取字符串sha512 hmac值。</p>
@@ -823,7 +897,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func HmacSha512(data, key string) string
+func HmacSha512(str, key string) string
 ```
 
 <b>示例:</b>
@@ -848,6 +922,38 @@ func main() {
 }
 ```
 
+### <span id="HmacSha512WithBase64">HmacSha512WithBase64</span>
+
+<p>获取字符串sha512 hmac base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func HmacSha512WithBase64(str, key string) string
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+	key := "12345"
+
+	hms := cryptor.HmacSha512WithBase64(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
+}
+```
+
 
 ### <span id="Md5String">Md5String</span>
 
@@ -856,7 +962,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func Md5String(s string) string
+func Md5String(str string) string
 ```
 
 <b>示例:</b>
@@ -880,9 +986,38 @@ func main() {
 }
 ```
 
+### <span id="Md5StringWithBase64">Md5StringWithBase64</span>
+
+<p>获取字符串md5 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Md5StringWithBase64(s string) string
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    md5Str := cryptor.Md5StringWithBase64("hello")
+	fmt.Println(md5Str)
+
+	// Output:
+	// XUFAKrxLKna5cZ2REBfFkg==
+}
+```
+
 ### <span id="Md5Byte">Md5Byte</span>
 
-<p>获取byte slice的md5至。</p>
+<p>获取byte slice的md5值。</p>
 
 <b>函数签名:</b>
 
@@ -909,6 +1044,35 @@ func main() {
 }
 ```
 
+### <span id="Md5ByteWithBase64">Md5ByteWithBase64</span>
+
+<p>获取byte slice的md5 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Md5ByteWithBase64(data []byte) string
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    md5Str := cryptor.Md5ByteWithBase64([]byte("hello"))
+	fmt.Println(md5Str)
+
+	// Output:
+	// XUFAKrxLKna5cZ2REBfFkg==
+}
+```
+
 ### <span id="Md5File">Md5File</span>
 
 <p>获取文件md5值。</p>
@@ -942,7 +1106,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func Sha1(data string) string
+func Sha1(str string) string
 ```
 
 <b>示例:</b>
@@ -966,6 +1130,35 @@ func main() {
 }
 ```
 
+### <span id="Sha1WithBase64">Sha1WithBase64</span>
+
+<p>获取字符串sha1 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Sha1WithBase64(str string) string
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha1WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
+}
+```
+
 ### <span id="Sha256">Sha256</span>
 
 <p>获取字符串sha256值。</p>
@@ -973,7 +1166,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func Sha256(data string) string
+func Sha256(str string) string
 ```
 
 <b>示例:</b>
@@ -997,6 +1190,35 @@ func main() {
 }
 ```
 
+### <span id="Sha256WithBase64">Sha256WithBase64</span>
+
+<p>获取字符串sha256 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Sha256WithBase64(str string) string
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha256WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
+}
+```
+
 ### <span id="Sha512">Sha512</span>
 
 <p>获取字符串sha512值。</p>
@@ -1004,7 +1226,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func Sha512(data string) string
+func Sha512(str string) string
 ```
 
 <b>示例:</b>
@@ -1028,6 +1250,35 @@ func main() {
 }
 ```
 
+### <span id="Sha512WithBase64">Sha512WithBase64</span>
+
+<p>获取字符串sha512 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Sha512WithBase64(str string) string
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha512WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
+}
+```
+
 ### <span id="GenerateRsaKey">GenerateRsaKey</span>
 
 <p>在当前目录下创建rsa私钥文件和公钥文件。</p>

docs/maputil.md

@@ -44,12 +44,19 @@ import (
 -   [Minus](#Minus)
 -   [IsDisjoint](#IsDisjoint)
 -   [HasKey](#HasKey)
+-   [NewConcurrentMap](#NewConcurrentMap)
+-   [ConcurrentMap_Get](#ConcurrentMap_Get)
+-   [ConcurrentMap_Set](#ConcurrentMap_Set)
+-   [ConcurrentMap_GetOrSet](#ConcurrentMap_GetOrSet)
+-   [ConcurrentMap_Delete](#ConcurrentMap_Delete)
+-   [ConcurrentMap_GetAndDelete](#ConcurrentMap_GetAndDelete)
+-   [ConcurrentMap_Has](#ConcurrentMap_Has)
+-   [ConcurrentMap_Range](#ConcurrentMap_Range)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
-
 ### <span id="MapTo">MapTo</span>
 
 <p>Rry to map any interface to struct or base type.</p>
@@ -984,3 +991,356 @@ func main() {
     // false
 }
 ```
+
+### <span id="NewConcurrentMap">NewConcurrentMap</span>
+
+<p>ConcurrentMap is like map, but is safe for concurrent use by multiple goroutines.</p>
+
+<b>Signature:</b>
+
+```go
+// NewConcurrentMap create a ConcurrentMap with specific shard count.
+func NewConcurrentMap[K comparable, V any](shardCount int) *ConcurrentMap[K, V]
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    // create a ConcurrentMap whose key type is string, value type is int
+    cm := maputil.NewConcurrentMap[string, int](100)
+}
+```
+
+### <span id="ConcurrentMap_Set">ConcurrentMap_Set</span>
+
+<p>Set the value for a key.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Set(key K, value V)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            val, ok := cm.Get(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok)
+        }(j)
+    }
+
+    // output: (order may change)
+    // 1 true
+    // 3 true
+    // 2 true
+    // 0 true
+    // 4 true
+}
+```
+
+### <span id="ConcurrentMap_Get">ConcurrentMap_Get</span>
+
+<p>Get the value stored in the map for a key, or nil if no.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Get(key K) (V, bool)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            val, ok := cm.Get(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok)
+        }(j)
+    }
+
+    // output: (order may change)
+    // 1 true
+    // 3 true
+    // 2 true
+    // 0 true
+    // 4 true
+}
+```
+
+### <span id="ConcurrentMap_GetOrSet">ConcurrentMap_GetOrSet</span>
+
+<p>Returns the existing value for the key if present. Otherwise, it sets and returns the given value.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) GetOrSet(key K, value V) (actual V, ok bool)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg sync.WaitGroup
+    wg.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            val, ok := cm.GetOrSet(fmt.Sprintf("%d", n), n)
+            fmt.Println(val, ok)
+            wg.Done()
+        }(i)
+    }
+    wg.Wait()
+
+    // output: (order may change)
+    // 1 false
+    // 3 false
+    // 2 false
+    // 0 false
+    // 4 false
+}
+```
+
+### <span id="ConcurrentMap_Delete">ConcurrentMap_Delete</span>
+
+<p>Delete the value for a key.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Delete(key K)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            cm.Delete(fmt.Sprintf("%d", n))
+            wg2.Done()
+        }(i)
+    }
+}
+```
+
+
+### <span id="ConcurrentMap_GetAndDelete">ConcurrentMap_GetAndDelete</span>
+
+<p>Returns the existing value for the key if present and then delete the value for the key. Otherwise, do nothing, just return false.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) GetAndDelete(key K) (actual V, ok bool)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            val, ok := cm.GetAndDelete(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok) //n, true
+
+            _, ok = cm.Get(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok) //false
+        }(j)
+    }
+}
+```
+
+
+### <span id="ConcurrentMap_Has">ConcurrentMap_Has</span>
+
+<p>Checks if map has the value for a key.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Has(key K) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            ok := cm.Has(fmt.Sprintf("%d", n))
+            fmt.Println(ok) // true
+        }(j)
+    }
+}
+```
+
+
+### <span id="ConcurrentMap_Range">ConcurrentMap_Range</span>
+
+<p>Calls iterator sequentially for each key and value present in each of the shards in the map. If iterator returns false, range stops the iteration.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Range(iterator func(key K, value V) bool)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    cm.Range(func(key string, value int) bool {
+        fmt.Println(value)
+        return true
+    })
+}
+```

docs/maputil_zh-CN.md

@@ -44,6 +44,15 @@ import (
 -   [Minus](#Minus)
 -   [IsDisjoint](#IsDisjoint)
 -   [HasKey](#HasKey)
+-   [NewConcurrentMap](#NewConcurrentMap)
+-   [ConcurrentMap_Get](#ConcurrentMap_Get)
+-   [ConcurrentMap_Set](#ConcurrentMap_Set)
+-   [ConcurrentMap_GetOrSet](#ConcurrentMap_GetOrSet)
+-   [ConcurrentMap_Delete](#ConcurrentMap_Delete)
+-   [ConcurrentMap_GetAndDelete](#ConcurrentMap_GetAndDelete)
+-   [ConcurrentMap_Has](#ConcurrentMap_Has)
+-   [ConcurrentMap_Range](#ConcurrentMap_Range)
+
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -979,3 +988,357 @@ func main() {
     // false
 }
 ```
+
+### <span id="NewConcurrentMap">NewConcurrentMap</span>
+
+<p>ConcurrentMap协程安全的map结构。</p>
+
+<b>函数签名:</b>
+
+```go
+// NewConcurrentMap create a ConcurrentMap with specific shard count.
+func NewConcurrentMap[K comparable, V any](shardCount int) *ConcurrentMap[K, V]
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    // create a ConcurrentMap whose key type is string, value type is int
+    cm := maputil.NewConcurrentMap[string, int](100)
+}
+```
+
+### <span id="ConcurrentMap_Set">ConcurrentMap_Set</span>
+
+<p>在map中设置key和value。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Set(key K, value V)
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            val, ok := cm.Get(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok)
+        }(j)
+    }
+
+    // output: (order may change)
+    // 1 true
+    // 3 true
+    // 2 true
+    // 0 true
+    // 4 true
+}
+```
+
+### <span id="ConcurrentMap_Get">ConcurrentMap_Get</span>
+
+<p>根据key获取value, 如果不存在key,返回零值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Get(key K) (V, bool)
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            val, ok := cm.Get(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok)
+        }(j)
+    }
+
+    // output: (order may change)
+    // 1 true
+    // 3 true
+    // 2 true
+    // 0 true
+    // 4 true
+}
+```
+
+### <span id="ConcurrentMap_GetOrSet">ConcurrentMap_GetOrSet</span>
+
+<p>返回键的现有值（如果存在），否则，设置key并返回给定值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) GetOrSet(key K, value V) (actual V, ok bool)
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg sync.WaitGroup
+    wg.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            val, ok := cm.GetOrSet(fmt.Sprintf("%d", n), n)
+            fmt.Println(val, ok)
+            wg.Done()
+        }(i)
+    }
+    wg.Wait()
+
+    // output: (order may change)
+    // 1 false
+    // 3 false
+    // 2 false
+    // 0 false
+    // 4 false
+}
+```
+
+### <span id="ConcurrentMap_Delete">ConcurrentMap_Delete</span>
+
+<p>删除key。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Delete(key K)
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            cm.Delete(fmt.Sprintf("%d", n))
+            wg2.Done()
+        }(i)
+    }
+}
+```
+
+
+### <span id="ConcurrentMap_GetAndDelete">ConcurrentMap_GetAndDelete</span>
+
+<p>获取key，然后删除。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) GetAndDelete(key K) (actual V, ok bool)
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            val, ok := cm.GetAndDelete(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok) //n, true
+
+            _, ok = cm.Get(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok) //false
+        }(j)
+    }
+}
+```
+
+
+### <span id="ConcurrentMap_Has">ConcurrentMap_Has</span>
+
+<p>验证是否包含key。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Has(key K) bool
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            ok := cm.Has(fmt.Sprintf("%d", n))
+            fmt.Println(ok) // true
+        }(j)
+    }
+}
+```
+
+
+### <span id="ConcurrentMap_Range">ConcurrentMap_Range</span>
+
+<p>为map中每个键和值顺序调用迭代器。 如果iterator返回false，则停止迭代。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Range(iterator func(key K, value V) bool)
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    cm.Range(func(key string, value int) bool {
+        fmt.Println(value)
+        return true
+    })
+}
+```
+

maputil/concurrentmap_test.go

@@ -24,17 +24,13 @@ func TestConcurrentMap_Set_Get(t *testing.T) {
 	}
 	wg1.Wait()
 
-	var wg2 sync.WaitGroup
-	wg2.Add(10)
 	for j := 0; j < 10; j++ {
 		go func(n int) {
 			val, ok := cm.Get(fmt.Sprintf("%d", n))
 			assert.Equal(n, val)
 			assert.Equal(true, ok)
-			wg2.Done()
 		}(j)
 	}
-	wg2.Wait()
 }
 
 func TestConcurrentMap_GetOrSet(t *testing.T) {
@@ -121,3 +117,49 @@ func TestConcurrentMap_GetAndDelete(t *testing.T) {
 		}(j)
 	}
 }
+
+func TestConcurrentMap_Has(t *testing.T) {
+	assert := internal.NewAssert(t, "TestConcurrentMap_Has")
+
+	cm := NewConcurrentMap[string, int](100)
+
+	var wg1 sync.WaitGroup
+	wg1.Add(10)
+
+	for i := 0; i < 10; i++ {
+		go func(n int) {
+			cm.Set(fmt.Sprintf("%d", n), n)
+			wg1.Done()
+		}(i)
+	}
+	wg1.Wait()
+
+	for j := 0; j < 10; j++ {
+		go func(n int) {
+			ok := cm.Has(fmt.Sprintf("%d", n))
+			assert.Equal(true, ok)
+		}(j)
+	}
+}
+
+func TestConcurrentMap_Range(t *testing.T) {
+	assert := internal.NewAssert(t, "TestConcurrentMap_Range")
+
+	cm := NewConcurrentMap[string, int](100)
+
+	var wg1 sync.WaitGroup
+	wg1.Add(10)
+
+	for i := 0; i < 10; i++ {
+		go func(n int) {
+			cm.Set(fmt.Sprintf("%d", n), n)
+			wg1.Done()
+		}(i)
+	}
+	wg1.Wait()
+
+	cm.Range(func(key string, value int) bool {
+		assert.Equal(key, fmt.Sprintf("%d", value))
+		return true
+	})
+}