- LenRune
- Repeat
- Compare
切分组合
数组处理
命名转换
包含判断
字符串转换
域名处理
参数解析
位置查找
子串截取
- CompareVersion
相似计算

使用方式：

接口文档：

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

以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档：

字符串判断

说明：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(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
```
示例：

说明：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 (
        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(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 string, count ...int) string

示例：

说明：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 = "*"
        result        = gstr.Trim(str, characterMask)
    )
    fmt.Println(result)
    // Output:
    // Hello World
}

`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用于计算字符串的键。
示例：

字符串处理-gstr

字符串判断

字符串长度

LenRune

字符串创建

Repeat

大小写转换

ToLower

ToUpper

UcFirst

LcFirst

UcWords

IsLetterLower

IsLetterUpper

字符串比较

Compare

Equal

切分组合

Split

SplitAndTrim

Join

JoinAny

Explode

Implode

ChunkSplit

Fields

转义处理

AddSlashes

StripSlashes

QuoteMeta