gstr提供了强大便捷的文本处理组件，组件内置了大量常用的字符串处理方法，比较于Golang标准库更加全面丰富，可应对绝大部分业务场景。

使用方式：

import "github.com/gogf/gf/text/gstr"

接口文档：

https://godoc.org/github.com/gogf/gf/text/gstr

以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档：https://pkg.go.dev/github.com/gogf/gf/v2/text/gstr

常用方法

`Count`

说明：Count计算substr在s中出现的次数。如果在s中没有找到substr，则返回0。
格式：
```
Count(s, substr string) int
```

示例：

func ExampleCount() {
	var (
		str     = `goframe is very, very easy to use`
		substr1 = "goframe"
		substr2 = "very"
		result1 = gstr.Count(str, substr1)
		result2 = gstr.Count(str, substr2)
	)
	fmt.Println(result1)
	fmt.Println(result2)

	// Output:
	// 1
	// 2
}

`CountI`

说明：Count计算substr在s中出现的次数，不区分大小写。如果在s中没有找到substr，则返回0。
格式：
```
CountI(s, substr string) int
```

示例：

func ExampleCountI() {
	var (
		str     = `goframe is very, very easy to use`
		substr1 = "GOFRAME"
		substr2 = "VERY"
		result1 = gstr.CountI(str, substr1)
		result2 = gstr.CountI(str, substr2)
	)
	fmt.Println(result1)
	fmt.Println(result2)

	// Output:
	// 1
	// 2
}

`ToLower`

说明：ToLower将s中所有Unicode字符都变为小写并返回其副本。
格式：
```
ToLower(s string) string
```

示例：

func ExampleToLower() {
	var (
		s      = `GOFRAME`
		result = gstr.ToLower(s)
	)
	fmt.Println(result)

	// Output:
	// goframe
}

`ToUpper`

说明：ToUpper将s中所有Unicode字符都变为大写并返回其副本。
格式：
```
ToUpper(s string) string
```

示例：

func ExampleToUpper() {
	var (
		s      = `goframe`
		result = gstr.ToUpper(s)
	)
	fmt.Println(result)

	// Output:
	// GOFRAME
}

`UcFirst`

说明：UcFirst将s中首字符变为大写并返回其副本。
格式：
```
UcFirst(s string) string
```

示例：

func ExampleUcFirst() {
	var (
		s      = `hello`
		result = gstr.UcFirst(s)
	)
	fmt.Println(result)

	// Output:
	// Hello
}

`LcFirst`

说明：LcFirst将s中首字符变为小写并返回其副本。
格式：
```
LcFirst(s string) string
```

示例：

func ExampleLcFirst() {
	var (
		str    = `Goframe`
		result = gstr.LcFirst(str)
	)
	fmt.Println(result)

	// Output:
	// goframe
}

`UcWords`

说明：UcWords将字符串str中每个单词的第一个字符变为大写。
格式：
```
UcWords(str string) string
```

示例：

func ExampleUcWords() {
	var (
		str    = `hello world`
		result = gstr.UcWords(str)
	)
	fmt.Println(result)

	// Output:
	// Hello World
}

`IsLetterLower`

说明：IsLetterLower验证给定的字符b是否是小写字符。
格式：
```
IsLetterLower(b byte) bool
```

示例：

func ExampleIsLetterLower() {
	fmt.Println(gstr.IsLetterLower('a'))
	fmt.Println(gstr.IsLetterLower('A'))

	// Output:
	// true
	// false
}

`IsLetterUpper`

说明：IsLetterUpper验证字符b是否是大写字符。
格式：
```
IsLetterUpper(b byte) bool
```

示例：

func ExampleIsLetterUpper() {
	fmt.Println(gstr.IsLetterUpper('A'))
	fmt.Println(gstr.IsLetterUpper('a'))

	// Output:
	// true
	// false
}

`IsNumeric`

