前缀和后缀

HasPrefix 判断字符串 s 是否以 prefix 开头

strings.HasPrefix(s, prefix string) bool

HasPrefix 判断字符串 s 是否以 prefix 开头

strings.HasSuffix(s, suffix string) bool

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {

	var str string = "hello world"

	// 前缀
	fmt.Printf("前缀包含 'hello' = %t\n", strings.HasPrefix(str,"hello"))
	fmt.Printf("前缀包含 'world' = %t\n", strings.HasPrefix(str,"world"))
	// 后缀
	fmt.Printf("后缀包含 'ld' = %t\n", strings.HasSuffix(str,"ld"))
}

输出：

前缀包含 'hello' = true
前缀包含 'world' = false
后缀包含 'ld' = true

字符串包含关系

Contains 判断字符串 s 是否包含 substr

Contains(s, substr string) bool

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {

	var str string = "hello world"

	// 判断包含关系
	fmt.Printf("字符串是否包含 'llo' = %t\n", strings.Contains(str,"llo"))
}

输出：

字符串是否包含 'llo' = true

判断子字符在父字符串中的位置

Index 返回字符串 substr 在字符串 s 中的第一个位置，-1 表示字符串 s 不包含 substr

Index(s, substr string) int

LastIndex 返回字符串 substr 在字符串 s 中的最后一个位置, -1 表示字符串 s 不包含 substr

LastIndex(s, substr string) int

如果需要查询非 ASCII 编码的字符在父字符串中的位置，建议使用以下函数来对字符进行定位：

IndexRune(s string, r rune) int

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {

	var str string = "hello world"

	// 判断字符串所在的位置(第一个位置)
	fmt.Printf("子字符串 'hello' 所在第一个位置 index = %d\n", strings.Index(str,"hello"))

	// 判断字符串所在的位置(最后一个位置)
	fmt.Printf("子字符串 'l' 所在最后一个位置 index = %d\n", strings.LastIndex(str,"l"))
}

输出：

子字符串 'hello' 所在第一个位置 index = 0
子字符串 'l' 所在最后一个位置 index = 9

字符串替换

Replace 用于将字符串 s 中的前 n 个字符串 old 替换为字符串 new，并返回一个新的字符串，如果 n = -1 则替换所有字符串 old 为字符串 new

Replace(s, old, new string, n int) string

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {

	var str string = "hello world, hello, hello"

	// 字符串替换
	fmt.Printf(" '你好' 替换第1个 'hello' = %s\n",strings.Replace(str,"hello","你好", 1))
	fmt.Printf(" '你好' 替换第2个以前的 'hello' = %s\n",strings.Replace(str,"hello","你好", 2))
	fmt.Printf(" '你好' 替换所有的 'hello' = %s\n",strings.Replace(str,"hello","你好", -1))
}

字符串出现的次数

Count 用于统计字符串 substr 出现在字符串 s 中的没有重叠的次数

Count(s, substr string) int

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {

	var str string = "hello world, hello, hello"
	var manyH string = "HHHHHHHH"

	// 字符串出现次数
	fmt.Printf(" 'hello' 出现的非重叠次数 = %d\n", strings.Count(str,"hello"))
	fmt.Printf(" 'HH' 出现的非重叠次数 = %d\n", strings.Count(manyH,"HH"))
}

输出：

 'hello' 出现的非重叠次数 = 3
 'HH' 出现的非重叠次数 = 4

重复字符串

Repeat 用于重复 count 次字符串 s 并返回新的字符串

Repeat(s string, count int) string

示例：

package main

import (
   "fmt"
   "strings"
)

func main() {
   // 重复字符串
   var originalStr = "hello"
   fmt.Printf("重复字符串 'hello' 3 次 = %s\n", strings.Repeat(originalStr,3))
}

输出：

重复字符串 'hello' 3 次 = hellohellohello

修改字符串大小写

ToLower 将字符串 s 全部转为小写

ToLower(s string) string

ToUpper 将字符串 s 全部转为大写

