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

使用方式：

Code Block

language	go

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

接口文档：

https://godocpkg.go.orgdev/github.com/gogf/gf/v2/text/gstr

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

常用方法

字符串判断

Count

`IsNumeric`

说明：Count计算substr在s中出现的次数。如果在s中没有找到substr，则返回0。 IsNumeric验证字符串s是否为数字。

格式：

Code Block

language	go

CountIsNumeric(s, substr string) intbool

示例：

Code Block

language	go

func ExampleCountExampleIsNumeric() {
	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`

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

字符串长度

`LenRune`

说明：LenRune返回unicode字符串长度。说明：Count计算substr在s中出现的次数，不区分大小写。如果在s中没有找到substr，则返回0。
格式：
Code Block
language go
CountILenRune(s,str substr string) int

示例：

Code Block

language	go

func ExampleCountIExampleLenRune() {
	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`GoFrame框架`
		result = gstr.LenRune(str)
	)
	fmt.Println(result)

	// Output:
	// 1
	// 2
9
}

`ToLower`

字符串创建

`Repeat`

说明：Repeat返回一个由input重复multiplier次后组成的新字符串。说明：ToLower将s中所有Unicode字符都变为小写并返回其副本。

格式：

Code Block

language	go

ToLowerRepeat(sinput string, multiplier int) string

示例：

Code Block

language	go

func ExampleToLowerExampleRepeat() {
	var (
		sinput      = `goframe `GOFRAME``
		multiplier = 3
		result     = gstr.ToLower(sRepeat(input, multiplier)
	)
	fmt.Println(result)

	// Output:
	// goframe goframe goframe
}

大小写转换

ToUpper

`ToLower`

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

示例：

Code Block

language	go

func ExampleToUpperExampleToLower() {
	var (
		s      = `goframe``GOFRAME`
		result = gstr.ToUpperToLower(s)
	)
	fmt.Println(result)

	// Output:
	// GOFRAMEgoframe
}

UcFirst

`ToUpper`

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

示例：

Code Block

language	go

func ExampleUcFirstExampleToUpper() {
	var (
		s      = `hello``goframe`
		result = gstr.UcFirstToUpper(s)
	)
	fmt.Println(result)

	// Output:
	// HelloGOFRAME
}

LcFirst

`UcFirst`

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

示例：

Code Block

language	go

func ExampleLcFirstExampleUcFirst() {
	var (
		strs      = `Goframe``hello`
		result = gstr.LcFirstUcFirst(strs)
	)
	fmt.Println(result)

	// Output:
	// goframeHello
}

UcWords

`LcFirst`

说明：UcWords将字符串str中每个单词的第一个字符变为大写。LcFirst将s中首字符变为小写并返回其副本。
格式：
Code Block
language go
UcWordsLcFirst(strs string) string

示例：

Code Block

language	go

func ExampleUcWordsExampleLcFirst() {
	var (
		str    = `hello world``Goframe`
		result = gstr.UcWordsLcFirst(str)
	)
	fmt.Println(result)

	// Output:
	// Hello World
}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`

字符串比较

`Compare`

说明：Compare返回一个按字典顺序比较两个字符串的整数。如果a == b，结果为0，如果a < b，结果为-1，如果a > b，结果为+1。说明：IsNumeric验证字符串s是否为数字。
格式：
Code Block
language go
IsNumeric(sCompare(a, b string) boolint

示例：

Code Block

language	go

func ExampleIsNumericExampleCompare() {
	fmt.Println(gstr.IsNumericCompare("88"c", "c"))
	fmt.Println(gstr.IsNumericCompare("3.1415926a", "b"))
	fmt.Println(gstr.IsNumericCompare("abc"c", "b"))

	// Output:
	// true0
	// true-1
	// false1
}

Reverse

`Equal`

说明：Reverse返回str的反转字符串。 Equal返回a和b在不区分大小写的情况下是否相等。

格式：

Code Block

language	go

Reverse(strEqual(a, b string) stringbool

示例：

Code Block

language	go

func ExampleReverseExampleEqual() {
	var (
		str    = `123456`
		result = gstr.Reverse(str)
	fmt.Println(gstr.Equal(`A`, `a`))
	fmt.Println(gstr.Equal(`A`, `A`))
	fmt.Println(resultgstr.Equal(`A`, `B`))

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

切分组合

`NumberFormat`

`Split`

说明：Split用delimiter将str拆分为[]string。
说明：NumberFormat以千位分组来格式化数字。
参数decimal设置小数点的个数。
参数decPoint设置小数点的分隔符。

参数

thousand

设置千位分隔符。

格式：

Code Block

language	go

NumberFormatSplit(number float64str, decimals int, decPoint, thousandsSep delimiter string) []string

示例：

Code Block

language	go

func ExampleNumberFormatExampleSplit() {
	var (
		numberstr       float64 = 123456`a|b|c|d`
		decimals             = 2
		decPoint             = "."
		thousandsSep         = ","
		result               delimiter = `|`
		result    = gstr.NumberFormatSplit(numberstr, decimals, decPoint, thousandsSepdelimiter)
	)
	fmt.PrintlnPrintf(`%#v`, result)

	// Output:
	// 123,456.00
}

`ChunkSplit`

[]string{"a", "b", "c", "d"} }

`SplitAndTrim`

说明： SplitAndTrim使用delimiter将str拆分为[]string，并对[]string的每个元素调用Trim，并忽略在Trim之后为空的元素。说明：ChunkSplit将字符串拆分为单位为chunkLen长度更小的每一份，并用end连接每一份拆分出的字符串。

格式：

Code Block

language	go

ChunkSplitSplitAndTrim(body stringstr, chunkLendelimiter intstring, endcharacterMask ...string) []string

示例：

Code Block

language	go

func ExampleChunkSplitExampleSplitAndTrim() {
	var (
		bodystr     = `1234567890`
		chunkLen = 2`a|b|||||c|d`
		end    delimiter  = "#"`|`
		result    = gstr.ChunkSplitSplitAndTrim(bodystr, chunkLen, enddelimiter)
	)
	fmt.PrintlnPrintf(`%#v`, result)

	// Output:
	// 12#34#56#78#90#[]string{"a", "b", "c", "d"}
}

`Compare`

`Join`

说明：Join将array中的每一个元素连接并生成一个新的字符串。参数sep会作为新字符串的分隔符。说明：Compare返回一个按字典顺序比较两个字符串的整数。如果a == b，结果为0，如果a < b，结果为-1，如果a > b，结果为+1。

格式：

Code Block

language	go

Compare(aJoin(array []string, bsep string) intstring

示例：

Code Block

language	go

func ExampleCompareExampleJoin() {
	fmt.Println(gstr.Compare("cvar (
		array  = []string{"goframe", "c"))
	fmt.Println(gstr.Compare("a", "b")is", "very", "easy", "to", "use"}
		sep    = ` `
		result = gstr.Join(array, sep)
	)
	fmt.Println(gstr.Compare("c", "b")result)

	// Output:
	// 0
	// -1
	// 1 goframe is very easy to use
}

Equal

`JoinAny`

说明：Equal返回a和b在不区分大小写的情况下是否相等。JoinAny将array中的每一个元素连接并生成一个新的字符串。参数sep会作为新字符串的分隔符。参数array可以是任意的类型。

格式：

Code Block

language	go

Equal(aJoinAny(array interface{}, bsep string) boolstring

示例：

Code Block

language	go

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

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

`Fields`

99,73,85,66 }

`Explode`

说明：Explode使用分隔符delimiter字符串str拆分成[]string说明：Fields以[]string的形式返回字符串中的每个单词。

格式：

Code Block

language	go

FieldsExplode(delimiter, str string) []string

示例：

Code Block

language	go

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

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

HasPrefix

`Implode`

说明：HasPrefix返回s是否以prefix开头。Implode使用glue连接pieces字符串数组的每一个元素。

格式：

Code Block

language	go

HasPrefixImplode(sglue string, prefixpieces []string) boolstring

示例：

Code Block

language	go

func ExampleHasPrefixExampleImplode() {
	var (
		spieces = []string{"goframe", "is", "very",  = `Hello World`"easy", "to", "use"}
		prefixglue   = "Hello "
		result = gstr.HasPrefixImplode(sglue, prefixpieces)
	)
	fmt.Println(result)

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

HasSuffix

`ChunkSplit`

说明：HasSuffix返回s是否以suffix 结束。ChunkSplit将字符串拆分为单位为chunkLen长度更小的每一份，并用end连接每一份拆分出的字符串。

格式：

Code Block

language	go

HasSuffix(sChunkSplit(body string, chunkLen int, suffixend string) boolstring

示例：

Code Block

language	go

func ExampleHasSuffixExampleChunkSplit() {
	var (
		sbody     = `1234567890`
		chunkLen = `my best love is goframe`
		prefix2
		end      = "goframe#"
		result   = gstr.HasSuffix(sChunkSplit(body, chunkLen, prefixend)
	)
	fmt.Println(result)

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

CountWords

`Fields`

说明：CountWordsFields以map[]string]int的形式返回str中使用的单词的统计信息。的形式返回字符串中的每个单词。

格式：

Code Block

language	go

CountWordsFields(str string) map[]string]int

示例：

Code Block

language	go

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

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

`CountChars`

转义处理

`AddSlashes`

说明：AddSlashes将字符串中的符号前添加转义字符'\'说明：CountChars以map[string]int的形式返回str中使用的字符的统计信息。noSpace参数可以控制是否计算空格。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

	fmt.Println(result)

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

`WordWrap`

\'aa\'\"bb\"cc\\r\\n\\d\\t }

`StripSlashes`

说明：StripSlashes去掉字符串str中的转义字符'\'。说明：WordWrap使用换行符将str换行到给定字符数（不会切分单词）。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

func ExampleWordWrapExampleStripSlashes() {
	{
		var (
			str    = `A very long woooooooooooooooooord. and something`
			width  = 8
			br     = "\n"
			`C:\\windows\\GoFrame\\test`
		result = gstr.WordWrapStripSlashes(str, width, br)
		)
		fmt.Println(result)
	}
	{
		var (
			str    = `The quick brown fox jumped over the lazy dog.`
			width  = 20
			br // 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    = "<br />\n"`.\+?[^]()`
			result = gstr.WordWrapQuoteMeta(str, width, br)
		)
		fmt.PrintfPrintln("%v", result)
	}
	{
	// Output:
	// A very
	// long
	// woooooooooooooooooord.
	// and	var (
			str    = `https://goframe.org/pages/viewpage.action?pageId=1114327`
			result = gstr.QuoteMeta(str)
		)
		fmt.Println(result)
	}

	// somethingOutput:
	// The quick brown fox<br />\.\\\+\?\[\^\]\(\)
	// jumped over the lazy<br />
	// dog.
}

`LenRune`

https://goframe\.org/pages/viewpage\.action\?pageId=1114327

}

统计计数

`Count`

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

示例：

Code Block

language	go

func ExampleLenRuneExampleCount() {
	var (
		str    = `GoFrame框架` = `goframe is very, very easy to use`
		substr1 = "goframe"
		substr2 = "very"
		result1 = gstr.Count(str, substr1)
		resultresult2 = gstr.LenRuneCount(str, substr2)
	)
	fmt.Println(resultresult1)
	fmt.Println(result2)

	// Output:
	// 1
	// 92
}

`Repeat`

`CountI`

说明：Count计算substr在s中出现的次数，不区分大小写。如果在s中没有找到substr，则返回0。说明：Repeat返回一个由input重复multiplier次后组成的新字符串。

格式：

Code Block

language	go

RepeatCountI(input strings, multipliersubstr intstring) stringint

示例：

Code Block

language	go

func ExampleRepeatExampleCountI() {
	var (
		inputstr      = `goframe `is very, very easy to use`
		multipliersubstr1 = 3"GOFRAME"
		result    substr2 = "VERY"
		result1 = gstr.CountI(str, substr1)
		result2 = gstr.RepeatCountI(inputstr, multipliersubstr2)
	)
	fmt.Println(resultresult1)

	/fmt.Println(result2)

	// Output:
	// goframe goframe goframe1
	// 2
}

Shuffle

`CountWords`

说明：Shuffle返回将str随机打散后的字符串。CountWords以map[string]int的形式返回str中使用的单词的统计信息。

格式：

Code Block

language	go

ShuffleCountWords(str string) map[string]int

示例：

Code Block

language	go

func ExampleShuffleExampleCountWords() {
	var (
		str    = `123456``goframe is very, very easy to use!`
		result = gstr.ShuffleCountWords(str)
	)
	fmt.PrintlnPrintf(`%#v`, result)

	// May Output:
	// 563214
}

`Split`

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

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

示例：

Code Block

language	go

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

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

`SplitAndTrim`

a:1 e:1 f:1 g:1 m:1 o:1 r:1] }

数组处理

`SearchArray`

说明：SearchArray在[]string 'a'中区分大小写地搜索字符串's'，返回其在'a'中的索引。如果在'a'中没有找到's'，则返回-1。
格式：
说明： SplitAndTrim使用delimiter将str拆分为[]string，并对[]string的每个元素调用Trim，并忽略在Trim之后为空的元素。

格式：

Code Block

language	go

SplitAndTrimSearchArray(str, delimiter a []string, characterMasks ...string) []stringint

示例：

Code Block

language	go

func ExampleSplitAndTrimExampleSearchArray() {
	var (
		strarray  = []string{"goframe", "is",   = `a|b|||||c|d`"very", "nice"}
		delimiterstr    = `|``goframe`
		result    = gstr.SplitAndTrimSearchArray(strarray, delimiterstr)
	)
	fmt.PrintfPrintln(`%#v`, result)

	// Output:
	// 0
}

`InArray`

说明：InArray校验[]string
{"a", "b", "c", "d"} }

`Join`

'a'中是否有字符串' s '。
说明：Join将array中的每一个元素连接并生成一个新的字符串。参数sep会作为新字符串的分隔符。

格式：

Code Block

language	go

JoinInArray(arraya []string, seps string) stringbool

示例：

Code Block

language	go

func ExampleJoinExampleInArray() {
	var (
		arraya      = []string{"goframe", "is", "very", "easy", "to", "use"}
		seps      = ` `"goframe"
		result = gstr.JoinInArray(arraya, seps)
	)
	fmt.Println(result)

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

JoinAny

`PrefixArray`

说明：JoinAny将array中的每一个元素连接并生成一个新的字符串。参数sep会作为新字符串的分隔符。参数array可以是任意的类型。PrefixArray位[]string array的每一个字符串添加'prefix'的前缀。

格式：

Code Block

language	go

JoinAnyPrefixArray(array interface{}[]string, sepprefix string) string

示例：

Code Block

language	go

func ExampleJoinAnyExamplePrefixArray() {
	var (
		sep    = `,`
		arr2   strArray = []intstring{99"tom", 73"lily", 85, 66"john"}
		result = )

	gstr.JoinAnyPrefixArray(arr2strArray, sep"classA_")
	)
	fmt.Println(resultstrArray)

	// Output:
	// 99,73,85,66[classA_tom classA_lily classA_john]
}

`Explode`

命名转换

`CaseCamel`

说明：CaseCamel将字符串转换为大驼峰形式(首字母大写)。说明：Explode使用分隔符delimiter字符串str拆分成[]string

格式：

Code Block

language	go

ExplodeCaseCamel(delimiter,s str string) []string

示例：

Code Block

language	go

func ExampleExplodeExampleCaseCamel() {
	var (
		str    =   = `Hello World`
		delimiter = " "`hello world`
		result    = gstr.ExplodeCaseCamel(delimiter, str)
	)
	fmt.PrintfPrintln(`%#v`, result)

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

Implode

`CaseCamelLower`

说明：Implode使用glue连接pieces字符串数组的每一个元素。CaseCamelLower将字符串转换为小驼峰形式(首字母小写)。

格式：

Code Block

language	go

Implode(glue string, pieces []CaseCamelLower(s string) string

示例：

Code Block

language	go

func ExampleImplodeExampleCaseCamelLower() {
	var (
		piecesstr = []string{"goframe", "is", "very", "easy", "to", "use"} = `hello world`
		glue result  = " "
		result = gstr.Implode(glue, piecesgstr.CaseCamelLower(str)
	)
	fmt.Println(result)

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

`Chr`

`CaseSnake`

说明：CaseSnake将字符串转换中的符号(下划线,空格,点,中横线)用下划线( _ )替换,并全部转换为小写字母。说明：Chr返回一个数字0-255对应的ascii字符串。
格式：
Code Block
language go
ChrCaseSnake(asciis intstring) string

示例：

Code Block

language	go

func ExampleChrExampleCaseSnake() {
	var (
		asciistr    = 65 // A`hello world`
		result = gstr.ChrCaseSnake(asciistr)
	)
	fmt.Println(result)

	// Output:
	// Ahello_world
}

Ord

`CaseSnakeScreaming`

说明：Ord将字符串的第一个字节转换为0-255之间的值。 CaseSnakeScreaming把字符串中的符号(下划线,空格,点,中横线),全部替换为下划线'_',并将所有英文字母转为大写。
格式：
Code Block
language go
CaseSnakeScreaming(s
格式：
Code Block
language go
Ord(char string) intstring

示例：

Code Block

language	go

func ExampleOrdExampleCaseSnakeScreaming() {
	var (
		str    = `goframe``hello world`
		result = gstr.OrdCaseSnakeScreaming(str)
	)

	fmt.Println(result)

	// Output:
	// 103HELLO_WORLD
}

`HideStr`

`CaseSnakeFirstUpper`

说明：CaseSnakeFirstUpper将字符串中的字母为大写时,将大写字母转换为小写字母并在其前面增加一个下划线'_',首字母大写时,只转换为小写,前面不增加下划线'_'。说明：HideStr将字符串str从中间字符开始，百分比percent的字符转换成hide字符串。

格式：

Code Block

language	go

HideStrCaseSnakeFirstUpper(strword string, percent int, hide underscore ...string) string

示例：

Code Block

language	go

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

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

Nl2Br

`CaseKebab`

说明：Nl2Br在字符串中的所有换行符之前插入HTML换行符(' br ' |<br />): \n\r， \r\n， \r， \n。 CaseKebab将字符串转换中的符号(下划线,空格,点,)用中横线'-'替换,并全部转换为小写字母。

格式：

Code Block

language	go

Nl2BrCaseKebab(strs string, isXhtml ...bool) string

示例：

Code Block

language	go

func ExampleNl2BrExampleCaseKebab() {
	var (
		str    = `goframe
is
very
easy
to
use`
`hello world`
		result = gstr.Nl2BrCaseKebab(str)
	)

	fmt.Println(result)

	// Output:
	// goframe<br>is<br>very<br>easy<br>to<br>usehello-world
}

AddSlashes

`CaseKebabScreaming`

说明：AddSlashes将字符串中的符号前添加转义字符'\'CaseKebabScreaming将字符串转换中的符号(下划线,空格,点,中横线)用中横线'-'替换,并全部转换为大写字母。

格式：

Code Block

language	go

AddSlashesCaseKebabScreaming(strs string) string

示例：

Code Block

language	go

func ExampleAddSlashesExampleCaseKebabScreaming() {
	var (
		str    = `'aa'"bb"cc\r\n\d\t``hello world`
		result = gstr.AddSlashesCaseKebabScreaming(str)
	)

	fmt.Println(result)

	// Output:
	// \'aa\'\"bb\"cc\\r\\n\\d\\tHELLO-WORLD
}

StripSlashes

`CaseDelimited`

说明：StripSlashes去掉字符串str中的转义字符'\'。CaseDelimited将字符串转换中的符号进行替换。

格式：

Code Block

language	go

StripSlashesCaseDelimited(strs string, del byte) string

示例：

Code Block

language	go

func ExampleStripSlashesExampleCaseDelimited() {
	var (
		str    = `C:\\windows\\GoFrame\\test``hello world`
		del    = byte('-')
		result = gstr.StripSlashesCaseDelimited(str, del)
	)
	fmt.Println(result)

	// Output:
	// C:\windows\GoFrame\testhello-world
}

QuoteMeta

`CaseDelimitedScreaming`

说明：QuoteMeta为str中'. \ + * ? [ ^ ] ( $ )中的每个字符前添加一个转义字符'\'。CaseDelimitedScreaming将字符串中的符号(空格,下划线,点,中横线)用第二个参数进行替换,该函数第二个参数为替换的字符,第三个参数为大小写转换,true为全部转换大写字母,false为全部转为小写字母。

格式：

Code Block

language	go

QuoteMetaCaseDelimitedScreaming(strs string, chars ...string del uint8, screaming bool) string

示例：

Code Block

language	go

func ExampleQuoteMetaExampleCaseDelimitedScreaming() {
	{
		var (
			str    = `.\+?[^]()``hello world`
			del    = byte('-')
			result = gstr.QuoteMetaCaseDelimitedScreaming(str, del, true)
		)
		fmt.Println(result)
	}
	{
		var (
			str    = `https://goframe.org/pages/viewpage.action?pageId=1114327` `hello world`
			del    = byte('-')
			result = gstr.QuoteMetaCaseDelimitedScreaming(str, del, false)
		)
		fmt.Println(result)
	}

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

}

Array

`SearchArray`

hello-world }

包含判断

`Contains`

说明：Contains返回字符串str是否包含子字符串substr，区分大小写。说明：SearchArray在[]string 'a'中区分大小写地搜索字符串's'，返回其在'a'中的索引。如果在'a'中没有找到's'，则返回-1。

格式：

Code Block

language	go

SearchArray(a []stringContains(str, ssubstr string) intbool

示例：

Code Block

language	go

func ExampleSearchArrayExampleContains() {
	{
		var (
		array	str  = []string{"goframe", "is", "very", "nice"}
		str    = `goframe`
		 = `Hello World`
			substr = `Hello`
			result = gstr.SearchArrayContains(arraystr, strsubstr)
		)
		fmt.Println(result)

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

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

InArray

`ContainsI`

说明：InArray校验[]string 'a'中是否有字符串' s '。 ContainsI校验substr是否在str中，不区分大小写。

格式：

Code Block

language	go

InArray(a []stringContainsI(str, ssubstr string) bool

示例：

Code Block

language	go

func ExampleInArrayExampleContainsI() {
	var (
		astr      = []string{"goframe", "is", "very", "easy", "to", "use"}
		s      = "goframe"
		result`Hello World`
		substr  = "hello"
		result1 = gstr.Contains(str, substr)
		result2 = gstr.InArrayContainsI(astr, ssubstr)
	)
	fmt.Println(result1)
	fmt.Println(resultresult2)

	// Output:
	// false
	// true
}

`PrefixArray`

`ContainsAny`

说明：ContainsAny校验s中是否包含chars。说明：PrefixArray位[]string array的每一个字符串添加'prefix'的前缀。

格式：

Code Block

language	go

PrefixArray(array []stringContainsAny(s, prefixchars string) bool

示例：

Code Block

language	go

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

	gstr.PrefixArray(strArray, "classA_")

 `goframe`
			chars  = "g"
			result = gstr.ContainsAny(s, chars)
		)
		fmt.Println(strArrayresult)
	}
	{
		//var Output:(
	// [classA_tom classA_lily classA_john]
}

Case

`CaseCamel`

			s      = `goframe`
			chars  = "G"
			result = gstr.ContainsAny(s, chars)
		)
		fmt.Println(result)
	}

	// Output:
	// true
	// false
}

字符串转换

`Chr`

说明：Chr返回一个数字0-255对应的ascii字符串。说明：CaseCamel将字符串转换为大驼峰形式(首字母大写)。
格式：
Code Block
language go
CaseCamelChr(sascii stringint) string

示例：

Code Block

language	go

func ExampleCaseCamelExampleChr() {
	var (
		strascii  = 65 = `hello world`// A
		result = gstr.CaseCamelChr(strascii)
	)
	fmt.Println(result)

	// Output:
	// HelloWorldA
}

CaseCamelLower

`Ord`

说明：CaseCamelLower将字符串转换为小驼峰形式(首字母小写)。Ord将字符串的第一个字节转换为0-255之间的值。

格式：

Code Block

language	go

CaseCamelLowerOrd(schar string) stringint

示例：

Code Block

language	go

func ExampleCaseCamelLowerExampleOrd() {
	var (
		str    = `hello world``goframe`
		result = gstr.CaseCamelLowerOrd(str)
	)

	fmt.Println(result)

	// Output:
	// helloWorld103
}

`CaseSnake`

`OctStr`

说明：OctStr将字符串str中的八进制字符串转换为其原始字符串。说明：CaseSnake将字符串转换中的符号(下划线,空格,点,中横线)用下划线( _ )替换,并全部转换为小写字母。
格式：
Code Block
language go
CaseSnakeOctStr(sstr string) string

示例：

Code Block

language	go

func ExampleCaseSnakeExampleOctStr() {
	var (
		str    = `hello world``\346\200\241`
		result = gstr.CaseSnakeOctStr(str)
	)
	fmt.Println(result)

	// Output:
	// hello_world怡
}

`CaseSnakeScreaming`

`Reverse`

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

格式：

Code Block

language	go

CaseSnakeScreamingReverse(sstr string) string

示例：

Code Block

language	go

func ExampleCaseSnakeScreamingExampleReverse() {
	var (
		str    = `hello world``123456`
		result = gstr.CaseSnakeScreamingReverse(str)
	)
	fmt.Println(result)

	// Output:
	// HELLO_WORLD
654321
}

`CaseSnakeFirstUpper`

`NumberFormat`

说明：NumberFormat以千位分组来格式化数字。
- 参数decimal设置小数点的个数。
- 参数decPoint设置小数点的分隔符。
- 参数thousand设置千位分隔符。
说明：CaseSnakeFirstUpper将字符串中的字母为大写时,将大写字母转换为小写字母并在其前面增加一个下划线'_',首字母大写时,只转换为小写,前面不增加下划线'_'。

格式：

Code Block

language	go

CaseSnakeFirstUpper(word string, underscore ...NumberFormat(number float64, decimals int, decPoint, thousandsSep string) string

示例：

Code Block

language	go

func ExampleCaseSnakeFirstUpperExampleNumberFormat() {
	var (
		strnumber       float64 = `RGBCodeMd5`123456
		resultdecimals             = gstr.CaseSnakeFirstUpper(str)2
	)
	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	decPoint             = "."
		thousandsSep         = `hello world`","
		result               = gstr.CaseKebab(str)
NumberFormat(number, decimals, decPoint, thousandsSep)
	)
	fmt.Println(result)

	// Output:
	// hello-world123,456.00
}

`CaseKebabScreaming`

`Shuffle`

说明：Shuffle返回将str随机打散后的字符串。说明：CaseKebabScreaming将字符串转换中的符号(下划线,空格,点,中横线)用中横线'-'替换,并全部转换为大写字母。

格式：

Code Block

language	go

CaseKebabScreamingShuffle(sstr string) string

示例：

Code Block

language	go

func ExampleCaseKebabScreamingExampleShuffle() {
	var (
		str    = `hello world``123456`
		result = gstr.CaseKebabScreamingShuffle(str)
	)
	fmt.Println(result)

	// May Output:
	// HELLO-WORLD563214
}

CaseDelimited

`HideStr`

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

格式：

Code Block

language	go

CaseDelimitedHideStr(sstr string, del bytepercent int, hide string) string

示例：

Code Block

language	go

func ExampleCaseDelimitedExampleHideStr() {
	var (
		str     = `hello world` `13800138000`
		percent = 40
		delhide    = byte('-')`*`
		result  = gstr.CaseDelimitedHideStr(str, percent, delhide)
	)
	fmt.Println(result)

	// Output:
	// hello-world138****8000
}

CaseDelimitedScreaming

`Nl2Br`

说明：CaseDelimitedScreaming将字符串中的符号(空格,下划线,点,中横线)用第二个参数进行替换,该函数第二个参数为替换的字符,第三个参数为大小写转换,true为全部转换大写字母,false为全部转为小写字母。Nl2Br在字符串中的所有换行符之前插入HTML换行符(' br ' |<br />): \n\r， \r\n， \r， \n。

格式：

Code Block

language	go

CaseDelimitedScreamingNl2Br(sstr string, del uint8, screaming isXhtml ...bool) string

示例：

Code Block

language	go

func ExampleCaseDelimitedScreamingExampleNl2Br() {
	{
		var (
			str    = `hello world``goframe
is
very
easy
to
use`
			del   result = byte('-')
			result = gstr.CaseDelimitedScreaming(str, del, true)
		)
		gstr.Nl2Br(str)
	)

	fmt.Println(result)

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

`WordWrap`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

func ExampleWordWrap() {
	{
		var (
			str    = `hello world` `A very long woooooooooooooooooord. and something`
			del  width  = byte('-')8
			br     = "\n"
			result = gstr.CaseDelimitedScreamingWordWrap(str, delwidth, falsebr)
		)
		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`The quick brown fox jumped over the lazy dog.`
			width  = 20
			br     = `Hello World`"<br />\n"
			substr = `hello`
			result = gstr.ContainsWordWrap(str, substrwidth, br)
		)
		fmt.PrintlnPrintf("%v", result)
	}

	// Output:
	// A very
	// truelong
	// false
}

`ContainsI`

woooooooooooooooooord.
	// and
	// something
	// The quick brown fox<br />
	// jumped over the lazy<br />
	// dog.
}

域名处理

`IsSubDomain`

说明：IsSubDomain校验subDomain是否为mainDomain的子域名。支持mainDomain中的'*'。说明：ContainsI校验substr是否在str中，不区分大小写。

格式：

Code Block

language	go

ContainsIIsSubDomain(strsubDomain string, substrmainDomain string) bool

示例：

Code Block

language	go

func ExampleContainsIExampleIsSubDomain() {
	var (
		str   subDomain  = `Hello World``s.goframe.org`
		substrmainDomain  = "hello"`goframe.org`
		result1result     = gstr.ContainsIsSubDomain(strsubDomain, substr)
		result2 = gstr.ContainsI(str, substrmainDomain)
	)
	fmt.Println(result1result)
	fmt.Println(result2)

	// Output:
	// false
	// true
}

`ContainsAny`

参数解析

`Parse`

说明：Parse解析字符串并以map[string]interface{}类型返回。说明：ContainsAny校验s中是否包含chars。

格式：

Code Block

language	go

ContainsAnyParse(s string) (result map[string]interface{}, charserr stringerror) bool

示例：

Code Block

language	go

func ExampleContainsAnyExampleParse() {
	{
		var (
			sstr       = `goframe``v1=m&v2=n`
			charsresult, _ = "g"gstr.Parse(str)
			result = gstr.ContainsAny(s, chars)
		)
		)
		fmt.Println(result)
	}
	{
		var (
			sstr       = `goframe`
			chars  = "G"`v[a][a]=m&v[a][b]=n`
			result, _ = gstr.ContainsAny(s, charsParse(str)
		)
		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)
	)
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)
	}
	// 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() {
	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 (
		str1	str    = "Hello World"
		str2 = `a  = "hallo World"
		costIns = 1
		costRep = 1
		costDel = 1
		result .[[b=c`
			result, _ = gstr.Levenshtein(str1, str2, costIns, costRep, costDelParse(str)
		)
		fmt.Println(result)
	}

	// May Output:
	// 2
}

Parse

`Parse`

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。

格式：

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

说明：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)
	}
	{// Output:
		// 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)
	}
	{
	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 (
			strhaystack = `goframe is very, very easy to use`
		needle = `a .[[b=c`= `very`
			result, _posI     = gstr.Parse(strPosI(haystack, needle)
		posR     = gstr.PosR(haystack, needle)
	)
	fmt.Println(resultposI)
	}fmt.Println(posR)

	// May Output:
	// map[v1:m v2:n]11
	// 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`

17 }

`PosRuneI`

说明：PosRuneI的作用于函数PosI相似，但支持haystack和needle为unicode字符串。说明：Pos返回needle在haystack中第一次出现的位置，区分大小写。如果没有找到，则返回-1。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

func ExamplePosExamplePosIRune() {
	{
		var (
			haystack    = `Hello World``GoFrame是一款模块化、高性能、企业级的Go基础开发框架`
			needle      = `高性能`
			startOffset = `World`10
			result      = gstr.PosPosIRune(haystack, needle, startOffset)
		)
		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    startOffset = gstr.PosRune(haystack, needle)30
		posR	result      = gstr.PosRRunePosIRune(haystack, needle, startOffset)
		)
		fmt.Println(posIresult)
	fmt.Println(posR)}

	// Output:
	// 014
	// 22-1
}

PosI

`PosR`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

func ExamplePosIExamplePosR() {
	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

`PosRuneR`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

func ExamplePosIRuneExamplePosRRune() {
	{
		var (
			haystack    = `GoFrame是一款模块化、高性能、企业级的Go基础开发框架`
			needle      = `高性能``Go`
			startOffsetposI     = 10 gstr.PosIRune(haystack, needle)
			result posR     = gstr.PosIRunePosRRune(haystack, needle, startOffset)
		)
		fmt.Println(resultposI)
	}
	{
		var (
			haystack    = `GoFrame是一款模块化、高性能、企业级的Go基础开发框架`
			needle      = `高性能`
			startOffset = 30
			resultfmt.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.PosIRunePosI(haystack, needle)
		posR     = gstr.PosRI(haystack, startOffsetneedle)
	)
	fmt.Println(posI)
		fmt.Println(result)
	}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返回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
}

子串截取

`Str`

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

格式：

Code Block

language	go

Str(haystack string, needle string) string

示例：

Code Block

language	go

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

	// Output:
	// .jpg
}

`StrEx`

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

格式：

Code Block

language	go

StrEx(haystack string, needle string) string

示例：

Code Block

language	go

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本身）。

格式：

Code Block

language	go

StrTill(haystack string, needle string) string

示例：

Code Block

language	go

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本身）。

格式：

Code Block

language	go

StrTillEx(haystack string, needle string) string

示例：

Code Block

language	go

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的长度。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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的长度。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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...后返回新的字符串。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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...后返回新的字符串。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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）。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

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

	// Output:
	// 爱GoFrameGood
}

`SubStrFromEx`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

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

	// Output:
	// GoFrameGood
}

`SubStrFromR`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

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

	// Output:
	// Good
}

`SubStrFromREx`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

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

	// Output:
	// od
}

字符/子串过滤

`Trim`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

	// Output:
	// Hello Worl
}