说明：IsNumeric验证字符串s是否为数字。
格式：
```
IsNumeric(s string) bool
```

示例：

func ExampleIsNumeric() {
	fmt.Println(gstr.IsNumeric("88"))
	fmt.Println(gstr.IsNumeric("3.1415926"))
	fmt.Println(gstr.IsNumeric("abc"))
	// Output:
	// true
	// true
	// false
}

`Reverse`

说明：Reverse返回str的反转字符串。
格式：
```
Reverse(str string) string
```

示例：

func ExampleReverse() {
	var (
		str    = `123456`
		result = gstr.Reverse(str)
	)
	fmt.Println(result)

	// Output:
	// 654321
}

`NumberFormat`

说明：NumberFormat以千位分组来格式化数字。
- 参数decimal设置小数点的个数。
- 参数decPoint设置小数点的分隔符。
- 参数thousand设置千位分隔符。

格式：

NumberFormat(number float64, decimals int, decPoint, thousandsSep string) string

示例：

func ExampleNumberFormat() {
	var (
		number       float64 = 123456
		decimals             = 2
		decPoint             = "."
		thousandsSep         = ","
		result               = gstr.NumberFormat(number, decimals, decPoint, thousandsSep)
	)
	fmt.Println(result)

	// Output:
	// 123,456.00
}

`ChunkSplit`

说明：ChunkSplit将字符串拆分为单位为chunkLen长度更小的每一份，并用end连接每一份拆分出的字符串。

格式：

ChunkSplit(body string, chunkLen int, end string) string

示例：

func ExampleChunkSplit() {
	var (
		body     = `1234567890`
		chunkLen = 2
		end      = "#"
		result   = gstr.ChunkSplit(body, chunkLen, end)
	)
	fmt.Println(result)

	// Output:
	// 12#34#56#78#90#
}

`Compare`

说明：Compare返回一个按字典顺序比较两个字符串的整数。如果a == b，结果为0，如果a < b，结果为-1，如果a > b，结果为+1。
格式：
```
Compare(a, b string) int
```

示例：

func ExampleCompare() {
	fmt.Println(gstr.Compare("c", "c"))
	fmt.Println(gstr.Compare("a", "b"))
	fmt.Println(gstr.Compare("c", "b"))

	// Output:
	// 0
	// -1
	// 1
}

`Equal`

说明：Equal返回a和b在不区分大小写的情况下是否相等。
格式：
```
Equal(a, b string) bool
```

示例：

func ExampleEqual() {
	fmt.Println(gstr.Equal(`A`, `a`))
	fmt.Println(gstr.Equal(`A`, `A`))
	fmt.Println(gstr.Equal(`A`, `B`))

	// Output:
	// true
	// true
	// false
}

`Fields`

说明：Fields以[]string的形式返回字符串中的每个单词。
格式：
```
Fields(str string) []string
```

示例：

func ExampleFields() {
	var (
		str    = `Hello World`
		result = gstr.Fields(str)
	)
	fmt.Printf(`%#v`, result)

	// Output:
	// []string{"Hello", "World"}
}

`HasPrefix`

说明：HasPrefix返回s是否以prefix开头。
格式：
```
HasPrefix(s, prefix string) bool
```

示例：

func ExampleHasPrefix() {
	var (
		s      = `Hello World`
		prefix = "Hello"
		result = gstr.HasPrefix(s, prefix)
	)
	fmt.Println(result)

	// Output:
	// true
}

`HasSuffix`

说明：HasSuffix返回s是否以suffix 结束。
格式：
```
HasSuffix(s, suffix string) bool
```

示例：

func ExampleHasSuffix() {
	var (
		s      = `my best love is goframe`
		prefix = "goframe"
		result = gstr.HasSuffix(s, prefix)
	)
	fmt.Println(result)

	// Output:
	// true
}

`CountWords`