ToUpper(s string) string

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {

	var str string = "HELLO world"

	// 字符串全部转为小写
	fmt.Printf(" 'HELLO world' 转为小写 = %s\n", strings.ToLower(str))
	// 字符串全部转为大写
	fmt.Printf(" 'HELLO world' 转为大写 = %s\n", strings.ToUpper(str))
}

输出：

 'HELLO world' 转为小写 = hello world
 'HELLO world' 转为大写 = HELLO WORLD

修剪字符串

TrimLeft 用于剔除字符串 s 开头的字符串 cutset

TrimLeft(s string, cutset string) string

TrimRight 用于剔除字符串 s 末尾的字符串 cutset

TrimRight(s string, cutset string) string

TrimSpace 用于剔除字符串 s 开头和末尾的空格字符串

TrimSpace(s string) string

Trim 用于剔除掉字符串 s 开头和末尾的字符串 cutset

Trim(s string, cutset string) string

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {

	var str string = "hello world"

	// 剔除掉开头的字符串
	fmt.Printf("裁剪掉开头的字符串 'he' = %s\n", strings.TrimLeft(str,"he"))
	// 剔除掉末尾的字符串
	fmt.Printf("裁剪掉末尾的字符串 'ld' = %s\n", strings.TrimRight(str,"ld"))

	// 剔除掉开头和末尾的空格字符串
	var cutString string = " he  llo "
	fmt.Printf("裁剪掉开头和末尾的空白字符串 = %s\n", strings.TrimSpace(cutString))

	// 剔除掉开头和末尾指定的字符串
	var cutString1 string = "shellos"
	fmt.Printf("裁剪掉所有的空格字符串 = %s\n", strings.Trim(cutString1,"s"))
}

输出：

裁剪掉开头的字符串 'he' =  hello world
裁剪掉末尾的字符串 'ld' =  hello wor
裁剪掉开头和末尾的空白字符串 = he  llo
裁剪掉所有的空格字符串 = hello

字符串类型的 `slice` 与字符串之间的转换

Fields 将会利用空白符号来作为分隔符将字符串分割成若干小块，并返回一个 slice，如果字符串只包含空白符号，则返回一个长度为 0 的 slice。

Fields(s string) []string

Split 用于自定义分割符号 sep 来对指定字符串进行分割，同样返回 slice。

Split(s, sep string) []string

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {

	str := "The quick brown fox jumps over the lazy dog"
	sl := strings.Fields(str)
	fmt.Printf("根据空格分割成 slice：\n")
	fmt.Println(sl)

	fmt.Println()

	str2 := "The-quick-brown-fox-jumps-over-the-lazy-dog"
	sl2 := strings.Split(str2,"-")

	fmt.Printf("根据 '-' 分割成 slice：\n")
	fmt.Println(sl2)

	fmt.Println()

	str3 := strings.Join(sl2,"+")
	fmt.Printf("slice sl2 转为字符串以 '+' 连接：\n", )
	fmt.Println(str3)



}

输出：

根据空格分割成 slice：
[The quick brown fox jumps over the lazy dog]

根据 '-' 分割成 slice：
[The quick brown fox jumps over the lazy dog]

slice sl2 转为字符串以 '+' 连接：
The+quick+brown+fox+jumps+over+the+lazy+dog

字符串与数字类型间的转换

字符串转数字

ParseInt 把字符串 s 转化为 int64类型

base 表示进位制（2 到 36），如果 base 为 0，则根据字符串前缀判断，前缀 0x 表示 16 进制，前缀 0 表示 8 进制，否则是 10 进制
bitSize 表示结果的位宽（包括符号位），0 表示最大位宽

ParseInt(s string, base int, bitSize int) (i int64, err error)

示例：

package main

import (
	"fmt"
	"strconv"
)

