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

使用方式：

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

接口文档：

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

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

常用方法

`Count`

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

示例：

Code Block

language	go

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。
格式：
Code Block
language go
CountI(s, substr string) int

示例：

Code Block

language	go

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字符都变为小写并返回其副本。
格式：
Code Block
language go
ToLower(s string) string

示例：

Code Block

language	go

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

	// Output:
	// goframe
}

`ToUpper`

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

示例：

Code Block

language	go

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

	// Output:
	// GOFRAME
}

`UcFirst`

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

示例：

Code Block

language	go

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

	// Output:
	// Hello
}

`LcFirst`

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

示例：

Code Block

language	go

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

	// Output:
	// goframe
}

`UcWords`

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

示例：

Code Block

language	go

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

	// Output:
	// Hello World
}

`IsLetterLower`

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

示例：

Code Block

language	go

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

	// Output:
	// true
	// false
}

`IsLetterUpper`

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

示例：

Code Block

language	go

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

	// Output:
	// true
	// false
}

`IsNumeric`

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

示例：

Code Block

language	go

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的反转字符串。
格式：
Code Block
language go
Reverse(str string) string

示例：

Code Block

language	go

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

	// Output:
	// 654321
}

`NumberFormat`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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连接每一份拆分出的字符串。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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。
格式：
Code Block
language go
Compare(a, b string) int

示例：

Code Block

language	go

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在不区分大小写的情况下是否相等。
格式：
Code Block
language go
Equal(a, b string) bool

示例：

Code Block

language	go

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的形式返回字符串中的每个单词。
格式：
Code Block
language go
Fields(str string) []string

示例：

Code Block

language	go

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

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

`HasPrefix`

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

示例：

Code Block

language	go

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

	// Output:
	// true
}

`HasSuffix`

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

示例：

Code Block

language	go

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中使用的单词的统计信息。
格式：
Code Block
language go
CountWords(str string) map[string]int

示例：

Code Block

language	go

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参数可以控制是否计算空格。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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换行到给定字符数（不会切分单词）。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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字符串长度。
格式：
Code Block
language go
LenRune(str string) int

示例：

Code Block

language	go

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

	// Output:
	// 9
}

`Repeat`

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

格式：

Code Block

language	go

Repeat(input string, multiplier int) string

示例：

Code Block

language	go

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

	// Output:
	// goframe goframe goframe
}

`Shuffle`

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

示例：

Code Block

language	go

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

	// May Output:
	// 563214
}

`Split`

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

示例：

Code Block

language	go

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之后为空的元素。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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会作为新字符串的分隔符。
格式：
Code Block
language go
Join(array []string, sep string) string

示例：

Code Block

language	go

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可以是任意的类型。

格式：

Code Block

language	go

JoinAny(array interface{}, sep string) string

示例：

Code Block

language	go

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
格式：
Code Block
language go
Explode(delimiter, str string) []string

示例：

Code Block

language	go

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

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

`Implode`

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

格式：

Code Block

language	go

Implode(glue string, pieces []string) string

示例：

Code Block

language	go

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字符串。
格式：
Code Block
language go
Chr(ascii int) string

示例：

Code Block

language	go

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

	// Output:
	// A
}

`Ord`

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

示例：

Code Block

language	go

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

	fmt.Println(result)

	// Output:
	// 103
}

`HideStr`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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将字符串中的符号前添加转义字符'\'
格式：
Code Block
language go
AddSlashes(str string) string

示例：

Code Block

language	go

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中的转义字符'\'。
格式：
Code Block
language go
StripSlashes(str string) string

示例：

Code Block

language	go

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

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

`QuoteMeta`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

}

Array

`SearchArray`

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

示例：

Code Block

language	go

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 '。
格式：
Code Block
language go
InArray(a []string, s string) bool

示例：

Code Block

language	go

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'的前缀。

格式：

Code Block

language	go

PrefixArray(array []string, prefix string)

示例：

Code Block