说明：CountWords以map[string]int的形式返回str中使用的单词的统计信息。
格式：
```
CountWords(str string) map[string]int
```

示例：

func ExampleCountWords() {
	var (
		str    = `goframe is very, very easy to use!`
		result = gstr.CountWords(str)
	)
	fmt.Printf(`%#v`, result)

	// Output:
	// map[string]int{"easy":1, "goframe":1, "is":1, "to":1, "use!":1, "very":1, "very,":1}
}

`CountChars`

说明：CountChars以map[string]int的形式返回str中使用的字符的统计信息。noSpace参数可以控制是否计算空格。

格式：

CountChars(str string, noSpace ...bool) map[string]int

示例：

func ExampleCountChars() {
	var (
		str    = `goframe`
		result = gstr.CountChars(str)
	)
	fmt.Println(result)

	// May Output:
	// map[a:1 e:1 f:1 g:1 m:1 o:1 r:1]
}

`WordWrap`

说明：WordWrap使用换行符将str换行到给定字符数（不会切分单词）。

格式：

WordWrap(str string, width int, br string) string

示例：

func ExampleWordWrap() {
	{
		var (
			str    = `A very long woooooooooooooooooord. and something`
			width  = 8
			br     = "\n"
			result = gstr.WordWrap(str, width, br)
		)
		fmt.Println(result)
	}
	{
		var (
			str    = `The quick brown fox jumped over the lazy dog.`
			width  = 20
			br     = "<br />\n"
			result = gstr.WordWrap(str, width, br)
		)
		fmt.Printf("%v", result)
	}

	// Output:
	// A very
	// long
	// woooooooooooooooooord.
	// and
	// something
	// The quick brown fox<br />
	// jumped over the lazy<br />
	// dog.
}

`LenRune`

说明：LenRune返回unicode字符串长度。
格式：
```
LenRune(str string) int
```

示例：

func ExampleLenRune() {
	var (
		str    = `GoFrame框架`
		result = gstr.LenRune(str)
	)
	fmt.Println(result)

	// Output:
	// 9
}

`Repeat`

说明：Repeat返回一个由input重复multiplier次后组成的新字符串。

格式：

Repeat(input string, multiplier int) string

示例：

func ExampleRepeat() {
	var (
		input      = `goframe `
		multiplier = 3
		result     = gstr.Repeat(input, multiplier)
	)
	fmt.Println(result)

	// Output:
	// goframe goframe goframe
}

`Shuffle`

说明：Shuffle返回将str随机打散后的字符串。
格式：
```
Shuffle(str string) string
```

示例：

func ExampleShuffle() {
	var (
		str    = `123456`
		result = gstr.Shuffle(str)
	)
	fmt.Println(result)

	// May Output:
	// 563214
}

`Split`

说明：Split用delimiter将str拆分为[]string。
格式：
```
Split(str, delimiter string) []string
```

示例：

func ExampleSplit() {
	var (
		str       = `a|b|c|d`
		delimiter = `|`
		result    = gstr.Split(str, delimiter)
	)
	fmt.Printf(`%#v`, result)

	// Output:
	// []string{"a", "b", "c", "d"}
}

`SplitAndTrim`

说明： SplitAndTrim使用delimiter将str拆分为[]string，并对[]string的每个元素调用Trim，并忽略在Trim之后为空的元素。

格式：

SplitAndTrim(str, delimiter string, characterMask ...string) []string

示例：

func ExampleSplitAndTrim() {
	var (
		str       = `a|b|||||c|d`
		delimiter = `|`
		result    = gstr.SplitAndTrim(str, delimiter)
	)
	fmt.Printf(`%#v`, result)

	// Output:
	// []string{"a", "b", "c", "d"}
}

`Join`

说明：Join将array中的每一个元素连接并生成一个新的字符串。参数sep会作为新字符串的分隔符。
格式：
```
Join(array []string, sep string) string
```

示例：