func main() {

	num,error := strconv.ParseInt("11",2,0)
	fmt.Printf("num = %d\n", num)
	fmt.Printf("error = %v\n\n", error)

	num1,error1 := strconv.ParseInt("11",8,0)
	fmt.Printf("num1 = %d\n", num1)
	fmt.Printf("error1 = %v\n\n", error1)

	num2,error2 := strconv.ParseInt("11",10,0)
	fmt.Printf("num2 = %d\n", num2)
	fmt.Printf("error2 = %v\n\n", error2)

	num3,error3 := strconv.ParseInt("11",16,0)
	fmt.Printf("num3 = %d\n", num3)
	fmt.Printf("error3 = %v\n\n", error3)
}

输出：

num = 3
error = <nil>

num1 = 9
error1 = <nil>

num2 = 11
error2 = <nil>

num3 = 17
error3 = <nil>

ParseUint 和 ParseInt 一样，但是输出为正整数

ParseUint(s string, base int, bitSize int) (uint64, error)

Atoi 把字符串 s 转换为int类型，并返回 error

Atoi(s string) (int, error)

示例：

package main

import (
	"fmt"
	"strconv"
)

func main() {

	num,error := strconv.Atoi("1")

	fmt.Printf("num = %d\n",num)
	fmt.Println("error = ",error)
}

输出：

num = 1
error =  <nil>

ParseBool 把字符串 s 转换为 bool，并返回 error

ParseBool(str string) (bool, error)

ParseFloat 把字符串 s 转换为 float64，并返回 error

bitSize 表示结果的位宽（包括符号位），0 表示最大位宽

ParseFloat(s string, bitSize int) (float64, error)

FormatInt 把 i 转换为 string

base 表示进位制（2 到 36）

FormatInt(i int64, base int) string

FormatUint 和 FormatInt 一样，但是要为正整数

func FormatUint(i uint64, base int) string

数字转字符串

FormatUint 把 uint64 转为字符串

FormatUint(i uint64, base int) string

FormatInt 把 int64 转为字符串

FormatInt(i int64, base int) string

FormatBool 把 bool 转为字符串

FormatBool(b bool) string

FormatFloat 把 float64 转为字符串

1、f：要转换的浮点数

2、fmt：格式标记（b、e、E、f、g、G）

b (-ddddp±ddd，二进制指数)
e (-d.dddde±dd，十进制指数)
E (-d.ddddE±dd，十进制指数)
f (-ddd.dddd，没有指数)
g (e:大指数，f:其它情况)
G (E:大指数，f:其它情况)
如果格式标记为 e，E 和 f，则 prec 表示小数点后的数字位数
如果格式标记为 g，G，则 prec 表示总的数字位数（整数部分+小数部分）

3、prec：精度（数字部分的长度，不包括指数部分）

4、bitSize：指定浮点类型（32:float32、64:float64）

FormatFloat(f float64, fmt byte, prec, bitSize int) string

示例：

package main

import (
	"fmt"
	"strconv"
)

func main() {

	f := 200.12345678901234567890123456789
	fmt.Println(strconv.FormatFloat(f, 'b', 5, 32))
	fmt.Println(strconv.FormatFloat(f, 'e', 5, 32))
	fmt.Println(strconv.FormatFloat(f, 'E', 5, 32))
	fmt.Println(strconv.FormatFloat(f, 'f', 5, 32))
	fmt.Println(strconv.FormatFloat(f, 'g', 5, 32))
	fmt.Println(strconv.FormatFloat(f, 'G', 5, 32))
	fmt.Println(strconv.FormatFloat(f, 'b', 30, 32))
	fmt.Println(strconv.FormatFloat(f, 'e', 30, 32))
	fmt.Println(strconv.FormatFloat(f, 'E', 30, 32))
	fmt.Println(strconv.FormatFloat(f, 'f', 30, 32))
	fmt.Println(strconv.FormatFloat(f, 'g', 30, 32))
	fmt.Println(strconv.FormatFloat(f, 'G', 30, 32))
}

输出：

13115291p-16
2.00123e+02
2.00123E+02
200.12346
200.12
200.12
13115291p-16
2.001234588623046875000000000000e+02
2.001234588623046875000000000000E+02
200.123458862304687500000000000000
200.1234588623046875
200.1234588623046875

go语言字符串处理包——strings 和 strconv