language	go

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

	gstr.PrefixArray(strArray, "classA_")

	fmt.Println(strArray)

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

Case

`CaseCamel`

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

示例：

Code Block

language	go

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

	// Output:
	// HelloWorld
}

`CaseCamelLower`

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

示例：

Code Block

language	go

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

	// Output:
	// helloWorld
}

`CaseSnake`

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

示例：

Code Block

language	go

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

	// Output:
	// hello_world
}

`CaseSnakeScreaming`

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

示例：

Code Block

language	go

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

	// Output:
	// HELLO_WORLD
}

`CaseSnakeFirstUpper`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

	// Output:
	// rgb_code_md5
}

`CaseKebab`

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

示例：

Code Block

language	go

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

	// Output:
	// hello-world
}

`CaseKebabScreaming`

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

示例：

Code Block

language	go

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

	// Output:
	// HELLO-WORLD
}

`CaseDelimited`

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

格式：

Code Block

language	go

CaseDelimited(s string, del byte) string

示例：

Code Block

language	go

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

	// Output:
	// hello-world
}

`CaseDelimitedScreaming`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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
}

Contain

`Contains`

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

示例：

Code Block

language	go

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中，不区分大小写。
格式：
Code Block
language go
ContainsI(str, substr string) bool

示例：

Code Block

language	go

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。
格式：
Code Block
language go
ContainsAny(s, chars string) bool

示例：

Code Block

language	go

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
}

Convert

`OctStr`

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

示例：

Code Block

language	go

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

	// Output:
	// 怡
}

Domain

`IsSubDomain`

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

格式：

Code Block

language	go

IsSubDomain(subDomain string, mainDomain string) bool

示例：

Code Block

language	go

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

	// Output:
	// true
}

Levenshtein

`Levenshtein`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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
}

Parse

`Parse`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

	// Output:
	// 6
}

`PosRune`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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字符串。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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字符串。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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字符串。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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不区分大小写。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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)顺序替换的新字符串，区分大小写。

格式：

Code Block

language	go

ReplaceByArray(origin string, array []string) string

示例：

Code Block

language	go

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)顺序替换的新字符串，不区分大小写。

格式：

Code Block

language	go

ReplaceIByArray(origin string, array []string) string

示例：

Code Block

language	go

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的新字符串，区分大小写。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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的新字符串，不区分大小写。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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
}

`Count`

说明：
格式：
Code Block
language go
示例：
Code Block
language go

Panel

title	Content Menu

Table of Contents

Space shortcuts

Page tree

Page History

Versions Compared

Old Version 58

New Version 59

Key

常用方法

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

Array

SearchArray

InArray

PrefixArray

Case

CaseCamel

CaseCamelLower

CaseSnake

CaseSnakeScreaming

CaseSnakeFirstUpper

CaseKebab

CaseKebabScreaming

CaseDelimited

CaseDelimitedScreaming

Contain

Contains

ContainsI

ContainsAny

Convert

OctStr

Domain

IsSubDomain

Levenshtein

Levenshtein

Parse

Parse

Pos

Pos

PosRune

PosI

PosRuneI

PosR

PosRuneR

PosRI

PosRIRune

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

`SearchArray`

`InArray`

`PrefixArray`

`CaseCamel`

`CaseCamelLower`

`CaseSnake`

`CaseSnakeScreaming`

`CaseSnakeFirstUpper`

`CaseKebab`

`CaseKebabScreaming`

`CaseDelimited`

`CaseDelimitedScreaming`

`Contains`

`ContainsI`

`ContainsAny`

`OctStr`

`IsSubDomain`

`Levenshtein`

`Parse`

`Pos`

`PosRune`

`PosI`

`PosRuneI`

`PosR`

`PosRuneR`

`PosRI`

`PosRIRune`

`Replace`

`ReplaceI`

`ReplaceByArray`

`ReplaceIByArray`

`ReplaceByMap`

`ReplaceIByMap`

`Count`