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

使用方式：

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

接口文档：

https://pkg.go.dev/github.com/gogf/gf/v2/text/gstr

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

字符串判断

`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
}

字符串长度

`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
}

大小写转换

`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
}

字符串比较

`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
}

切分组合

`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
}

`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#
}

`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"}
}

转义处理

`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`

说明：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
}

`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]
}

数组处理

`SearchArray`

说明：SearchArray在[]string 'a'中区分大小写地搜索字符串's'，返回其在'a'中的索引。如果在'a'中没有找到's'，则返回-1。
格式：
```
SearchArray(a []string, s string) int
```

示例：

func ExampleSearchArray() {
	var (
		array  = []string{"goframe", "is", "very", "nice"}
		str    = `goframe`
		result = gstr.SearchArray(array, str)
	)
	fmt.Println(result)

	// Output:
	// 0
}

`InArray`

说明：InArray校验[]string 'a'中是否有字符串' s '。
格式：
```
InArray(a []string, s string) bool
```

示例：

func ExampleInArray() {
	var (
		a      = []string{"goframe", "is", "very", "easy", "to", "use"}
		s      = "goframe"
		result = gstr.InArray(a, s)
	)
	fmt.Println(result)

	// Output:
	// true
}

`PrefixArray`

说明：PrefixArray位[]string array的每一个字符串添加'prefix'的前缀。

格式：

PrefixArray(array []string, prefix string)

示例：

func ExamplePrefixArray() {
	var (
		strArray = []string{"tom", "lily", "john"}
	)

	gstr.PrefixArray(strArray, "classA_")

	fmt.Println(strArray)

	// Output:
	// [classA_tom classA_lily classA_john]
}

命名转换

`CaseCamel`

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

示例：

func ExampleCaseCamel() {
	var (
		str    = `hello world`
		result = gstr.CaseCamel(str)
	)
	fmt.Println(result)

	// Output:
	// HelloWorld
}

`CaseCamelLower`

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

示例：

func ExampleCaseCamelLower() {
	var (
		str    = `hello world`
		result = gstr.CaseCamelLower(str)
	)
	fmt.Println(result)

	// Output:
	// helloWorld
}

`CaseSnake`

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

示例：

func ExampleCaseSnake() {
	var (
		str    = `hello world`
		result = gstr.CaseSnake(str)
	)
	fmt.Println(result)

	// Output:
	// hello_world
}

`CaseSnakeScreaming`

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

示例：

func ExampleCaseSnakeScreaming() {
	var (
		str    = `hello world`
		result = gstr.CaseSnakeScreaming(str)
	)
	fmt.Println(result)

	// Output:
	// HELLO_WORLD
}

`CaseSnakeFirstUpper`

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

格式：

CaseSnakeFirstUpper(word string, underscore ...string) string

示例：

func ExampleCaseSnakeFirstUpper() {
	var (
		str    = `RGBCodeMd5`
		result = gstr.CaseSnakeFirstUpper(str)
	)
	fmt.Println(result)

	// Output:
	// rgb_code_md5
}

`CaseKebab`

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

示例：

func ExampleCaseKebab() {
	var (
		str    = `hello world`
		result = gstr.CaseKebab(str)
	)
	fmt.Println(result)

	// Output:
	// hello-world
}

`CaseKebabScreaming`

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

示例：

func ExampleCaseKebabScreaming() {
	var (
		str    = `hello world`
		result = gstr.CaseKebabScreaming(str)
	)
	fmt.Println(result)

	// Output:
	// HELLO-WORLD
}

`CaseDelimited`

说明：CaseDelimited将字符串转换中的符号进行替换。

格式：

CaseDelimited(s string, del byte) string

示例：

func ExampleCaseDelimited() {
	var (
		str    = `hello world`
		del    = byte('-')
		result = gstr.CaseDelimited(str, del)
	)
	fmt.Println(result)

	// Output:
	// hello-world
}

`CaseDelimitedScreaming`

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

格式：