func ExampleJoin() {
	var (
		array  = []string{"goframe", "is", "very", "easy", "to", "use"}
		sep    = ` `
		result = gstr.Join(array, sep)
	)
	fmt.Println(result)

	// Output:
	// goframe is very easy to use
}

`JoinAny`

说明：JoinAny将array中的每一个元素连接并生成一个新的字符串。参数sep会作为新字符串的分隔符。参数array可以是任意的类型。

格式：

JoinAny(array interface{}, sep string) string

示例：

func ExampleJoinAny() {
	var (
		sep    = `,`
		arr2   = []int{99, 73, 85, 66}
		result = gstr.JoinAny(arr2, sep)
	)
	fmt.Println(result)

	// Output:
	// 99,73,85,66
}

`Explode`

说明：Explode使用分隔符delimiter字符串str拆分成[]string
格式：
```
Explode(delimiter, str string) []string
```

示例：

func ExampleExplode() {
	var (
		str       = `Hello World`
		delimiter = " "
		result    = gstr.Explode(delimiter, str)
	)
	fmt.Printf(`%#v`, result)

	// Output:
	// []string{"Hello", "World"}
}

`Implode`

说明：Implode使用glue连接pieces字符串数组的每一个元素。

格式：

Implode(glue string, pieces []string) string

示例：

func ExampleImplode() {
	var (
		pieces = []string{"goframe", "is", "very", "easy", "to", "use"}
		glue   = " "
		result = gstr.Implode(glue, pieces)
	)
	fmt.Println(result)

	// Output:
	// goframe is very easy to use
}

`Chr`

说明：Chr返回一个数字0-255对应的ascii字符串。
格式：
```
Chr(ascii int) string
```

示例：

func ExampleChr() {
	var (
		ascii  = 65 // A
		result = gstr.Chr(ascii)
	)
	fmt.Println(result)

	// Output:
	// A
}

`Ord`

说明：Ord将字符串的第一个字节转换为0-255之间的值。
格式：
```
Ord(char string) int
```

示例：

func ExampleOrd() {
	var (
		str    = `goframe`
		result = gstr.Ord(str)
	)

	fmt.Println(result)

	// Output:
	// 103
}

`HideStr`

说明：HideStr将字符串str从中间字符开始，百分比percent的字符转换成hide字符串。

格式：

HideStr(str string, percent int, hide string) string

示例：

func ExampleHideStr() {
	var (
		str     = `13800138000`
		percent = 40
		hide    = `*`
		result  = gstr.HideStr(str, percent, hide)
	)
	fmt.Println(result)

	// Output:
	// 138****8000
}

`Nl2Br`

说明：Nl2Br在字符串中的所有换行符之前插入HTML换行符(' br ' |<br />): \n\r， \r\n， \r， \n。

格式：

Nl2Br(str string, isXhtml ...bool) string

示例：

func ExampleNl2Br() {
	var (
		str = `goframe
is
very
easy
to
use`
		result = gstr.Nl2Br(str)
	)

	fmt.Println(result)

	// Output:
	// goframe<br>is<br>very<br>easy<br>to<br>use
}

`AddSlashes`

说明：AddSlashes将字符串中的符号前添加转义字符'\'
格式：
```
AddSlashes(str string) string
```

示例：

func ExampleAddSlashes() {
	var (
		str    = `'aa'"bb"cc\r\n\d\t`
		result = gstr.AddSlashes(str)
	)

	fmt.Println(result)

	// Output:
	// \'aa\'\"bb\"cc\\r\\n\\d\\t
}

`StripSlashes`

说明：StripSlashes去掉字符串str中的转义字符'\'。
格式：
```
StripSlashes(str string) string
```

示例：

func ExampleStripSlashes() {
	var (
		str    = `C:\\windows\\GoFrame\\test`
		result = gstr.StripSlashes(str)
	)
	fmt.Println(result)

	// Output:
	// C:\windows\GoFrame\test
}

