diff --git a/text/gstr/gstr_z_all_example_test.go b/text/gstr/gstr_z_all_example_test.go
index ce97e2c69..cfb05c8d9 100644
--- a/text/gstr/gstr_z_all_example_test.go
+++ b/text/gstr/gstr_z_all_example_test.go
@@ -7,9 +7,11 @@ import (
 )
 
 func ExampleAddSlashes() {
-	var str string
-	str = `'aa'"bb"cc\r\n\d\t`
-	rsStr := gstr.AddSlashes(str)
+	var (
+		str   = `'aa'"bb"cc\r\n\d\t`
+		rsStr = gstr.AddSlashes(str)
+	)
+
 	fmt.Println(rsStr)
 
 	// Output:
@@ -28,9 +30,11 @@ func ExampleCaseCamel() {
 }
 
 func ExampleCaseCamelLower() {
-	var str string
-	str = `goframe_is very nice.to-use`
-	rsStr := gstr.CaseCamelLower(str)
+	var (
+		str   = `goframe_is very nice.to-use`
+		rsStr = gstr.CaseCamelLower(str)
+	)
+
 	fmt.Println(rsStr)
 
 	// Output:
@@ -38,11 +42,11 @@ func ExampleCaseCamelLower() {
 }
 
 func ExampleCaseDelimited() {
-	var str string
-	var del uint8
-	str = `goframe_is_very-nice.to-use`
-	del = 35
-	rsStr := gstr.CaseDelimited(str, del)
+	var (
+		str   = `goframe_is_very-nice.to-use`
+		del   = uint8(35)
+		rsStr = gstr.CaseDelimited(str, del)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -50,23 +54,34 @@ func ExampleCaseDelimited() {
 }
 
 func ExampleCaseDelimitedScreaming() {
-	var str string
-	var del uint8
-	var screaming bool
-	str = `goframe_is Very Nice.to-use`
-	del = 35
-	screaming = true
-	rsStr := gstr.CaseDelimitedScreaming(str, del, screaming)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `goframe_is Very Nice.to-use`
+			del   = uint8(35)
+			rsStr = gstr.CaseDelimitedScreaming(str, del, true)
+		)
+		fmt.Println(rsStr)
+	}
+
+	{
+		var (
+			str   = `GOFRAME_IS VERY NICE.TO-USE`
+			del   = uint8(35)
+			rsStr = gstr.CaseDelimitedScreaming(str, del, false)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// GOFRAME#IS#VERY#NICE#TO#USE
+	// goframe#is#very#nice#to#use
 }
 
 func ExampleCaseKebab() {
-	var str string
-	str = `goframe_is Very Nice.to-use`
-	rsStr := gstr.CaseKebab(str)
+	var (
+		str   = `goframe_is Very Nice.to-use`
+		rsStr = gstr.CaseKebab(str)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -74,9 +89,10 @@ func ExampleCaseKebab() {
 }
 
 func ExampleCaseKebabScreaming() {
-	var str string
-	str = `goframe_is Very Nice.to-use`
-	rsStr := gstr.CaseKebabScreaming(str)
+	var (
+		str   = `goframe_is Very Nice.to-use`
+		rsStr = gstr.CaseKebabScreaming(str)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -84,9 +100,11 @@ func ExampleCaseKebabScreaming() {
 }
 
 func ExampleCaseSnake() {
-	var str string
-	str = `goframe_is Very Nice.to-use`
-	rsStr := gstr.CaseSnake(str)
+	var (
+		str   = `goframe_is Very Nice.to-use`
+		rsStr = gstr.CaseSnake(str)
+	)
+
 	fmt.Println(rsStr)
 
 	// Output:
@@ -94,9 +112,11 @@ func ExampleCaseSnake() {
 }
 
 func ExampleCaseSnakeFirstUpper() {
-	var str string
-	str = `GoframeIsVeryNiceToUse`
-	rsStr := gstr.CaseSnakeFirstUpper(str)
+	var (
+		str   = `GoframeIsVeryNiceToUse`
+		rsStr = gstr.CaseSnakeFirstUpper(str)
+	)
+
 	fmt.Println(rsStr)
 
 	// Output:
@@ -104,9 +124,11 @@ func ExampleCaseSnakeFirstUpper() {
 }
 
 func ExampleCaseSnakeScreaming() {
-	var str string
-	str = `goframe_is Very Nice.to-use`
-	rsStr := gstr.CaseSnakeScreaming(str)
+	var (
+		str   = `goframe_is Very Nice.to-use`
+		rsStr = gstr.CaseSnakeScreaming(str)
+	)
+
 	fmt.Println(rsStr)
 
 	// Output:
@@ -114,9 +136,10 @@ func ExampleCaseSnakeScreaming() {
 }
 
 func ExampleChr() {
-	var ascii int
-	ascii = 65
-	rsStr := gstr.Chr(ascii)
+	var (
+		ascii = 65
+		rsStr = gstr.Chr(ascii)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -124,26 +147,36 @@ func ExampleChr() {
 }
 
 func ExampleChunkSplit() {
-	var body string
-	var chunkLen int
-	var end string
-	body = `1234`
-	chunkLen = 2
-	end = "#"
-	rsStr := gstr.ChunkSplit(body, chunkLen, end)
-	fmt.Println(rsStr)
+	{
+		var (
+			body     = `1234`
+			chunkLen = 2
+			end      = "#"
+			rsStr    = gstr.ChunkSplit(body, chunkLen, end)
+		)
 
-	body = `我爱Goframe`
-	chunkLen = 1
-	end = "-"
-	rsStr = gstr.ChunkSplit(body, chunkLen, end)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	body = `1234`
-	chunkLen = 1
-	end = ""
-	rsStr = gstr.ChunkSplit(body, chunkLen, end)
-	fmt.Println(rsStr)
+	{
+		var (
+			body     = `我爱Goframe`
+			chunkLen = 1
+			end      = "-"
+			rsStr    = gstr.ChunkSplit(body, chunkLen, end)
+		)
+		fmt.Println(rsStr)
+	}
+
+	{
+		var (
+			body     = `1234`
+			chunkLen = 1
+			end      = ""
+			rsStr    = gstr.ChunkSplit(body, chunkLen, end)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// May Output:
 	// 12#34#
@@ -152,23 +185,33 @@ func ExampleChunkSplit() {
 }
 
 func ExampleCompare() {
-	var a string
-	var b string
+	{
+		var (
+			a     = "C"
+			b     = "C"
+			rsStr = gstr.Compare(a, b)
+		)
 
-	a = "C"
-	b = "C"
-	rsStr := gstr.Compare(a, b)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	a = "A"
-	b = "B"
-	rsStr = gstr.Compare(a, b)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = "A"
+			b     = "B"
+			rsStr = gstr.Compare(a, b)
+		)
+		fmt.Println(rsStr)
+	}
 
-	a = "C"
-	b = "B"
-	rsStr = gstr.Compare(a, b)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = "C"
+			b     = "B"
+			rsStr = gstr.Compare(a, b)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 0
@@ -177,24 +220,34 @@ func ExampleCompare() {
 }
 
 func ExampleCompareVersion() {
-	var a string
-	var b string
+	{
+		var (
+			a = "v2.11.9"
+			b = "v2.10.8"
 
-	a = "v2.11.9"
-	b = "v2.10.8"
+			rsStr = gstr.CompareVersion(a, b)
+		)
 
-	rsStr := gstr.CompareVersion(a, b)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	a = "A.10.8"
-	b = "A.19.7"
-	rsStr = gstr.CompareVersion(a, b)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = "A.10.8"
+			b     = "A.19.7"
+			rsStr = gstr.CompareVersion(a, b)
+		)
+		fmt.Println(rsStr)
+	}
 
-	a = "2.8.beta"
-	b = "2.8"
-	rsStr = gstr.CompareVersion(a, b)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = "2.8.beta"
+			b     = "2.8"
+			rsStr = gstr.CompareVersion(a, b)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 1
@@ -203,23 +256,33 @@ func ExampleCompareVersion() {
 }
 
 func ExampleCompareVersionGo() {
-	var a string
-	var b string
 
-	a = "v2.11.9"
-	b = "v2.10.8"
-	rsStr := gstr.CompareVersionGo(a, b)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = "v2.11.9"
+			b     = "v2.10.8"
+			rsStr = gstr.CompareVersionGo(a, b)
+		)
+		fmt.Println(rsStr)
+	}
 
-	a = "v0.0.2-20180626092158-b2ccc119800e"
-	b = "v1.0.1-20190626092158-b2ccc519800e"
-	rsStr = gstr.CompareVersionGo(a, b)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = "v0.0.2-20180626092158-b2ccc119800e"
+			b     = "v1.0.1-20190626092158-b2ccc519800e"
+			rsStr = gstr.CompareVersionGo(a, b)
+		)
+		fmt.Println(rsStr)
+	}
 
-	a = "v4.20.1"
-	b = "v4.20.1+incompatible"
-	rsStr = gstr.CompareVersionGo(a, b)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = "v4.20.1"
+			b     = "v4.20.1+incompatible"
+			rsStr = gstr.CompareVersionGo(a, b)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 1
@@ -228,15 +291,24 @@ func ExampleCompareVersionGo() {
 }
 
 func ExampleContains() {
-	var str, substr string
-	str = `goframe_is Very Nice.to-use`
-	substr = `goframe`
-	rsStr := gstr.Contains(str, substr)
-	fmt.Println(rsStr)
+	{
+		var (
+			str    = `goframe_is Very Nice.to-use`
+			substr = `goframe`
+			rsStr  = gstr.Contains(str, substr)
+		)
 
-	substr = `Goframe`
-	rsStr = gstr.Contains(str, substr)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
+
+	{
+		var (
+			str    = `goframe_is Very Nice.to-use`
+			substr = `Goframe`
+			rsStr  = gstr.Contains(str, substr)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// true
@@ -244,19 +316,33 @@ func ExampleContains() {
 }
 
 func ExampleContainsAny() {
-	var s, chars string
-	s = `goframe_is Very Nice.to-use`
-	chars = "g"
-	rsStr := gstr.ContainsAny(s, chars)
-	fmt.Println(rsStr)
+	{
+		var (
+			s     = `goframe_is Very Nice.to-use`
+			chars = "g"
+			rsStr = gstr.ContainsAny(s, chars)
+		)
 
-	chars = "G"
-	rsStr = gstr.ContainsAny(s, chars)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	chars = "Nice"
-	rsStr = gstr.ContainsAny(s, chars)
-	fmt.Println(rsStr)
+	{
+		var (
+			s     = `goframe_is Very Nice.to-use`
+			chars = "G"
+			rsStr = gstr.ContainsAny(s, chars)
+		)
+		fmt.Println(rsStr)
+	}
+
+	{
+		var (
+			s     = `goframe_is Very Nice.to-use`
+			chars = "Nice"
+			rsStr = gstr.ContainsAny(s, chars)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// true
@@ -265,20 +351,33 @@ func ExampleContainsAny() {
 }
 
 func ExampleContainsI() {
-	var str, substr string
-	str = `goframe_is Very Nice.to-use`
+	{
+		var (
+			str    = `goframe_is Very Nice.to-use`
+			substr = "go"
+			rsStr  = gstr.ContainsI(str, substr)
+		)
 
-	substr = "go"
-	rsStr := gstr.ContainsI(str, substr)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	substr = "Go"
-	rsStr = gstr.ContainsI(str, substr)
-	fmt.Println(rsStr)
+	{
+		var (
+			str    = `goframe_is Very Nice.to-use`
+			substr = "Go"
+			rsStr  = gstr.ContainsI(str, substr)
+		)
+		fmt.Println(rsStr)
+	}
 
-	substr = "Golang"
-	rsStr = gstr.ContainsI(str, substr)
-	fmt.Println(rsStr)
+	{
+		var (
+			str    = `goframe_is Very Nice.to-use`
+			substr = "Golang"
+			rsStr  = gstr.ContainsI(str, substr)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// true
@@ -287,16 +386,23 @@ func ExampleContainsI() {
 }
 
 func ExampleCount() {
-	var str, substr string
-	str = `goframe_is Very Nice.to-use`
+	{
+		var (
+			str    = `goframe_is Very Nice.to-use`
+			substr = "goframe"
+			rsStr  = gstr.Count(str, substr)
+		)
+		fmt.Println(rsStr)
+	}
 
-	substr = "goframe"
-	rsStr := gstr.Count(str, substr)
-	fmt.Println(rsStr)
-
-	substr = "golang"
-	rsStr = gstr.Count(str, substr)
-	fmt.Println(rsStr)
+	{
+		var (
+			str    = `goframe_is Very Nice.to-use`
+			substr = "golang"
+			rsStr  = gstr.Count(str, substr)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 1
@@ -304,16 +410,21 @@ func ExampleCount() {
 }
 
 func ExampleCountChars() {
-	var str string
-	var noSpace bool
-	str = `goframe_is Very Nice.to-use`
+	{
+		var (
+			str   = `goframe_is Very Nice.to-use`
+			rsStr = gstr.CountChars(str)
+		)
+		fmt.Println(rsStr)
+	}
 
-	rsStr := gstr.CountChars(str)
-	fmt.Println(rsStr)
-
-	noSpace = true
-	rsStr = gstr.CountChars(str, noSpace)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `goframe_is Very Nice.to-use`
+			rsStr = gstr.CountChars(str, true)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// May Output:
 	// map[ :2 -:1 .:1 N:1 V:1 _:1 a:1 c:1 e:4 f:1 g:1 i:2 m:1 o:2 r:2 s:2 t:1 u:1 y:1]
@@ -322,16 +433,24 @@ func ExampleCountChars() {
 }
 
 func ExampleCountI() {
-	var s, substr string
-	s = `goframe_is Very Nice.to-use`
+	{
+		var (
+			s      = `goframe_is Very Nice.to-use`
+			substr = "goframe"
+			rsStr  = gstr.CountI(s, substr)
+		)
 
-	substr = "goframe"
-	rsStr := gstr.CountI(s, substr)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	substr = "golang"
-	rsStr = gstr.CountI(s, substr)
-	fmt.Println(rsStr)
+	{
+		var (
+			s      = `goframe_is Very Nice.to-use`
+			substr = "golang"
+			rsStr  = gstr.CountI(s, substr)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 1
@@ -339,9 +458,11 @@ func ExampleCountI() {
 }
 
 func ExampleCountWords() {
-	var str string
-	str = `goframe is Very Nice to use ! goframe Very Nice !`
-	rsStr := gstr.CountWords(str)
+	var (
+		str   = `goframe is Very Nice to use ! goframe Very Nice !`
+		rsStr = gstr.CountWords(str)
+	)
+
 	fmt.Println(rsStr)
 
 	// Output:
@@ -349,21 +470,33 @@ func ExampleCountWords() {
 }
 
 func ExampleEqual() {
-	var a, b string
-	a = `A`
-	b = `a`
-	rsStr := gstr.Equal(a, b)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = `A`
+			b     = `a`
+			rsStr = gstr.Equal(a, b)
+		)
 
-	a = `A`
-	b = `A`
-	rsStr = gstr.Equal(a, b)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	a = `C`
-	b = `B`
-	rsStr = gstr.Equal(a, b)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = `A`
+			b     = `A`
+			rsStr = gstr.Equal(a, b)
+		)
+		fmt.Println(rsStr)
+	}
+
+	{
+		var (
+			a     = `C`
+			b     = `B`
+			rsStr = gstr.Equal(a, b)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// true
@@ -372,10 +505,12 @@ func ExampleEqual() {
 }
 
 func ExampleExplode() {
-	var delimiter, str string
-	str = `goframe_is_Very_Nice_to_use`
-	delimiter = "_"
-	rsStr := gstr.Explode(delimiter, str)
+	var (
+		str       = `goframe_is_Very_Nice_to_use`
+		delimiter = "_"
+		rsStr     = gstr.Explode(delimiter, str)
+	)
+
 	fmt.Println(rsStr)
 
 	// Output:
@@ -383,9 +518,11 @@ func ExampleExplode() {
 }
 
 func ExampleFields() {
-	var str string
-	str = `goframe is Very Nice to-use`
-	rsStr := gstr.Fields(str)
+	var (
+		str   = `goframe is Very Nice to-use`
+		rsStr = gstr.Fields(str)
+	)
+
 	fmt.Println(rsStr)
 
 	// Output:
@@ -393,16 +530,24 @@ func ExampleFields() {
 }
 
 func ExampleHasPrefix() {
-	var s, prefix string
-	s = `goframe_is Very Nice.to-use`
+	{
+		var (
+			s      = `goframe_is Very Nice.to-use`
+			prefix = "goframe"
+			rsStr  = gstr.HasPrefix(s, prefix)
+		)
 
-	prefix = "goframe"
-	rsStr := gstr.HasPrefix(s, prefix)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	prefix = "Goframe"
-	rsStr = gstr.HasPrefix(s, prefix)
-	fmt.Println(rsStr)
+	{
+		var (
+			s      = `goframe_is Very Nice.to-use`
+			prefix = "Goframe"
+			rsStr  = gstr.HasPrefix(s, prefix)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// true
@@ -410,16 +555,23 @@ func ExampleHasPrefix() {
 }
 
 func ExampleHasSuffix() {
-	var s, prefix string
-	s = `goframe_is Very Nice.to-use`
+	{
+		var (
+			s      = `goframe_is Very Nice.to-use`
+			prefix = "use"
+			rsStr  = gstr.HasSuffix(s, prefix)
+		)
+		fmt.Println(rsStr)
+	}
 
-	prefix = "use"
-	rsStr := gstr.HasSuffix(s, prefix)
-	fmt.Println(rsStr)
-
-	prefix = "Use"
-	rsStr = gstr.HasSuffix(s, prefix)
-	fmt.Println(rsStr)
+	{
+		var (
+			s      = `goframe_is Very Nice.to-use`
+			prefix = "Use"
+			rsStr  = gstr.HasSuffix(s, prefix)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// true
@@ -427,21 +579,25 @@ func ExampleHasSuffix() {
 }
 
 func ExampleHideStr() {
-	var str string
-	var percent int
-	var hide string
+	{
+		var (
+			str     = `13800138000`
+			percent = 40
+			hide    = `*`
+			rsStr   = gstr.HideStr(str, percent, hide)
+		)
+		fmt.Println(rsStr)
+	}
 
-	str = `13800138000`
-	percent = 40
-	hide = `*`
-	rsStr := gstr.HideStr(str, percent, hide)
-	fmt.Println(rsStr)
-
-	str = `AAAAAAAAAA`
-	percent = 60
-	hide = `@`
-	rsStr = gstr.HideStr(str, percent, hide)
-	fmt.Println(rsStr)
+	{
+		var (
+			str     = `AAAAAAAAAA`
+			percent = 60
+			hide    = `@`
+			rsStr   = gstr.HideStr(str, percent, hide)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 138****8000
@@ -449,11 +605,11 @@ func ExampleHideStr() {
 }
 
 func ExampleImplode() {
-	var glue string
-	var pieces []string
-	pieces = []string{"goframe", "is", "Very", "Nice", "to", "use"}
-	glue = "-"
-	rsStr := gstr.Implode(glue, pieces)
+	var (
+		pieces = []string{"goframe", "is", "Very", "Nice", "to", "use"}
+		glue   = "-"
+		rsStr  = gstr.Implode(glue, pieces)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -461,16 +617,23 @@ func ExampleImplode() {
 }
 
 func ExampleInArray() {
-	var a []string
-	var s string
-	a = []string{"goframe", "is", "Very", "Nice", "to", "use"}
-	s = "goframe"
-	rsStr := gstr.InArray(a, s)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = []string{"goframe", "is", "Very", "Nice", "to", "use"}
+			s     = "goframe"
+			rsStr = gstr.InArray(a, s)
+		)
+		fmt.Println(rsStr)
+	}
 
-	s = "golang"
-	rsStr = gstr.InArray(a, s)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = []string{"goframe", "is", "Very", "Nice", "to", "use"}
+			s     = "golang"
+			rsStr = gstr.InArray(a, s)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// true
@@ -478,14 +641,21 @@ func ExampleInArray() {
 }
 
 func ExampleIsLetterLower() {
-	var b byte
-	b = 65 // In ASCII is "a"
-	rsStr := gstr.IsLetterLower(b)
-	fmt.Println(rsStr)
+	{
+		var (
+			b     byte = 65 // In ASCII is "a"
+			rsStr      = gstr.IsLetterLower(b)
+		)
+		fmt.Println(rsStr)
+	}
 
-	b = 97 // In ASCII is "A"
-	rsStr = gstr.IsLetterLower(b)
-	fmt.Println(rsStr)
+	{
+		var (
+			b     byte = 97 // In ASCII is "A"
+			rsStr      = gstr.IsLetterLower(b)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// false
@@ -493,14 +663,21 @@ func ExampleIsLetterLower() {
 }
 
 func ExampleIsLetterUpper() {
-	var b byte
-	b = 65 // In ASCII is "a"
-	rsStr := gstr.IsLetterUpper(b)
-	fmt.Println(rsStr)
+	{
+		var (
+			b     byte = 65 // In ASCII is "a"
+			rsStr      = gstr.IsLetterUpper(b)
+		)
+		fmt.Println(rsStr)
+	}
 
-	b = 97 // In ASCII is "A"
-	rsStr = gstr.IsLetterUpper(b)
-	fmt.Println(rsStr)
+	{
+		var (
+			b     byte = 97 // In ASCII is "A"
+			rsStr      = gstr.IsLetterUpper(b)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// true
@@ -508,19 +685,29 @@ func ExampleIsLetterUpper() {
 }
 
 func ExampleIsNumeric() {
-	var s string
+	{
+		var (
+			s     = "88"
+			rsStr = gstr.IsNumeric(s)
+		)
+		fmt.Println(rsStr)
+	}
 
-	s = "88"
-	rsStr := gstr.IsNumeric(s)
-	fmt.Println(rsStr)
+	{
+		var (
+			s     = "aa66bb88"
+			rsStr = gstr.IsNumeric(s)
+		)
+		fmt.Println(rsStr)
+	}
 
-	s = "aa66bb88"
-	rsStr = gstr.IsNumeric(s)
-	fmt.Println(rsStr)
-
-	s = "3.1415926"
-	rsStr = gstr.IsNumeric(s)
-	fmt.Println(rsStr)
+	{
+		var (
+			s     = "3.1415926"
+			rsStr = gstr.IsNumeric(s)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// true
@@ -529,22 +716,32 @@ func ExampleIsNumeric() {
 }
 
 func ExampleIsSubDomain() {
-	var subDomain, mainDomain string
+	{
+		var (
+			subDomain  = `s.goframe.org`
+			mainDomain = `goframe.org`
+			rsStr      = gstr.IsSubDomain(subDomain, mainDomain)
+		)
+		fmt.Println(rsStr)
+	}
 
-	subDomain = `s.goframe.org`
-	mainDomain = `goframe.org`
-	rsStr := gstr.IsSubDomain(subDomain, mainDomain)
-	fmt.Println(rsStr)
+	{
+		var (
+			subDomain  = `s.s.goframe.org`
+			mainDomain = `goframe.org`
+			rsStr      = gstr.IsSubDomain(subDomain, mainDomain)
+		)
+		fmt.Println(rsStr)
+	}
 
-	subDomain = `s.s.goframe.org`
-	mainDomain = `goframe.org`
-	rsStr = gstr.IsSubDomain(subDomain, mainDomain)
-	fmt.Println(rsStr)
-
-	subDomain = `s.s.goframe.org`
-	mainDomain = `*goframe.org`
-	rsStr = gstr.IsSubDomain(subDomain, mainDomain)
-	fmt.Println(rsStr)
+	{
+		var (
+			subDomain  = `s.s.goframe.org`
+			mainDomain = `*goframe.org`
+			rsStr      = gstr.IsSubDomain(subDomain, mainDomain)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// true
@@ -553,12 +750,11 @@ func ExampleIsSubDomain() {
 }
 
 func ExampleJoin() {
-	var array []string
-	var sep string
-
-	array = []string{"goframe", "is", "Very", "Nice", "to", "use"}
-	sep = `,`
-	rsStr := gstr.Join(array, sep)
+	var (
+		array = []string{"goframe", "is", "Very", "Nice", "to", "use"}
+		sep   = `,`
+		rsStr = gstr.Join(array, sep)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -566,43 +762,58 @@ func ExampleJoin() {
 }
 
 func ExampleJoinAny() {
-	var sep string
-
-	sep = `@`
-	arr1 := []string{"goframe", "is", "Very", "Nice", "to", "use"}
-	rsStr := gstr.JoinAny(arr1, sep)
-	fmt.Println(rsStr)
-
-	sep = `,`
-	arr2 := []int{99, 73, 85, 66}
-	rsStr2 := gstr.JoinAny(arr2, sep)
-	fmt.Println(rsStr2)
-
-	sep = `,`
-	arr3 := []interface{}{
-		"Mary",
-		18,
-		99.5,
-		"<br>",
-		"Jack",
-		19,
-		66.5,
+	{
+		var (
+			sep   = `@`
+			arr1  = []string{"goframe", "is", "Very", "Nice", "to", "use"}
+			rsStr = gstr.JoinAny(arr1, sep)
+		)
+		fmt.Println(rsStr)
 	}
-	rsStr3 := gstr.JoinAny(arr3, sep)
-	fmt.Println(rsStr3)
 
-	sep = `|`
-	type StructA struct {
-		Name string
-		Age  int
+	{
+		var (
+			sep    = `,`
+			arr2   = []int{99, 73, 85, 66}
+			rsStr2 = gstr.JoinAny(arr2, sep)
+		)
+		fmt.Println(rsStr2)
 	}
-	arr4 := []StructA{
-		{"Mary", 18},
-		{"Jack", 18},
-		{"Lucy", 18},
+
+	{
+		var (
+			sep  = `,`
+			arr3 = []interface{}{
+				"Mary",
+				18,
+				99.5,
+				"<br>",
+				"Jack",
+				19,
+				66.5,
+			}
+			rsStr3 = gstr.JoinAny(arr3, sep)
+		)
+		fmt.Println(rsStr3)
+	}
+
+	{
+		type StructA struct {
+			Name string
+			Age  int
+		}
+		var (
+			sep = `|`
+
+			arr4 = []StructA{
+				{"Mary", 18},
+				{"Jack", 18},
+				{"Lucy", 18},
+			}
+			rsStr = gstr.JoinAny(arr4, sep)
+		)
+		fmt.Println(rsStr)
 	}
-	rsStr = gstr.JoinAny(arr4, sep)
-	fmt.Println(rsStr)
 
 	// Output:
 	// goframe@is@Very@Nice@to@use
@@ -612,14 +823,21 @@ func ExampleJoinAny() {
 }
 
 func ExampleLcFirst() {
-	var str string
-	str = `Goframe`
-	rsStr := gstr.LcFirst(str)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `Goframe`
+			rsStr = gstr.LcFirst(str)
+		)
+		fmt.Println(rsStr)
+	}
 
-	str = `Goframe is Very Nice to use.`
-	rsStr = gstr.LcFirst(str)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `Goframe is Very Nice to use.`
+			rsStr = gstr.LcFirst(str)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// goframe
@@ -627,18 +845,29 @@ func ExampleLcFirst() {
 }
 
 func ExampleLenRune() {
-	var str string
-	str = `goframe is Very Nice to use`
-	rsStr := gstr.LenRune(str)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `goframe is Very Nice to use`
+			rsStr = gstr.LenRune(str)
+		)
+		fmt.Println(rsStr)
+	}
 
-	str = `123 4567 890`
-	rsStr = gstr.LenRune(str)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `123 4567 890`
+			rsStr = gstr.LenRune(str)
+		)
+		fmt.Println(rsStr)
+	}
 
-	str = `Goframe是一个非常好用的Go语言框架!`
-	rsStr = gstr.LenRune(str)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `Goframe是一个非常好用的Go语言框架!`
+			rsStr = gstr.LenRune(str)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 27
@@ -647,24 +876,30 @@ func ExampleLenRune() {
 }
 
 func ExampleLevenshtein() {
-	var str1, str2 string
-	var costIns, costRep, costDel int
-	str1 = "Hello World"
-	str2 = "ello World"
+	{
+		var (
+			str1    = "Hello World"
+			str2    = "ello World"
+			costIns = 1
+			costRep = 1
+			costDel = 1
+			rsStr   = gstr.Levenshtein(str1, str2, costIns, costRep, costDel)
+		)
 
-	costIns = 1
-	costRep = 1
-	costDel = 1
-	rsStr := gstr.Levenshtein(str1, str2, costIns, costRep, costDel)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	str1 = "Hello World"
-	str2 = "ello Worles"
-	costIns = 10
-	costRep = 20
-	costDel = 30
-	rsStr = gstr.Levenshtein(str1, str2, costIns, costRep, costDel)
-	fmt.Println(rsStr)
+	{
+		var (
+			str1    = "Hello World"
+			str2    = "ello Worles"
+			costIns = 10
+			costRep = 20
+			costDel = 30
+			rsStr   = gstr.Levenshtein(str1, str2, costIns, costRep, costDel)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 1
@@ -672,14 +907,16 @@ func ExampleLevenshtein() {
 }
 
 func ExampleNl2Br() {
-	var str string
-	str = `goframe
+	var (
+		str = `goframe
 is
 Very
 Nice
 to
 use`
-	rsStr := gstr.Nl2Br(str)
+		rsStr = gstr.Nl2Br(str)
+	)
+
 	fmt.Println(rsStr)
 
 	// Output:
@@ -687,31 +924,39 @@ use`
 }
 
 func ExampleNumberFormat() {
-	var number float64
-	var decimals int
-	var decPoint string
-	var thousandsSep string
 
-	number = 123456
-	decimals = 2
-	decPoint = "."
-	thousandsSep = ","
-	rsStr := gstr.NumberFormat(number, decimals, decPoint, thousandsSep)
-	fmt.Println(rsStr)
+	{
+		var (
+			number       float64 = 123456
+			decimals             = 2
+			decPoint             = "."
+			thousandsSep         = ","
+			rsStr                = gstr.NumberFormat(number, decimals, decPoint, thousandsSep)
+		)
+		fmt.Println(rsStr)
+	}
 
-	number = 1234.56
-	decimals = 1
-	decPoint = ","
-	thousandsSep = " "
-	rsStr = gstr.NumberFormat(number, decimals, decPoint, thousandsSep)
-	fmt.Println(rsStr)
+	{
+		var (
+			number       = 1234.56
+			decimals     = 1
+			decPoint     = ","
+			thousandsSep = " "
+			rsStr        = gstr.NumberFormat(number, decimals, decPoint, thousandsSep)
+		)
+		fmt.Println(rsStr)
+	}
 
-	number = 1234.5678
-	decimals = 3
-	decPoint = "."
-	thousandsSep = ","
-	rsStr = gstr.NumberFormat(number, decimals, decPoint, thousandsSep)
-	fmt.Println(rsStr)
+	{
+		var (
+			number       = 1234.5678
+			decimals     = 3
+			decPoint     = "."
+			thousandsSep = ","
+			rsStr        = gstr.NumberFormat(number, decimals, decPoint, thousandsSep)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 123,456.00
@@ -720,9 +965,10 @@ func ExampleNumberFormat() {
 }
 
 func ExampleOctStr() {
-	var str string
-	str = `\346\200\241`
-	rsStr := gstr.OctStr(str)
+	var (
+		str   = `\346\200\241`
+		rsStr = gstr.OctStr(str)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -730,9 +976,11 @@ func ExampleOctStr() {
 }
 
 func ExampleOrd() {
-	var str string
-	str = `goframe`
-	rsStr := gstr.Ord(str)
+	var (
+		str   = `goframe`
+		rsStr = gstr.Ord(str)
+	)
+
 	fmt.Println(rsStr)
 
 	// Output:
@@ -740,37 +988,51 @@ func ExampleOrd() {
 }
 
 func ExampleParse() {
-	var str string
-
-	str = `v1=m&v2=n`
-	rsStr, _ := gstr.Parse(str)
-	fmt.Println(rsStr)
-
-	str = `v[a][a]=m&v[a][b]=n`
-	rsStr, _ = gstr.Parse(str)
-	fmt.Println(rsStr)
-
-	// The form of nested Slice is not yet supported.
-	str = `v[][]=m&v[][]=n`
-	rsStr, err := gstr.Parse(str)
-	if err != nil {
-		fmt.Println("Error:", err)
+	{
+		var (
+			str      = `v1=m&v2=n`
+			rsStr, _ = gstr.Parse(str)
+		)
+		fmt.Println(rsStr)
 	}
-	fmt.Println(rsStr)
 
-	// This will produce an error.
-	str = `v=m&v[a]=n`
-	rsStr, err = gstr.Parse(str)
-	if err != nil {
-		fmt.Println("Error:", err)
+	{
+		var (
+			str      = `v[a][a]=m&v[a][b]=n`
+			rsStr, _ = gstr.Parse(str)
+		)
+		fmt.Println(rsStr)
 	}
-	fmt.Println(rsStr)
 
-	str = `a .[[b=c`
-	rsStr, _ = gstr.Parse(str)
-	fmt.Println(rsStr)
+	{
+		// The form of nested Slice is not yet supported.
+		var str = `v[][]=m&v[][]=n`
+		rsStr, err := gstr.Parse(str)
+		if err != nil {
+			panic(err)
+		}
+		fmt.Println(rsStr)
+	}
 
-	// Output:
+	{
+		// This will produce an error.
+		var str = `v=m&v[a]=n`
+		rsStr, err := gstr.Parse(str)
+		if err != nil {
+			println(err)
+		}
+		fmt.Println(rsStr)
+	}
+
+	{
+		var (
+			str      = `a .[[b=c`
+			rsStr, _ = gstr.Parse(str)
+		)
+		fmt.Println(rsStr)
+	}
+
+	// May Output:
 	// map[v1:m v2:n]
 	// map[v:map[a:map[a:m b:n]]]
 	// map[v:map[]]
@@ -780,25 +1042,43 @@ func ExampleParse() {
 }
 
 func ExamplePos() {
-	var haystack, needle string
-	var startOffset int
+	{
+		var (
+			haystack = `goframe_is Very Nice.to-use`
+			needle   = `Nice`
+			rsStr    = gstr.Pos(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
-	haystack = `goframe_is Very Nice.to-use`
-	needle = `Nice`
-	rsStr := gstr.Pos(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `goframe_is Very Nice.to-use`
+			needle      = `Nice`
+			startOffset = 16
+			rsStr       = gstr.Pos(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	startOffset = 16
-	rsStr = gstr.Pos(haystack, needle, startOffset)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `goframe_is Very Nice.to-use`
+			needle      = `Nice`
+			startOffset = 17
+			rsStr       = gstr.Pos(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	startOffset = 17
-	rsStr = gstr.Pos(haystack, needle, startOffset)
-	fmt.Println(rsStr)
-
-	needle = `nice`
-	rsStr = gstr.Pos(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack = `goframe_is Very Nice.to-use`
+			needle   = `nice`
+			rsStr    = gstr.Pos(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 16
@@ -808,25 +1088,44 @@ func ExamplePos() {
 }
 
 func ExamplePosI() {
-	var haystack, needle string
-	var startOffset int
+	{
+		var (
+			haystack = `goframe_is Very Nice.to-use`
+			needle   = `Nice`
+			rsStr    = gstr.PosI(haystack, needle)
+		)
 
-	haystack = `goframe_is Very Nice.to-use`
-	needle = `Nice`
-	rsStr := gstr.PosI(haystack, needle)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	startOffset = 16
-	rsStr = gstr.PosI(haystack, needle, startOffset)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `goframe_is Very Nice.to-use`
+			needle      = `Nice`
+			startOffset = 16
+			rsStr       = gstr.PosI(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	startOffset = 17
-	rsStr = gstr.PosI(haystack, needle, startOffset)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `goframe_is Very Nice.to-use`
+			needle      = `Nice`
+			startOffset = 17
+			rsStr       = gstr.PosI(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	needle = `nice`
-	rsStr = gstr.PosI(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack = `goframe_is Very Nice.to-use`
+			needle   = `nice`
+			rsStr    = gstr.PosI(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 16
@@ -836,26 +1135,44 @@ func ExamplePosI() {
 }
 
 func ExamplePosIRune() {
-	var haystack, needle string
-	var startOffset int
+	{
+		var (
+			haystack = `goframe_is Very Nice.to-use`
+			needle   = `Nice`
+			rsStr    = gstr.PosIRune(haystack, needle)
+		)
 
-	haystack = `goframe_is Very Nice.to-use`
-	needle = `Nice`
-	rsStr := gstr.PosIRune(haystack, needle)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	haystack = `Goframe是个非常好用的框架.`
-	startOffset = 16
-	rsStr = gstr.PosIRune(haystack, needle, startOffset)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `Goframe是个非常好用的框架.`
+			needle      = `Nice`
+			startOffset = 16
+			rsStr       = gstr.PosIRune(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	startOffset = 17
-	rsStr = gstr.PosIRune(haystack, needle, startOffset)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `Goframe是个非常好用的框架.`
+			needle      = `Nice`
+			startOffset = 17
+			rsStr       = gstr.PosIRune(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	needle = `nice`
-	rsStr = gstr.PosIRune(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack = `Goframe是个非常好用的框架.`
+			needle   = `nice`
+			rsStr    = gstr.PosIRune(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 16
@@ -865,25 +1182,43 @@ func ExamplePosIRune() {
 }
 
 func ExamplePosR() {
-	var haystack, needle string
-	var startOffset int
+	{
+		var (
+			haystack = `goframe_is Very Nice.to-use`
+			needle   = `Nice`
+			rsStr    = gstr.PosR(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
-	haystack = `goframe_is Very Nice.to-use`
-	needle = `Nice`
-	rsStr := gstr.PosR(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `goframe_is Very Nice.to-use`
+			needle      = `Nice`
+			startOffset = 16
+			rsStr       = gstr.PosR(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	startOffset = 16
-	rsStr = gstr.PosR(haystack, needle, startOffset)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `goframe_is Very Nice.to-use`
+			needle      = `Nice`
+			startOffset = 17
+			rsStr       = gstr.PosR(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	startOffset = 17
-	rsStr = gstr.PosR(haystack, needle, startOffset)
-	fmt.Println(rsStr)
-
-	needle = `nice`
-	rsStr = gstr.PosR(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack = `goframe_is Very Nice.to-use`
+			needle   = `nice`
+			rsStr    = gstr.PosR(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 16
@@ -893,25 +1228,43 @@ func ExamplePosR() {
 }
 
 func ExamplePosRI() {
-	var haystack, needle string
-	var startOffset int
+	{
+		var (
+			haystack = `goframe_is Very Nice.to-use`
+			needle   = `Nice`
+			rsStr    = gstr.PosRI(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
-	haystack = `goframe_is Very Nice.to-use`
-	needle = `Nice`
-	rsStr := gstr.PosRI(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `goframe_is Very Nice.to-use`
+			needle      = `Nice`
+			startOffset = 16
+			rsStr       = gstr.PosRI(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	startOffset = 16
-	rsStr = gstr.PosRI(haystack, needle, startOffset)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `goframe_is Very Nice.to-use`
+			needle      = `Nice`
+			startOffset = 17
+			rsStr       = gstr.PosRI(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	startOffset = 17
-	rsStr = gstr.PosRI(haystack, needle, startOffset)
-	fmt.Println(rsStr)
-
-	needle = `nice`
-	rsStr = gstr.PosRI(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack = `goframe_is Very Nice.to-use`
+			needle   = `nice`
+			rsStr    = gstr.PosRI(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 16
@@ -922,27 +1275,44 @@ func ExamplePosRI() {
 }
 
 func ExamplePosRIRune() {
-	var haystack, needle string
-	var startOffset int
+	{
+		var (
+			haystack = `Goframe是个非常好用的框架`
+			needle   = `好用`
+			rsStr    = gstr.PosRIRune(haystack, needle)
+		)
 
-	haystack = `Goframe是个非常好用的框架`
-	needle = `好用`
-	rsStr := gstr.PosRIRune(haystack, needle)
-	fmt.Println(rsStr)
+		fmt.Println(rsStr)
+	}
 
-	needle = `框架`
-	startOffset = 16
-	rsStr = gstr.PosRIRune(haystack, needle, startOffset)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `Goframe是个非常好用的框架`
+			needle      = `框架`
+			startOffset = 16
+			rsStr       = gstr.PosRIRune(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	needle = `golang`
-	startOffset = 17
-	rsStr = gstr.PosRIRune(haystack, needle, startOffset)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `Goframe是个非常好用的框架`
+			needle      = `golang`
+			startOffset = 17
+			rsStr       = gstr.PosRIRune(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	needle = `goframe`
-	rsStr = gstr.PosRIRune(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack = `Goframe是个非常好用的框架`
+			needle   = `goframe`
+			rsStr    = gstr.PosRIRune(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 11
@@ -952,26 +1322,43 @@ func ExamplePosRIRune() {
 }
 
 func ExamplePosRRune() {
-	var haystack, needle string
-	var startOffset int
+	{
+		var (
+			haystack = `goframe_is Very Nice.to-use`
+			needle   = `Nice`
+			rsStr    = gstr.PosRRune(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
-	haystack = `goframe_is Very Nice.to-use`
-	needle = `Nice`
-	rsStr := gstr.PosRRune(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `goframe_is Very Nice.to-use`
+			needle      = `Nice`
+			startOffset = 16
+			rsStr       = gstr.PosRRune(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	startOffset = 16
-	rsStr = gstr.PosRRune(haystack, needle, startOffset)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `Goframe是中国开发者的福利.`
+			needle      = `Nice`
+			startOffset = 17
+			rsStr       = gstr.PosRRune(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	haystack = `Goframe是中国开发者的福利.`
-	startOffset = 17
-	rsStr = gstr.PosRRune(haystack, needle, startOffset)
-	fmt.Println(rsStr)
-
-	needle = `开发者`
-	rsStr = gstr.PosRRune(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack = `Goframe是中国开发者的福利.`
+			needle   = `开发者`
+			rsStr    = gstr.PosRRune(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 16
@@ -981,27 +1368,43 @@ func ExamplePosRRune() {
 }
 
 func ExamplePosRune() {
-	var haystack, needle string
-	var startOffset int
+	{
+		var (
+			haystack = `goframe_is Very Nice.to-use`
+			needle   = `Nice`
+			rsStr    = gstr.PosRune(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
-	haystack = `goframe_is Very Nice.to-use`
-	needle = `Nice`
-	rsStr := gstr.PosRune(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `我喜欢Goframe框架`
+			needle      = `框架`
+			startOffset = 16
+			rsStr       = gstr.PosRune(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	haystack = `我喜欢Goframe框架`
-	needle = `框架`
-	startOffset = 16
-	rsStr = gstr.PosRune(haystack, needle, startOffset)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack    = `我喜欢Goframe框架`
+			needle      = `框架`
+			startOffset = 17
+			rsStr       = gstr.PosRune(haystack, needle, startOffset)
+		)
+		fmt.Println(rsStr)
+	}
 
-	startOffset = 17
-	rsStr = gstr.PosRune(haystack, needle, startOffset)
-	fmt.Println(rsStr)
-
-	needle = `goframe`
-	rsStr = gstr.PosRune(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack = `我喜欢Goframe框架`
+			needle   = `goframe`
+			rsStr    = gstr.PosRune(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 16
@@ -1011,14 +1414,21 @@ func ExamplePosRune() {
 }
 
 func ExampleQuoteMeta() {
-	var str string
-	str = `.\+?[^]()`
-	rsStr := gstr.QuoteMeta(str)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `.\+?[^]()`
+			rsStr = gstr.QuoteMeta(str)
+		)
+		fmt.Println(rsStr)
+	}
 
-	str = `https://goframe.org/pages/viewpage.action?pageId=1114327`
-	rsStr = gstr.QuoteMeta(str)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `https://goframe.org/pages/viewpage.action?pageId=1114327`
+			rsStr = gstr.QuoteMeta(str)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// \.\\\+\?\[\^\]\(\)
@@ -1027,11 +1437,11 @@ func ExampleQuoteMeta() {
 }
 
 func ExampleRepeat() {
-	var input string
-	var multiplier int
-	input = `goframe `
-	multiplier = 3
-	rsStr := gstr.Repeat(input, multiplier)
+	var (
+		input      = `goframe `
+		multiplier = 3
+		rsStr      = gstr.Repeat(input, multiplier)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1039,18 +1449,26 @@ func ExampleRepeat() {
 }
 
 func ExampleReplace() {
-	var origin, search, replace string
-	var count int
+	{
+		var (
+			origin  = `goframe_is_Very_Nice_to_use!`
+			search  = `_`
+			replace = `+`
+			rsStr   = gstr.Replace(origin, search, replace)
+		)
+		fmt.Println(rsStr)
+	}
 
-	origin = `goframe_is_Very_Nice_to_use!`
-	search = `_`
-	replace = `+`
-	rsStr := gstr.Replace(origin, search, replace)
-	fmt.Println(rsStr)
-
-	count = 2
-	rsStr = gstr.Replace(origin, search, replace, count)
-	fmt.Println(rsStr)
+	{
+		var (
+			origin  = `goframe_is_Very_Nice_to_use!`
+			search  = `_`
+			replace = `+`
+			count   = 2
+			rsStr   = gstr.Replace(origin, search, replace, count)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// goframe+is+Very+Nice+to+use!
@@ -1058,18 +1476,23 @@ func ExampleReplace() {
 }
 
 func ExampleReplaceByArray() {
-	var origin string
-	var array []string
+	{
+		var (
+			origin = `Golang is Very Good`
+			array  = []string{"o", "O"}
+			rsStr  = gstr.ReplaceByArray(origin, array)
+		)
+		fmt.Println(rsStr)
+	}
 
-	origin = `Golang is Very Good`
-
-	array = []string{"o", "O"}
-	rsStr := gstr.ReplaceByArray(origin, array)
-	fmt.Println(rsStr)
-
-	array = []string{"Golang", "Goframe", "Good", "Nice"}
-	rsStr = gstr.ReplaceByArray(origin, array)
-	fmt.Println(rsStr)
+	{
+		var (
+			origin = `Golang is Very Good`
+			array  = []string{"Golang", "Goframe", "Good", "Nice"}
+			rsStr  = gstr.ReplaceByArray(origin, array)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// GOlang is Very GOOd
@@ -1077,24 +1500,29 @@ func ExampleReplaceByArray() {
 }
 
 func ExampleReplaceByMap() {
-	var origin string
-	var replaces map[string]string
-
-	origin = `Golang is Very Good`
-
-	replaces = map[string]string{
-		"Golang": "Goframe",
-		"Good":   "Nice",
+	{
+		var (
+			origin   = `Golang is Very Good`
+			replaces = map[string]string{
+				"Golang": "Goframe",
+				"Good":   "Nice",
+			}
+			rsStr = gstr.ReplaceByMap(origin, replaces)
+		)
+		fmt.Println(rsStr)
 	}
-	rsStr := gstr.ReplaceByMap(origin, replaces)
-	fmt.Println(rsStr)
 
-	replaces = map[string]string{
-		"golang": "Goframe",
-		"good":   "Nice",
+	{
+		var (
+			origin   = `Golang is Very Good`
+			replaces = map[string]string{
+				"golang": "Goframe",
+				"good":   "Nice",
+			}
+			rsStr = gstr.ReplaceByMap(origin, replaces)
+		)
+		fmt.Println(rsStr)
 	}
-	rsStr = gstr.ReplaceByMap(origin, replaces)
-	fmt.Println(rsStr)
 
 	// Output:
 	// Goframe is Very Nice
@@ -1102,14 +1530,13 @@ func ExampleReplaceByMap() {
 }
 
 func ExampleReplaceI() {
-	var origin, search, replace string
-	var count int
-
-	origin = `goframe is Very Nice to use`
-	search = `Goframe`
-	replace = `golang`
-	count = 3
-	rsStr := gstr.ReplaceI(origin, search, replace, count)
+	var (
+		origin  = `goframe is Very Nice to use`
+		search  = `Goframe`
+		replace = `golang`
+		count   = 3
+		rsStr   = gstr.ReplaceI(origin, search, replace, count)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1117,39 +1544,42 @@ func ExampleReplaceI() {
 }
 
 func ExampleReplaceIByArray() {
-	fmt.Println(gstr.ReplaceIByArray(
-		`golang is very nice`,
-		[]string{
-			"Golang",
-			"GoFrame",
-			"Nice",
-			"GOOD",
-		},
-	))
+	var (
+		origin = `golang is very nice`
+		array  = []string{"Golang", "GoFrame", "Nice", "GOOD"}
+		rsStr  = gstr.ReplaceIByArray(origin, array)
+	)
+
+	fmt.Println(rsStr)
 
 	// Output:
 	// GoFrame is very GOOD
 }
 
 func ExampleReplaceIByMap() {
-	var origin string
-	var replaces map[string]string
-
-	origin = `Golang is Very Good`
-
-	replaces = map[string]string{
-		"Golang": "Goframe",
-		"Good":   "Nice",
+	{
+		var (
+			origin   = `Golang is Very Good`
+			replaces = map[string]string{
+				"Golang": "Goframe",
+				"Good":   "Nice",
+			}
+			rsStr = gstr.ReplaceIByMap(origin, replaces)
+		)
+		fmt.Println(rsStr)
 	}
-	rsStr := gstr.ReplaceIByMap(origin, replaces)
-	fmt.Println(rsStr)
 
-	replaces = map[string]string{
-		"golang": "Goframe",
-		"good":   "Nice",
+	{
+		var (
+			origin   = `Golang is Very Good`
+			replaces = map[string]string{
+				"golang": "Goframe",
+				"good":   "Nice",
+			}
+			rsStr = gstr.ReplaceIByMap(origin, replaces)
+		)
+		fmt.Println(rsStr)
 	}
-	rsStr = gstr.ReplaceIByMap(origin, replaces)
-	fmt.Println(rsStr)
 
 	// Output:
 	// Goframe is Very Nice
@@ -1157,9 +1587,10 @@ func ExampleReplaceIByMap() {
 }
 
 func ExampleReverse() {
-	var str string
-	str = `123456`
-	rsStr := gstr.Reverse(str)
+	var (
+		str   = `123456`
+		rsStr = gstr.Reverse(str)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1167,25 +1598,32 @@ func ExampleReverse() {
 }
 
 func ExampleSearchArray() {
-	var a []string
-	var s string
-	a = []string{
-		"goframe",
-		"is",
-		"Very",
-		"Nice",
+	{
+		var (
+			a     = []string{"goframe", "is", "Very", "Nice"}
+			s     = `goframe`
+			rsStr = gstr.SearchArray(a, s)
+		)
+		fmt.Println(rsStr)
 	}
-	s = `goframe`
-	rsStr := gstr.SearchArray(a, s)
-	fmt.Println(rsStr)
 
-	s = `Very`
-	rsStr = gstr.SearchArray(a, s)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = []string{"goframe", "is", "Very", "Nice"}
+			s     = `Very`
+			rsStr = gstr.SearchArray(a, s)
+		)
+		fmt.Println(rsStr)
+	}
 
-	s = `use`
-	rsStr = gstr.SearchArray(a, s)
-	fmt.Println(rsStr)
+	{
+		var (
+			a     = []string{"goframe", "is", "Very", "Nice"}
+			s     = `use`
+			rsStr = gstr.SearchArray(a, s)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 0
@@ -1194,9 +1632,10 @@ func ExampleSearchArray() {
 }
 
 func ExampleShuffle() {
-	var str string
-	str = `goframe_is Nice.`
-	rsStr := gstr.Shuffle(str)
+	var (
+		str   = `goframe_is Nice.`
+		rsStr = gstr.Shuffle(str)
+	)
 	fmt.Println(rsStr)
 
 	// May Output:
@@ -1204,37 +1643,61 @@ func ExampleShuffle() {
 }
 
 func ExampleSimilarText() {
-	var first, second string
-	var percent *float64
-	first = `goframe_is`
-	second = `go-nice`
-	rsStr := gstr.SimilarText(first, second, percent)
-	fmt.Println(rsStr)
+	{
+		var (
+			percent *float64
+			first   = `goframe_is`
+			second  = `go-nice`
+			rsStr   = gstr.SimilarText(first, second, percent)
+		)
+		fmt.Println(rsStr)
+	}
+
+	{
+		var (
+			first  = `AaBbCcDd`
+			second = `ad`
+		)
+		p := 0.80
+		rsStr := gstr.SimilarText(first, second, &p)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// 3
+	// 2
 }
 
 func ExampleSoundex() {
-	var str string
-	var str2 string
-	str = `Euler`
-	str2 = `Ellery`
-	rsStr := gstr.Soundex(str)
-	rsStr2 := gstr.Soundex(str2)
-	fmt.Println(rsStr, rsStr2)
+	{
+		var (
+			str    = `Euler`
+			str2   = `Ellery`
+			rsStr  = gstr.Soundex(str)
+			rsStr2 = gstr.Soundex(str2)
+		)
+		fmt.Println(rsStr, rsStr2)
+	}
 
-	str = `Gauss`
-	str2 = `Ghosh`
-	rsStr = gstr.Soundex(str)
-	rsStr2 = gstr.Soundex(str2)
-	fmt.Println(rsStr, rsStr2)
+	{
+		var (
+			str    = `Gauss`
+			str2   = `Ghosh`
+			rsStr  = gstr.Soundex(str)
+			rsStr2 = gstr.Soundex(str2)
+		)
+		fmt.Println(rsStr, rsStr2)
+	}
 
-	str = `Lloyd`
-	str2 = `Ladd`
-	rsStr = gstr.Soundex(str)
-	rsStr2 = gstr.Soundex(str2)
-	fmt.Println(rsStr, rsStr2)
+	{
+		var (
+			str    = `Lloyd`
+			str2   = `Ladd`
+			rsStr  = gstr.Soundex(str)
+			rsStr2 = gstr.Soundex(str2)
+		)
+		fmt.Println(rsStr, rsStr2)
+	}
 
 	// Output:
 	// E406 E406
@@ -1243,10 +1706,11 @@ func ExampleSoundex() {
 }
 
 func ExampleSplit() {
-	var str, delimiter string
-	str = `GoFrame_Nice`
-	delimiter = `_`
-	rsStr := gstr.Split(str, delimiter)
+	var (
+		str       = `GoFrame_Nice`
+		delimiter = `_`
+		rsStr     = gstr.Split(str, delimiter)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1254,11 +1718,12 @@ func ExampleSplit() {
 }
 
 func ExampleSplitAndTrim() {
-	var str, delimiter, characterMask string
-	str = `    goframe, is,       Very ,Nice ,to,      use`
-	delimiter = `,`
-	characterMask = ` `
-	rsStr := gstr.SplitAndTrim(str, delimiter, characterMask)
+	var (
+		str           = `    goframe, is,       Very ,Nice ,to,      use`
+		delimiter     = `,`
+		characterMask = ` `
+		rsStr         = gstr.SplitAndTrim(str, delimiter, characterMask)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1266,45 +1731,36 @@ func ExampleSplitAndTrim() {
 }
 
 func ExampleStr() {
-	var haystack, needle string
-	haystack = `goframe nice`
-	needle = `fram`
-	rsStr := gstr.Str(haystack, needle)
-	fmt.Println(rsStr)
-
-	needle = `ame n`
-	rsStr = gstr.Str(haystack, needle)
+	var (
+		haystack = `xxx.jpg`
+		needle   = `.`
+		rsStr    = gstr.Str(haystack, needle)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
-	// me nice
-	// nice
+	// .jpg
 }
 
 func ExampleStrEx() {
-	var haystack, needle string
-	haystack = `ABCDEFG`
-	needle = `B`
-	rsStr := gstr.StrEx(haystack, needle)
-	fmt.Println(rsStr)
-
-	haystack = `ABCDEFG`
-	needle = `E`
-	rsStr = gstr.StrEx(haystack, needle)
+	var (
+		haystack = `https://goframe.org/index.html?a=1&b=2`
+		needle   = `?`
+		rsStr    = gstr.StrEx(haystack, needle)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
-	// CDEFG
-	// FG
+	// a=1&b=2
 }
 
 func ExampleStrLimit() {
-	var str, suffix string
-	var length int
-	str = `1234567890.png`
-	length = 8
-	suffix = `.jpg`
-	rsStr := gstr.StrLimit(str, length, suffix)
+	var (
+		str    = `1234567890.png`
+		length = 8
+		suffix = `.jpg`
+		rsStr  = gstr.StrLimit(str, length, suffix)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1312,51 +1768,60 @@ func ExampleStrLimit() {
 }
 
 func ExampleStrLimitRune() {
-	var str, suffix string
-	var length int
-	str = `Goframe是一个非常好用的Go语言框架.`
-	length = 7
-	suffix = "好用"
-	rsStr := gstr.StrLimitRune(str, length, suffix)
+	var (
+		str    = `123456789`
+		length = 5
+		suffix = "ABCD"
+		rsStr  = gstr.StrLimitRune(str, length, suffix)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
-	// Goframe好用
+	// 12345ABCD
 }
 
 func ExampleStrTill() {
-	var haystack, needle string
+	{
+		var (
+			haystack = `goframe是一个好用的框架,她提供了非常丰富的工具给使用者.`
+			needle   = `,`
+			rsStr    = gstr.StrTill(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
-	haystack = `ABCDEFGHIJKLMN`
-	needle = `C`
-	rsStr := gstr.StrTill(haystack, needle)
-	fmt.Println(rsStr)
-
-	needle = `E`
-	rsStr = gstr.StrTill(haystack, needle)
-	fmt.Println(rsStr)
-
-	needle = `G`
-	rsStr = gstr.StrTill(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack = `ABCDEFGHIJKLMN`
+			needle   = `EF`
+			rsStr    = gstr.StrTill(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
-	// ABC
+	// goframe是一个好用的框架,
 	// ABCDE
-	// ABCDEFG
 }
 
 func ExampleStrTillEx() {
-	var haystack, needle string
-	haystack = `abcdefg`
-	needle = `e`
-	rsStr := gstr.StrTillEx(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack = `abcdefg`
+			needle   = `e`
+			rsStr    = gstr.StrTillEx(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
-	haystack = `abcdefg`
-	needle = `de`
-	rsStr = gstr.StrTillEx(haystack, needle)
-	fmt.Println(rsStr)
+	{
+		var (
+			haystack = `abcdefg`
+			needle   = `de`
+			rsStr    = gstr.StrTillEx(haystack, needle)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// abcd
@@ -1364,9 +1829,10 @@ func ExampleStrTillEx() {
 }
 
 func ExampleStripSlashes() {
-	var str string
-	str = `C:\\windows\\GoFrame\\test`
-	rsStr := gstr.StripSlashes(str)
+	var (
+		str   = `C:\\windows\\GoFrame\\test`
+		rsStr = gstr.StripSlashes(str)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1374,33 +1840,38 @@ func ExampleStripSlashes() {
 }
 
 func ExampleSubStr() {
-	var str string
-	var start, length int
+	{
+		var (
+			str    = `123456789`
+			start  = 0
+			length = 2
+			subStr = gstr.SubStr(str, start, length)
+		)
+		fmt.Println(subStr)
+	}
 
-	str = `ABCDEFGHIJK`
-
-	start = 0
-	length = 2
-	subStr := gstr.SubStr(str, start, length)
-	fmt.Println(subStr)
-
-	start = 5
-	length = 6
-	subStr = gstr.SubStr(str, start, length)
-	fmt.Println(subStr)
+	{
+		var (
+			str    = `123456789`
+			start  = 5
+			length = 3
+			subStr = gstr.SubStr(str, start, length)
+		)
+		fmt.Println(subStr)
+	}
 
 	// Output:
-	// AB
-	// FGHIJK
+	// 12
+	// 678
 }
 
 func ExampleSubStrRune() {
-	var str string
-	var start, length int
-	str = `123456789`
-	start = 5
-	length = 4
-	subStr := gstr.SubStrRune(str, start, length)
+	var (
+		str    = `123456789`
+		start  = 5
+		length = 4
+		subStr = gstr.SubStrRune(str, start, length)
+	)
 	fmt.Println(subStr)
 
 	// Output:
@@ -1408,9 +1879,10 @@ func ExampleSubStrRune() {
 }
 
 func ExampleToLower() {
-	var s string
-	s = `GOFRAME IS VERY NICE TO USE`
-	rsStr := gstr.ToLower(s)
+	var (
+		s     = `GOFRAME IS VERY NICE TO USE`
+		rsStr = gstr.ToLower(s)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1418,9 +1890,10 @@ func ExampleToLower() {
 }
 
 func ExampleToUpper() {
-	var s string
-	s = `goframe is very nice to use`
-	rsStr := gstr.ToUpper(s)
+	var (
+		s     = `goframe is very nice to use`
+		rsStr = gstr.ToUpper(s)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1428,10 +1901,11 @@ func ExampleToUpper() {
 }
 
 func ExampleTrim() {
-	var str, characterMask string
-	str = `.abc.def..`
-	characterMask = "."
-	rsStr := gstr.Trim(str, characterMask)
+	var (
+		str           = `.abc.def..`
+		characterMask = "."
+		rsStr         = gstr.Trim(str, characterMask)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1439,10 +1913,11 @@ func ExampleTrim() {
 }
 
 func ExampleTrimAll() {
-	var str, characterMask string
-	str = `.abc.def...`
-	characterMask = "."
-	rsStr := gstr.TrimAll(str, characterMask)
+	var (
+		str           = `.abc.def...`
+		characterMask = "."
+		rsStr         = gstr.TrimAll(str, characterMask)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1450,10 +1925,11 @@ func ExampleTrimAll() {
 }
 
 func ExampleTrimLeft() {
-	var str, characterMask string
-	str = `..abc.def.. `
-	characterMask = "."
-	rsStr := gstr.TrimLeft(str, characterMask)
+	var (
+		str           = `..abc.def.. `
+		characterMask = "."
+		rsStr         = gstr.TrimLeft(str, characterMask)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1461,12 +1937,12 @@ func ExampleTrimLeft() {
 }
 
 func ExampleTrimLeftStr() {
-	var str, cut string
-	var count int
-	str = `...abcd..efg...`
-	cut = "."
-	count = 2
-	rsStr := gstr.TrimLeftStr(str, cut, count)
+	var (
+		str   = `...abcd..efg...`
+		cut   = "."
+		count = 2
+		rsStr = gstr.TrimLeftStr(str, cut, count)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1474,10 +1950,11 @@ func ExampleTrimLeftStr() {
 }
 
 func ExampleTrimRight() {
-	var str, characterMask string
-	str = `abcdef    `
-	characterMask = "def" // []byte{"d", "e", "f"}
-	rsStr := gstr.TrimRight(str, characterMask)
+	var (
+		str           = `abcdef    `
+		characterMask = "def" // []byte{"d", "e", "f"}
+		rsStr         = gstr.TrimRight(str, characterMask)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1485,25 +1962,35 @@ func ExampleTrimRight() {
 }
 
 func ExampleTrimRightStr() {
-	var str, cut string
-	var count int
-	str = `aaa,bbb,ccc,ddd,eee,`
-	cut = ","
-	count = 1
-	rsStr := gstr.TrimRightStr(str, cut, count)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `aaa,bbb,ccc,ddd,eee,`
+			cut   = ","
+			count = 1
+			rsStr = gstr.TrimRightStr(str, cut, count)
+		)
+		fmt.Println(rsStr)
+	}
 
-	str = `aaa,bbb,ccc,ddd,eee,,,,,`
-	cut = ","
-	count = -1
-	rsStr = gstr.TrimRightStr(str, cut, count)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `aaa,bbb,ccc,ddd,eee,,,,,`
+			cut   = ","
+			count = -1
+			rsStr = gstr.TrimRightStr(str, cut, count)
+		)
+		fmt.Println(rsStr)
+	}
 
-	str = `aaa,bbb,ccc,ddd,eee,,,,,   `
-	cut = ","
-	count = -1
-	rsStr = gstr.TrimRightStr(str, cut, count)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `aaa,bbb,ccc,ddd,eee,,,,,   `
+			cut   = ","
+			count = -1
+			rsStr = gstr.TrimRightStr(str, cut, count)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// aaa,bbb,ccc,ddd,eee
@@ -1512,16 +1999,23 @@ func ExampleTrimRightStr() {
 }
 
 func ExampleTrimStr() {
-	var str, cut string
-	var count int
-	str = `goframe is Very Nice to-use`
-	cut = "goframe"
-	rsStr := gstr.TrimStr(str, cut, count)
-	fmt.Println(rsStr)
-
-	cut = "use"
-	rsStr = gstr.TrimStr(str, cut, count)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `goframe is Very Nice to-use`
+			cut   = "goframe"
+			rsStr = gstr.TrimStr(str, cut)
+		)
+		fmt.Println(rsStr)
+	}
+	{
+		var (
+			str   = `goframe is Very Nice to-use`
+			cut   = "use"
+			count = -1
+			rsStr = gstr.TrimStr(str, cut, count)
+		)
+		fmt.Println(rsStr)
+	}
 
 	// Output:
 	// is Very Nice to-use
@@ -1529,9 +2023,10 @@ func ExampleTrimStr() {
 }
 
 func ExampleUcFirst() {
-	var s string
-	s = `goframe is very nice to use.`
-	rsStr := gstr.UcFirst(s)
+	var (
+		s     = `goframe is very nice to use.`
+		rsStr = gstr.UcFirst(s)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1539,9 +2034,10 @@ func ExampleUcFirst() {
 }
 
 func ExampleUcWords() {
-	var str string
-	str = `goframe is very nice to use.`
-	rsStr := gstr.UcWords(str)
+	var (
+		str   = `goframe is very nice to use.`
+		rsStr = gstr.UcWords(str)
+	)
 	fmt.Println(rsStr)
 
 	// Output:
@@ -1549,19 +2045,25 @@ func ExampleUcWords() {
 }
 
 func ExampleWordWrap() {
-	var str, br string
-	var width int
-	str = `A very long woooooooooooooooooord. and something`
-	width = 8
-	br = "\n"
-	rsStr := gstr.WordWrap(str, width, br)
-	fmt.Println(rsStr)
+	{
+		var (
+			str   = `A very long woooooooooooooooooord. and something`
+			width = 8
+			br    = "\n"
+			rsStr = gstr.WordWrap(str, width, br)
+		)
+		fmt.Println(rsStr)
+	}
 
-	str = `The quick brown fox jumped over the lazy dog.`
-	width = 20
-	br = "<br />\n"
-	rsStr = gstr.WordWrap(str, width, br)
-	fmt.Printf("%v", rsStr)
+	{
+		var (
+			str   = `The quick brown fox jumped over the lazy dog.`
+			width = 20
+			br    = "<br />\n"
+			rsStr = gstr.WordWrap(str, width, br)
+		)
+		fmt.Printf("%v", rsStr)
+	}
 
 	// Output:
 	// A very