CaseDelimitedScreaming(s string, del uint8, screaming bool) string

示例：

func ExampleCaseDelimitedScreaming() {
	{
		var (
			str    = `hello world`
			del    = byte('-')
			result = gstr.CaseDelimitedScreaming(str, del, true)
		)
		fmt.Println(result)
	}
	{
		var (
			str    = `hello world`
			del    = byte('-')
			result = gstr.CaseDelimitedScreaming(str, del, false)
		)
		fmt.Println(result)
	}

	// Output:
	// HELLO-WORLD
	// hello-world
}

包含判断

`Contains`

说明：Contains返回字符串str是否包含子字符串substr，区分大小写。
格式：
```
Contains(str, substr string) bool
```

示例：

func ExampleContains() {
	{
		var (
			str    = `Hello World`
			substr = `Hello`
			result = gstr.Contains(str, substr)
		)
		fmt.Println(result)
	}
	{
		var (
			str    = `Hello World`
			substr = `hello`
			result = gstr.Contains(str, substr)
		)
		fmt.Println(result)
	}

	// Output:
	// true
	// false
}

`ContainsI`

说明：ContainsI校验substr是否在str中，不区分大小写。
格式：
```
ContainsI(str, substr string) bool
```

示例：

func ExampleContainsI() {
	var (
		str     = `Hello World`
		substr  = "hello"
		result1 = gstr.Contains(str, substr)
		result2 = gstr.ContainsI(str, substr)
	)
	fmt.Println(result1)
	fmt.Println(result2)

	// Output:
	// false
	// true
}

`ContainsAny`

说明：ContainsAny校验s中是否包含chars。
格式：
```
ContainsAny(s, chars string) bool
```

示例：

func ExampleContainsAny() {
	{
		var (
			s      = `goframe`
			chars  = "g"
			result = gstr.ContainsAny(s, chars)
		)
		fmt.Println(result)
	}
	{
		var (
			s      = `goframe`
			chars  = "G"
			result = gstr.ContainsAny(s, chars)
		)
		fmt.Println(result)
	}

	// Output:
	// true
	// false
}

字符串转换

`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
}

`OctStr`

说明：OctStr将字符串str中的八进制字符串转换为其原始字符串。
格式：
```
OctStr(str string) string
```

示例：

func ExampleOctStr() {
	var (
		str    = `\346\200\241`
		result = gstr.OctStr(str)
	)
	fmt.Println(result)

	// Output:
	// 怡
}

`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
}

`Shuffle`

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

示例：

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

	// May Output:
	// 563214
}

`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
}

`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.
}

域名处理

`IsSubDomain`

说明：IsSubDomain校验subDomain是否为mainDomain的子域名。支持mainDomain中的'*'。

格式：

IsSubDomain(subDomain string, mainDomain string) bool

示例：

func ExampleIsSubDomain() {
	var (
		subDomain  = `s.goframe.org`
		mainDomain = `goframe.org`
		result     = gstr.IsSubDomain(subDomain, mainDomain)
	)
	fmt.Println(result)

	// Output:
	// true
}

参数解析

`Parse`

说明：Parse解析字符串并以map[string]interface{}类型返回。

格式：

Parse(s string) (result map[string]interface{}, err error)

示例：

func ExampleParse() {
	{
		var (
			str       = `v1=m&v2=n`
			result, _ = gstr.Parse(str)
		)
		fmt.Println(result)
	}
	{
		var (
			str       = `v[a][a]=m&v[a][b]=n`
			result, _ = gstr.Parse(str)
		)
		fmt.Println(result)
	}
	{
		// The form of nested Slice is not yet supported.
		var str = `v[][]=m&v[][]=n`
		result, err := gstr.Parse(str)
		if err != nil {
			panic(err)
		}
		fmt.Println(result)
	}
	{
		// This will produce an error.
		var str = `v=m&v[a]=n`
		result, err := gstr.Parse(str)
		if err != nil {
			println(err)
		}
		fmt.Println(result)
	}
	{
		var (
			str       = `a .[[b=c`
			result, _ = gstr.Parse(str)
		)
		fmt.Println(result)
	}

	// May Output:
	// map[v1:m v2:n]
	// map[v:map[a:map[a:m b:n]]]
	// map[v:map[]]
	// Error: expected type 'map[string]interface{}' for key 'v', but got 'string'
	// map[]
	// map[a___[b:c]
}