`QuoteMeta`

说明：QuoteMeta为str中'. \ + * ? [ ^ ] ( $ )中的每个字符前添加一个转义字符'\'。

格式：

QuoteMeta(str string, chars ...string) string

示例：

func ExampleQuoteMeta() {
	{
		var (
			str    = `.\+?[^]()`
			result = gstr.QuoteMeta(str)
		)
		fmt.Println(result)
	}
	{
		var (
			str    = `https://goframe.org/pages/viewpage.action?pageId=1114327`
			result = gstr.QuoteMeta(str)
		)
		fmt.Println(result)
	}

	// Output:
	// \.\\\+\?\[\^\]\(\)
	// https://goframe\.org/pages/viewpage\.action\?pageId=1114327

}

`Count`

说明：
格式：
示例：

AddSlashes

格式: AddSlashes
说明: 在英文的单引号( ' ) , 双引号( " ), 反斜杠( \ ) 前面自动添加一个转义符号反斜杠( \ )。

示例：

func ExampleAddSlashes() {
	var str string
	str = `'aa'"bb"cc\r\n\d\t`
	rsStr := gstr.AddSlashes(str)
	fmt.Println(rsStr)
	
	// Output:
	// \'aa\'\"bb\"cc\\r\\n\\d\\t
}

CaseCamel

格式: CaseCamel
说明: 将字符串转换为大驼峰形式(首字母大写)。

示例： `goframe_is very nice.to-use` 字符串中的下划线,空格,点,中横杠都可以作为驼峰的分割点。

func ExampleCaseCamel() {
	var str string
	str = `goframe_is very nice.to-use`
	rsStr := gstr.CaseCamel(str)
	fmt.Println(rsStr)

	// Output:
	// GoframeIsVeryNiceToUse
}

CaseCamelLower

格式: CaseCamelLower
说明: 将字符串转换为小驼峰形式(首字母小写)。

示例： `goframe_is very nice.to-use` 字符串中的下划线,空格,点,中横杠都可以作为驼峰的分割点。

func ExampleCaseCamelLower() {
	var str string
	str = `goframe_is very nice.to-use`
	rsStr := gstr.CaseCamelLower(str)
	fmt.Println(rsStr)

	// Output:
	// goframeIsVeryNiceToUse
}

CaseDelimited

格式: CaseDelimited
说明: 将字符串转换中的符号进行替换,该函数第二个参数为替换的uint8类型字符。

示例： del参数为int8类型的35,就是字符 # (井号)

func ExampleCaseDelimited() {
	var str string
	var del uint8
	str = `goframe_is_very-nice.to-use`
	del = 35
	rsStr := gstr.CaseDelimited(str,del)
	fmt.Println(rsStr)

	// Output:
	// goframe#is#very#nice#to#use
}

CaseDelimitedScreaming

格式: CaseDelimitedScreaming
说明: 将字符串中的符号(空格,下划线,点,中横线)用第二个参数进行替换,该函数第二个参数为替换的uint8类型字符,第三个参数为大小写转换,true为全部转换大写字母,false为全部转为小写字母。

示例： del参数为int8类型的35,就是字符 # (井号)

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)

	// Output:
	// GOFRAME#IS#VERY#NICE#TO#USE
}

CaseKebab

格式: CaseKebab
说明: 将字符串转换中的符号(下划线,空格,点,)用中横线(-)替换,并全部转换为小写字母。

示例：

func ExampleCaseKebab() {
	var str string
	str = `goframe_is Very Nice.to-use`
	rsStr := gstr.CaseKebab(str)
	fmt.Println(rsStr)

	// Output:
	// goframe-is-very-nice-to-use
}

CaseKebabScreaming

格式: CaseKebabScreaming
说明: 将字符串转换中的符号(下划线,空格,点,中横线)用中横线(-)替换,并全部转换为大写字母。

示例：