`TrimStr`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

	// Output:
	// Hello
}

`TrimLeft`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

	// Output:
	// Hello World*
}

`TrimLeftStr`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

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

`TrimRight`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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字符串（不会删除尾部的空格）。

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

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

	// Output:
	// HelloWorld
}

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

版本比较

`CompareVersion`

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

示例：

Code Block

language	go

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:
	// 141
	// -1
	// 0
}

`PosR`

`CompareVersionGo`

说明：CompareVersionGo将a和b作为标准的Golang版本进行比较。说明：PosR返回needle在haystack中最后一次出现的位置，区分大小写。如果没有找到，则返回-1。

格式：

Code Block

language	go

PosRCompareVersionGo(haystacka, needleb string, startOffset ...int) int

示例：

Code Block

language	go

func ExamplePosRExampleCompareVersionGo() {
	var (
		haystack = `goframe is very, very easy to use`
		needle   = `very`
		posI     = gstr.PosI(haystack, needle)
		posR     = gstr.PosR(haystack, needle)
	fmt.Println(gstr.CompareVersionGo("v2.11.9", "v2.10.8"))
	fmt.Println(gstr.CompareVersionGo("v4.20.1", "v4.20.1+incompatible"))
	fmt.Println(posI)
	fmt.Println(posRgstr.CompareVersionGo(
		"v0.0.2-20180626092158-b2ccc119800e",
		"v1.0.1-20190626092158-b2ccc519800e",
	))

	// Output:
	// 1
	// 111
	// 17-1
}

相似计算

`PosRuneR`

`Levenshtein`

说明：Levenshtein计算两个字符串之间的Levenshtein距离。说明：PosRuneR的作用于函数PosR相似，但支持haystack和needle为unicode字符串。

格式：

Code Block

language	go

PosRRuneLevenshtein(haystackstr1, needlestr2 string, costIns, costRep, startOffsetcostDel ...int) int

示例：

Code Block

language	go

func ExamplePosRRuneExampleLevenshtein() {
	var (
		haystackstr1    = "Hello `GoFrame是一款模块化、高性能、企业级的Go基础开发框架`World"
		needlestr2    = "hallo `Go`World"
		posIcostIns = 1
		costRep = 1
		costDel = gstr.PosIRune(haystack, needle)1
		posRresult     = gstr.PosRRune(haystackLevenshtein(str1, str2, costIns, costRep, needlecostDel)
	)
	fmt.Println(posIresult)
	fmt.Println(posR)

	// Output:
	// 0
	// 222
}

PosRI

`SimilarText`

说明：PosRI返回needle在haystack中最后一次出现的位置，不区分大小写。如果没有找到，则返回-1。 SimilarText计算两个字符串之间的相似度。

格式：

Code Block

language	go

PosRISimilarText(haystackfirst, needlesecond string, startOffset ...intpercent *float64) int

示例：

Code Block

language	go

func ExamplePosRIExampleSimilarText() {
	var (
		haystack =first `goframe is very, very easy to use`= `AaBbCcDd`
		needlesecond   = `VERY``ad`
		posIpercent     = gstr.PosI(haystack, needle)0.80
		posR result    = gstr.PosRI(haystackSimilarText(first, second, needle&percent)
	)
	fmt.Println(posI)
	fmt.Println(posRresult)

	// Output:
	// 11
	// 17
2
}

PosRIRune

`Soundex`

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

格式：

Code Block

language	go

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

示例：

Code Block

language	go

func ExamplePosRIRuneExampleSoundex() {
	var (
		haystackstr1    = `GoFrame是一款模块化、高性能、企业级的Go基础开发框架``Hello`
		needlestr2    = `GO``Hallo`
		posIresult1     = gstr.PosIRune(haystack, needleSoundex(str1)
		posRresult2     = gstr.PosRIRune(haystack, needleSoundex(str2)
	)
	fmt.Println(posIresult1, result2)
	fmt.Println(posR)

	// Output:
	// 0
	// 22
}

Replace

`Count`

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

Panel

title	Content Menu

Table of Contents

Space shortcuts

Page tree

Page History

Versions Compared

Old Version 57

New Version Current

Key

字符串判断

IsNumeric

CountI

字符串长度

LenRune

ToLower

字符串创建

Repeat

大小写转换

ToLower

ToUpper

UcFirst

LcFirst

UcWords

IsLetterLower

IsLetterUpper

IsNumeric

字符串比较

Compare

Equal

切分组合

NumberFormat

Split

ChunkSplit

SplitAndTrim

Compare

Join

JoinAny

Fields

Explode

Implode

ChunkSplit

Fields

CountChars

转义处理

AddSlashes

WordWrap

StripSlashes

QuoteMeta

LenRune

统计计数

Count

Repeat

CountI

CountWords

Split

CountChars

SplitAndTrim

数组处理

SearchArray

InArray

Join

PrefixArray

Explode

命名转换

CaseCamel

CaseCamelLower

Chr

CaseSnake

CaseSnakeScreaming

HideStr

CaseSnakeFirstUpper

CaseKebab

CaseKebabScreaming

CaseDelimited

CaseDelimitedScreaming

Array

SearchArray

包含判断

Contains

ContainsI

PrefixArray

ContainsAny

`IsNumeric`

`CountI`

`LenRune`

`ToLower`

`Repeat`

`ToLower`

`ToUpper`

`UcFirst`

`LcFirst`

`UcWords`

`IsLetterLower`

`IsLetterUpper`

`IsNumeric`

`Compare`

`Equal`

`NumberFormat`

`Split`

`ChunkSplit`

`SplitAndTrim`

`Compare`

`Join`

`JoinAny`

`Fields`

`Explode`

`Implode`

`ChunkSplit`

`Fields`

`CountChars`

`AddSlashes`

`WordWrap`

`StripSlashes`

`QuoteMeta`

`LenRune`

`Count`

`Repeat`

`CountI`

`CountWords`

`Split`

`CountChars`

`SplitAndTrim`

`SearchArray`

`InArray`

`Join`

`PrefixArray`

`Explode`

`CaseCamel`

`CaseCamelLower`

`Chr`

`CaseSnake`

`CaseSnakeScreaming`

`HideStr`

`CaseSnakeFirstUpper`

`CaseKebab`

`CaseKebabScreaming`

`CaseDelimited`

`CaseDelimitedScreaming`

`SearchArray`

`Contains`

`ContainsI`

`PrefixArray`

`ContainsAny`

`CaseCamel`

`Chr`

`Ord`

`CaseSnake`

`OctStr`

`CaseSnakeScreaming`

`Reverse`

`CaseSnakeFirstUpper`

`NumberFormat`

`CaseKebab`

`CaseKebabScreaming`

`Shuffle`

`HideStr`

`Nl2Br`

`WordWrap`

`Contains`

`ContainsI`

`IsSubDomain`

`ContainsAny`