位置查找

`Pos`

说明：Pos返回needle在haystack中第一次出现的位置，区分大小写。如果没有找到，则返回-1。

格式：

Pos(haystack, needle string, startOffset ...int) int

示例：

func ExamplePos() {
	var (
		haystack = `Hello World`
		needle   = `World`
		result   = gstr.Pos(haystack, needle)
	)
	fmt.Println(result)

	// Output:
	// 6
}

`PosRune`

说明：PosRune的作用于函数Pos相似，但支持haystack和needle为unicode字符串。

格式：

PosRune(haystack, needle string, startOffset ...int) int

示例：

func ExamplePosRune() {
	var (
		haystack = `GoFrame是一款模块化、高性能、企业级的Go基础开发框架`
		needle   = `Go`
		posI     = gstr.PosRune(haystack, needle)
		posR     = gstr.PosRRune(haystack, needle)
	)
	fmt.Println(posI)
	fmt.Println(posR)

	// Output:
	// 0
	// 22
}

`PosI`

说明：PosI返回needle在haystack中第一次出现的位置，不区分大小写。如果没有找到，则返回-1。

格式：

PosI(haystack, needle string, startOffset ...int) int

示例：

func ExamplePosI() {
	var (
		haystack = `goframe is very, very easy to use`
		needle   = `very`
		posI     = gstr.PosI(haystack, needle)
		posR     = gstr.PosR(haystack, needle)
	)
	fmt.Println(posI)
	fmt.Println(posR)

	// Output:
	// 11
	// 17
}

`PosRuneI`

说明：PosRuneI的作用于函数PosI相似，但支持haystack和needle为unicode字符串。

格式：

PosIRune(haystack, needle string, startOffset ...int) int

示例：

func ExamplePosIRune() {
	{
		var (
			haystack    = `GoFrame是一款模块化、高性能、企业级的Go基础开发框架`
			needle      = `高性能`
			startOffset = 10
			result      = gstr.PosIRune(haystack, needle, startOffset)
		)
		fmt.Println(result)
	}
	{
		var (
			haystack    = `GoFrame是一款模块化、高性能、企业级的Go基础开发框架`
			needle      = `高性能`
			startOffset = 30
			result      = gstr.PosIRune(haystack, needle, startOffset)
		)
		fmt.Println(result)
	}

	// Output:
	// 14
	// -1
}

`PosR`

说明：PosR返回needle在haystack中最后一次出现的位置，区分大小写。如果没有找到，则返回-1。

格式：

PosR(haystack, needle string, startOffset ...int) int

示例：

func ExamplePosR() {
	var (
		haystack = `goframe is very, very easy to use`
		needle   = `very`
		posI     = gstr.PosI(haystack, needle)
		posR     = gstr.PosR(haystack, needle)
	)
	fmt.Println(posI)
	fmt.Println(posR)

	// Output:
	// 11
	// 17
}

`PosRuneR`

说明：PosRuneR的作用于函数PosR相似，但支持haystack和needle为unicode字符串。

格式：

PosRRune(haystack, needle string, startOffset ...int) int

示例：

func ExamplePosRRune() {
	var (
		haystack = `GoFrame是一款模块化、高性能、企业级的Go基础开发框架`
		needle   = `Go`
		posI     = gstr.PosIRune(haystack, needle)
		posR     = gstr.PosRRune(haystack, needle)
	)
	fmt.Println(posI)
	fmt.Println(posR)

	// Output:
	// 0
	// 22
}

`PosRI`

说明：PosRI返回needle在haystack中最后一次出现的位置，不区分大小写。如果没有找到，则返回-1。