func ExampleCaseKebabScreaming() {
	var str string
	str = `goframe_is Very Nice.to-use`
	rsStr := gstr.CaseKebabScreaming(str)
	fmt.Println(rsStr)

	// Output:
	// GOFRAME-IS-VERY-NICE-TO-USE
}

CaseSnake

格式: CaseSnake
说明: 将字符串转换中的符号(下划线,空格,点,中横线)用下划线( _ )替换,并全部转换为小写字母。

示例：

func ExampleCaseSnake() {
	var str string
	str = `goframe_is Very Nice.to-use`
	rsStr := gstr.CaseSnake(str)
	fmt.Println(rsStr)

	// Output:
	// goframe_is_very_nice_to_use
}

CaseSnakeFirstUpper

格式: CaseSnakeFirstUpper
说明: 当字符串中的字母为大写时,将大写字母转换为小写字母并在其前面增加一个下划线( _ ),首字母大写时,只转换为小写,前面不增加下划线( _ )。

示例：

func ExampleCaseSnakeFirstUpper() {
	var str string
	str = `GoframeIsVeryNiceToUse`
	rsStr := gstr.CaseSnakeFirstUpper(str)
	fmt.Println(rsStr)

	// Output:
	// goframe_is_very_nice_to_use
}

CaseSnakeScreaming

格式: CaseSnakeScreaming
说明: 当字符串中的符号(下划线,空格,点,中横线),全部替换为下划线( _ ),并将所有英文字母转为大写。

示例：

func ExampleCaseSnakeScreaming() {
	var str string
	str = `goframe_is Very Nice.to-use`
	rsStr := gstr.CaseSnakeScreaming(str)
	fmt.Println(rsStr)

	// Output:
	// GOFRAME_IS_VERY_NICE_TO_USE
}

Chr

格式: Chr
说明: 将ASCII 码表中对应的十进制数字转换为字符, 其 ASCII码 (American Standard Code for Information Interchange) 为美国信息交换标准代码,

示例：在ASCII表中英文大写字母A对应的十进制数为65

func ExampleChr() {
	var ascii int
	ascii = 65
	rsStr := gstr.Chr(ascii)
	fmt.Println(rsStr)

	// Output:
	// A
}

`Count`

说明：
格式：
示例：

Content Menu

Space shortcuts

Page tree

字符串处理-gstr(更新中)

常用方法

Count

CountI

ToLower

ToUpper

UcFirst

LcFirst

UcWords

IsLetterLower

IsLetterUpper

IsNumeric

Reverse

NumberFormat

ChunkSplit

Compare

Equal

Fields

HasPrefix

HasSuffix

CountWords

CountChars

WordWrap

LenRune

Repeat

Shuffle

Split

SplitAndTrim

Join

JoinAny

Explode

Implode

Chr

Ord

HideStr

Nl2Br

AddSlashes

StripSlashes

QuoteMeta

Count

AddSlashes

CaseCamel

CaseCamelLower

CaseDelimited

CaseDelimitedScreaming

CaseKebab

CaseKebabScreaming

CaseSnake

CaseSnakeFirstUpper

CaseSnakeScreaming

Chr

Count

`Count`

`CountI`

`ToLower`

`ToUpper`

`UcFirst`

`LcFirst`

`UcWords`

`IsLetterLower`

`IsLetterUpper`

`IsNumeric`

`Reverse`

`NumberFormat`

`ChunkSplit`

`Compare`

`Equal`

`Fields`

`HasPrefix`

`HasSuffix`

`CountWords`

`CountChars`

`WordWrap`

`LenRune`

`Repeat`

`Shuffle`

`Split`

`SplitAndTrim`

`Join`

`JoinAny`

`Explode`

`Implode`

`Chr`

`Ord`

`HideStr`

`Nl2Br`

`AddSlashes`

`StripSlashes`

`QuoteMeta`

`Count`

`Count`