格式：

PosRI(haystack, needle string, startOffset ...int) int

示例：

func ExamplePosRI() {
	var (
		haystack = `goframe is very, very easy to use`
		needle   = `VERY`
		posI     = gstr.PosI(haystack, needle)
		posR     = gstr.PosRI(haystack, needle)
	)
	fmt.Println(posI)
	fmt.Println(posR)

	// Output:
	// 11
	// 17
}

`PosRIRune`

说明：PosRIRune的作用于函数PosRI相似，但支持haystack和needle为unicode字符串。

格式：

PosRIRune(haystack, needle string, startOffset ...int) int

示例：

func ExamplePosRIRune() {
	var (
		haystack = `GoFrame是一款模块化、高性能、企业级的Go基础开发框架`
		needle   = `GO`
		posI     = gstr.PosIRune(haystack, needle)
		posR     = gstr.PosRIRune(haystack, needle)
	)
	fmt.Println(posI)
	fmt.Println(posR)

	// Output:
	// 0
	// 22
}

查找替换

`Replace`

说明：Replace返回origin字符串中, search被replace替换后的新字符串。search区分大小写。

格式：

Replace(origin, search, replace string, count ...int) string

示例：

func ExampleReplace() {
	var (
		origin  = `golang is very nice!`
		search  = `golang`
		replace = `goframe`
		result  = gstr.Replace(origin, search, replace)
	)
	fmt.Println(result)

	// Output:
	// goframe is very nice!
}

`ReplaceI`

说明：ReplaceI返回origin字符串中, search被replace替换后的新字符串。search不区分大小写。

格式：

ReplaceI(origin, search, replace string, count ...int) string

示例：

func ExampleReplaceI() {
	var (
		origin  = `golang is very nice!`
		search  = `GOLANG`
		replace = `goframe`
		result  = gstr.ReplaceI(origin, search, replace)
	)
	fmt.Println(result)

	// Output:
	// goframe is very nice!
}

`ReplaceByArray`

说明：ReplaceByArray返回origin被一个切片按两个一组(search, replace)顺序替换的新字符串，区分大小写。

格式：

ReplaceByArray(origin string, array []string) string

示例：

func ExampleReplaceByArray() {
	{
		var (
			origin = `golang is very nice`
			array  = []string{"lang", "frame"}
			result = gstr.ReplaceByArray(origin, array)
		)
		fmt.Println(result)
	}
	{
		var (
			origin = `golang is very good`
			array  = []string{"golang", "goframe", "good", "nice"}
			result = gstr.ReplaceByArray(origin, array)
		)
		fmt.Println(result)
	}

	// Output:
	// goframe is very nice
	// goframe is very nice
}

`ReplaceIByArray`

说明：ReplaceIByArray返回origin被一个切片按两个一组(search, replace)顺序替换的新字符串，不区分大小写。

格式：

ReplaceIByArray(origin string, array []string) string

示例：

func ExampleReplaceIByArray() {
	var (
		origin = `golang is very Good`
		array  = []string{"Golang", "goframe", "GOOD", "nice"}
		result = gstr.ReplaceIByArray(origin, array)
	)

	fmt.Println(result)

	// Output:
	// goframe is very nice
}

`ReplaceByMap`

说明：ReplaceByMap返回origin中map的key替换为value的新字符串，区分大小写。

格式：

ReplaceByMap(origin string, replaces map[string]string) string

示例：

func ExampleReplaceByMap() {
	{
		var (
			origin   = `golang is very nice`
			replaces = map[string]string{
				"lang": "frame",
			}
			result = gstr.ReplaceByMap(origin, replaces)
		)
		fmt.Println(result)
	}
	{
		var (
			origin   = `golang is very good`
			replaces = map[string]string{
				"golang": "goframe",
				"good":   "nice",
			}
			result = gstr.ReplaceByMap(origin, replaces)
		)
		fmt.Println(result)
	}

	// Output:
	// goframe is very nice
	// goframe is very nice
}

`ReplaceIByMap`

说明：ReplaceIByMap返回origin中map的key替换为value的新字符串，不区分大小写。

格式：

ReplaceIByMap(origin string, replaces map[string]string) string

示例：

func ExampleReplaceIByMap() {
	var (
		origin   = `golang is very nice`
		replaces = map[string]string{
			"Lang": "frame",
		}
		result = gstr.ReplaceIByMap(origin, replaces)
	)
	fmt.Println(result)

	// Output:
	// goframe is very nice
}

子串截取

`Str`

说明：Str返回从needle第一次出现的位置开始，到haystack结尾的字符串（包含needle本身）。

格式：

Str(haystack string, needle string) string

示例：

func ExampleStr() {
	var (
		haystack = `xxx.jpg`
		needle   = `.`
		result   = gstr.Str(haystack, needle)
	)
	fmt.Println(result)

	// Output:
	// .jpg
}

`StrEx`

说明：StrEx返回从needle第一次出现的位置开始，到haystack结尾的字符串（不包含needle本身）。

格式：

StrEx(haystack string, needle string) string

示例：

func ExampleStrEx() {
	var (
		haystack = `https://goframe.org/index.html?a=1&b=2`
		needle   = `?`
		result   = gstr.StrEx(haystack, needle)
	)
	fmt.Println(result)

	// Output:
	// a=1&b=2
}

`StrTill`

说明：StrTill返回从haystack字符串开始到needle第一次出现的位置的字符串（包含needle本身）。

格式：

StrTill(haystack string, needle string) string

示例：

func ExampleStrTill() {
	var (
		haystack = `https://goframe.org/index.html?test=123456`
		needle   = `?`
		result   = gstr.StrTill(haystack, needle)
	)
	fmt.Println(result)

	// Output:
	// https://goframe.org/index.html?
}

`StrTillEx`

说明：StrTillEx返回从haystack字符串开始到needle第一次出现的位置的字符串（不包含needle本身）。

格式：

StrTillEx(haystack string, needle string) string

示例：

func ExampleStrTillEx() {
	var (
		haystack = `https://goframe.org/index.html?test=123456`
		needle   = `?`
		result   = gstr.StrTillEx(haystack, needle)
	)
	fmt.Println(result)

	// Output:
	// https://goframe.org/index.html
}

`SubStr`

说明：SubStr返回字符串str从start开始，长度为length的新字符串。参数length是可选的，它默认使用str的长度。

格式：

SubStr(str string, start int, length ...int) (substr string)

示例：

func ExampleSubStr() {
	var (
		str    = `1234567890`
		start  = 0
		length = 4
		subStr = gstr.SubStr(str, start, length)
	)
	fmt.Println(subStr)

	// Output:
	// 1234
}

`SubStrRune`

说明：SubStrRune返回unicode字符串str从start开始，长度为length的新字符串。参数length是可选的，它默认使用str的长度。

格式：

SubStrRune(str string, start int, length ...int) (substr string)

示例：

func ExampleSubStrRune() {
	var (
		str    = `GoFrame是一款模块化、高性能、企业级的Go基础开发框架。`
		start  = 14
		length = 3
		subStr = gstr.SubStrRune(str, start, length)
	)
	fmt.Println(subStr)

	// Output:
	// 高性能
}

`StrLimit`

说明：StrLimit取str字符串开始，长度为length的字符串，加上suffix...后返回新的字符串。

格式：

StrLimit(str string, length int, suffix ...string) string

示例：

func ExampleStrLimit() {
	var (
		str    = `123456789`
		length = 3
		suffix = `...`
		result = gstr.StrLimit(str, length, suffix)
	)
	fmt.Println(result)

	// Output:
	// 123...
}

`StrLimitRune`

说明：StrLimitRune取unicode字符串str开始，长度为length的字符串，加上suffix...后返回新的字符串。

格式：

StrLimitRune(str string, length int, suffix ...string) string

示例：

func ExampleStrLimitRune() {
	var (
		str    = `GoFrame是一款模块化、高性能、企业级的Go基础开发框架。`
		length = 17
		suffix = "..."
		result = gstr.StrLimitRune(str, length, suffix)
	)
	fmt.Println(result)

	// Output:
	// GoFrame是一款模块化、高性能...
}

`SubStrFrom`

说明：SubStrFrom返回字符串str从第一次出现need到str的结尾的字符串（包含need）。

格式：

SubStrFrom(str string, need string) (substr string)

示例：

func ExampleSubStrFrom() {
	var (
		str  = "我爱GoFrameGood"
		need = `爱`
	)

	fmt.Println(gstr.SubStrFrom(str, need))

	// Output:
	// 爱GoFrameGood
}

`SubStrFromEx`

说明：SubStrFromEx返回字符串str从第一次出现need到str的结尾的字符串（不包含need）。

格式：

SubStrFromEx(str string, need string) (substr string)

示例：

func ExampleSubStrFromEx() {
	var (
		str  = "我爱GoFrameGood"
		need = `爱`
	)

	fmt.Println(gstr.SubStrFromEx(str, need))

	// Output:
	// GoFrameGood
}

`SubStrFromR`

说明：SubStrFromR返回字符串str从最后一次出现need到str的结尾的字符串（包含need）。

格式：

SubStrFromR(str string, need string) (substr string)

示例：

func ExampleSubStrFromR() {
	var (
		str  = "我爱GoFrameGood"
		need = `Go`
	)

	fmt.Println(gstr.SubStrFromR(str, need))

	// Output:
	// Good
}

`SubStrFromREx`

说明：SubStrFromREx返回字符串str从最后一次出现need到str的结尾的字符串（不包含need）。

格式：

SubStrFromREx(str string, need string) (substr string)

示例：

func ExampleSubStrFromREx() {
	var (
		str  = "我爱GoFrameGood"
		need = `Go`
	)

	fmt.Println(gstr.SubStrFromREx(str, need))

	// Output:
	// od
}

字符/子串过滤

`Trim`

说明：Trim从字符串的开头和结尾剪切空白(或其他字符)。可选参数characterMask指定额外剥离的字符。

格式：

Trim(str string, characterMask ...string) string

示例：

func ExampleTrim() {
	var (
		str           = `*Hello World*`
		characterMask = "*d"
		result        = gstr.Trim(str, characterMask)
	)
	fmt.Println(result)

	// Output:
	// Hello Worl
}

`TrimStr`

说明：TrimStr从字符串的开头和结尾去掉所有cut字符串（不会删除开头或结尾的空白）。

格式：

TrimStr(str string, cut string, count ...int) string

示例：

func ExampleTrimStr() {
	var (
		str    = `Hello World`
		cut    = "World"
		count  = -1
		result = gstr.TrimStr(str, cut, count)
	)
	fmt.Println(result)

	// Output:
	// Hello
}

`TrimLeft`

说明：TrimLeft将字符串开头的空格(或其他字符)删除。

格式：

TrimLeft(str string, characterMask ...string) string

示例：

func ExampleTrimLeft() {
	var (
		str           = `*Hello World*`
		characterMask = "*"
		result        = gstr.TrimLeft(str, characterMask)
	)
	fmt.Println(result)

	// Output:
	// Hello World*
}

`TrimLeftStr`

说明：TrimLeftStr从字符串的开头删除count个cut字符串（不会删除开头的空格）。

格式：

TrimLeftStr(str string, cut string, count ...int) string

示例：

func ExampleTrimLeftStr() {
	var (
		str    = `**Hello World**`
		cut    = "*"
		count  = 1
		result = gstr.TrimLeftStr(str, cut, count)
	)
	fmt.Println(result)

	// Output:
	// *Hello World**
}

`TrimRight`

说明：TrimRight从字符串的末尾去掉空白(或其他字符)。

格式：

TrimRight(str string, characterMask ...string) string

示例：

func ExampleTrimRight() {
	var (
		str           = `**Hello World**`
		characterMask = "*def" // []byte{"*", "d", "e", "f"}
		result        = gstr.TrimRight(str, characterMask)
	)
	fmt.Println(result)

	// Output:
	// **Hello Worl
}

`TrimRightStr`

说明：TrimRightStr从字符串的尾部删除count个cut字符串（不会删除尾部的空格）。

格式：

TrimRightStr(str string, cut string, count ...int) string

示例：

func ExampleTrimRightStr() {
	var (
		str    = `Hello World!`
		cut    = "!"
		count  = -1
		result = gstr.TrimRightStr(str, cut, count)
	)
	fmt.Println(result)

	// Output:
	// Hello World
}

`TrimAll`

说明：TrimAll删除字符串str中的所有空格(或其他字符)以及characterMask字符。

格式：

TrimAll(str string, characterMask ...string) string

示例：

func ExampleTrimAll() {
	var (
		str           = `*Hello World*`
		characterMask = "*"
		result        = gstr.TrimAll(str, characterMask)
	)
	fmt.Println(result)

	// Output:
	// HelloWorld
}

`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
}

版本比较

`CompareVersion`

说明：CompareVersion将a和b作为标准GNU版本进行比较。
格式：
```
CompareVersion(a, b string) int
```

示例：

func ExampleCompareVersion() {
	fmt.Println(gstr.CompareVersion("v2.11.9", "v2.10.8"))
	fmt.Println(gstr.CompareVersion("1.10.8", "1.19.7"))
	fmt.Println(gstr.CompareVersion("2.8.beta", "2.8"))

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

`CompareVersionGo`

说明：CompareVersionGo将a和b作为标准的Golang版本进行比较。
格式：
```
CompareVersionGo(a, b string) int
```

示例：

func ExampleCompareVersionGo() {
	fmt.Println(gstr.CompareVersionGo("v2.11.9", "v2.10.8"))
	fmt.Println(gstr.CompareVersionGo("v4.20.1", "v4.20.1+incompatible"))
	fmt.Println(gstr.CompareVersionGo(
		"v0.0.2-20180626092158-b2ccc119800e",
		"v1.0.1-20190626092158-b2ccc519800e",
	))

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

相似计算

`Levenshtein`

说明：Levenshtein计算两个字符串之间的Levenshtein距离。

格式：

Levenshtein(str1, str2 string, costIns, costRep, costDel int) int

示例：

func ExampleLevenshtein() {
	var (
		str1    = "Hello World"
		str2    = "hallo World"
		costIns = 1
		costRep = 1
		costDel = 1
		result  = gstr.Levenshtein(str1, str2, costIns, costRep, costDel)
	)
	fmt.Println(result)

	// Output:
	// 2
}

`SimilarText`

说明：SimilarText计算两个字符串之间的相似度。

格式：

SimilarText(first, second string, percent *float64) int

示例：

func ExampleSimilarText() {
	var (
		first   = `AaBbCcDd`
		second  = `ad`
		percent = 0.80
		result  = gstr.SimilarText(first, second, &percent)
	)
	fmt.Println(result)

	// Output:
	// 2
}

`Soundex`

说明：Soundex用于计算字符串的Soundex键。
格式：
```
Soundex(str string) string
```

示例：

func ExampleSoundex() {
	var (
		str1    = `Hello`
		str2    = `Hallo`
		result1 = gstr.Soundex(str1)
		result2 = gstr.Soundex(str2)
	)
	fmt.Println(result1, result2)

	// Output:
	// H400 H400
}

Content Menu

Space shortcuts

Page tree

字符串处理-gstr

字符串判断

IsNumeric

字符串长度

LenRune

字符串创建

Repeat

大小写转换

ToLower

ToUpper

UcFirst

LcFirst

UcWords

IsLetterLower

IsLetterUpper

字符串比较

Compare

Equal

切分组合

Split

SplitAndTrim

Join

JoinAny

Explode

Implode

ChunkSplit

Fields