Go语言中的字符串处理方法示例详解

1 概述

字符串，string，一串固定长度的字符连接起来的字符集合。Go语言的字符串是使用UTF-8编码的。UTF-8是Unicode的实现方式之一。

Go语言原生支持字符串。使用双引号(\"\")或反引号(``)定义。

双引号：\"\", 用于单行字符串。

反引号：``，用于定义多行字符串，内部会原样解析。

示例：

// 单行
\"心有猛虎，细嗅蔷薇\"
// 多行
`
大风歌
大风起兮云飞扬。
威加海内兮归故乡。
安得猛士兮守四方！
`

字符串支持转义字符，列表如下：

• \\r 回车符（返回行首）
• \\n 换行符（直接跳到下一行的同列位置）
• \\t 制表符
• \\\' 单引号
• \\\" 双引号
• \\\\ 反斜杠
• \\uXXXX Unicode字符码值转义，例如 \"\\u5eb7\" 就是 \"康\"

Go语言中字符串的顶层结构是由一个指针和长度构成的。使用 unsafe.Sizeof(\"\") 会得到16长度，其中8个字节是指针，指向字符串的内存地址，8个是存储字符串的长度。

2 常规操作

以下是针对字符串的操作总结，主要来自于Go语言的API的说明和测试。

[]索引访问

可以使用[index]方式，访问到字符串中的字符。可以访问，不可以修改。

s := \"Hank\"
fmt.Printf(\"%c\", s[2])
// 返回 n

unicode/utf8 包

多字节字符的处理，请参考 unicode/utf8 包的相关说明。

例如：

import \"unicode/utf8\"
utf8.RuneCountInString(\"小韩说课\")
// 返回 4

len()，字符串占用的字节数

utf-8 是变长字符集，英文标点占用1个字节，中文占用3个字节。

len(\"Hank康\")
// 返回 7

+，字符串连接\"

\"Hello\" + \" \" + \"Hank\"

==, >, <

字符串比较，比较机制是字符的对称比较。

\"abc\" > \"bbcd\"
// 结果为false

strings.Compare(a, b string) int

字符串比较，比较机制是字符的对称比较。返回值为：

0，表示a == b
-1，表示a < b
1，表示a > b
strings.Compare(\"abc\", \"abcd\")
// 返回 1

strings.Contains(s, substr string) bool

检测字符串 substr 是否在 s 中。

strings.Contains(\"foobar\", \"foo\")
// 返回 true
strings.Contains(\"fobar\", \"foo\")
// 返回 false

strings.ContainsAny(s, chars string) bool

检测字符串 chars 的中任意字符是否出现在 s 中。

fmt.Println(strings.ContainsAny(\"Hank\", \"kang\")) 
// 返回 true
fmt.Println(strings.ContainsAny(\"Hank\", \"go\")) 
// 返回 false

strings.ContainsRune(s string, r rune) bool

检测 rune字符是否出现在 s 中。

strings.ContainsRune(\"Hank\", \'a\')
// 返回 true
strings.ContainsRune(\"Hank\", 97)
// 返回 true，a的码值97

strings.Count(s, substr string) int

统计字符串 s 中非重叠substr的数量。若统计空字符串\"\"，会返回 s 的长度加1。

strings.Count(\"HanZhongKang\", \"n\")
// 返回 3
strings.Count(\"Hank\", \"\")
// 返回 5，\"Hank\"每个rune的前后都算

strings.EqualFold(s, t string) bool

检测字符串 s 和 t 在忽略大小写的情况下是否相等。

strings.EqualFold(\"Hank\", \"hank\")
// 返回 true

strings.Fields(s string) []string

返回使用空格分割的字符串 s，结果为切片。

strings.Fields(\"Han Zhong Kang\")
// 返回 []string, [\"Han\", \"Zhong\", \"Kang\"]

strings.FieldsFunc(s string, f func(rune) bool) []string

使用函数确定分隔符，来分割字符串 s。结果是切片。

// ,|/ 都是分隔符
fn := func(c rune) bool {
 return strings.ContainsRune(\",|/\", c)
}
strings.FieldsFunc(\"go,python,c++/c,Js| \", fn)
// 返回 [\"go\" \"python\" \"c++\" \"c\" \"Js\" \" \"]

strings.HasPrefix(s, prefix string) bool

检测字符串 s 是否以字符串 prefix 作为前缀。

strings.HasPrefix(\"Gopher\", \"Go\")
// 返回 true

strings.HasSuffix(s, suffix string) bool

检测字符串 s 是否以字符串 suffix 作为后缀。

strings.HasSuffix(\"Gopher\", \"er\")
// 返回 true

strings.Index(s, substr string) int

返回字符串 substr 在字符串 s 中第一次出现的索引位置，若没有出现，返回-1。

strings.Index(\"Gopher\", \"ph\")
// 返回 2

strings.IndexAny(s, chars string) int

返回字符串 chars 中的任意字符在字符串 s 中第一次出现的索引位置，若没有出现，返回-1。

strings.IndexAny(\"Gopher\", \"lmno\")
// 返回 1

strings.IndexByte(s string, c byte) int

返回byte字符 c 在字符串 s 中第一次出现的索引位置，若没有出现，返回-1。

strings.IndexByte(\"Gopher\", \'h\')
// 返回 3

strings.IndexFunc(s string, f func(rune) bool) int

返回字符串 s 中第一次满足函数 f 的rune字符的索引位置，若没有出现，返回-1。

fn := func(c rune) bool {
 return strings.ContainsRune(\",|/\", c)
}
strings.IndexFunc(\"go,python,c++/c,Js| \", fn)
// 返回 2

strings.IndexRune(s string, r rune) int

返回run字符 r 在字符串 s 中第一次出现的索引位置，若没有出现，返回-1。

strings.IndexRune(\"小韩说课\", \'说\')
// 返回 6

strings.Join(a []string, sep string) string

使用分隔符 sep 连接字符串切片 a。

ss := []string{\"Go\", \"Hank\", \"Python\", \"PHP\"}
strings.Join(ss, \"-\")
// 返回 \"Go-Hank-Python-PHP\"

strings.LastIndex(s, substr string) int

返回字符串 substr 在字符串 s 中最后一次出现的索引位置，若没有出现，返回-1。

strings.LastIndex(\"Hankang\", \"an\")
// 返回 4

strings.LastIndexAny(s, chars string) int

返回字符串 chars 中的任意字符在字符串 s 中最后一次出现的索引位置，若没有出现，返回-1。

strings.LastIndexAny(\"Hankang\", \"lmno\")
// 返回 5

strings.LastIndexByte(s string, c byte) int

返回byte字符 c 在字符串 s 中最后一次出现的索引位置，若没有出现，返回-1。

strings.LastIndexByte(\"Hankang\", \'n\')
// 返回 5

strings.LastIndexFunc(s string, f func(rune) bool) int

返回字符串 s 中字后一次满足函数 f 的rune字符的索引位置，若没有出现，返回-1。

fn := func(c rune) bool {
 return strings.ContainsRune(\",|/\", c)
}
strings.LastIndexFunc(\"go,Js| \", fn)
// 返回 5

strings.Map(mapping func(rune) rune, s string) string

返回字符串 s 中的每个字符经过映射函数 mapping 处理之后的字符串。

fn := func(c rune) rune {
 if strings.ContainsRune(\",|/\", c) {
  return \'-\'
 } else {
  return c
 }
}
strings.Map(fn, \"go,Js| \")
// 返回 \"go-Js- \"

strings.Repeat(s string, count int) string

返回将字符串 s 重复 count 的字符串。

strings.Repeat(\"la~\", 3)
// 返回值 \"la~la~la~\"

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

在字符串 s 中使用字符串 new 替换字符串 old，使用 n 限定替换次数，n设置为负数表示没有限制。返回替换结果。

strings.Replace(\"han zhong kang\", \"n\", \"N\", 2)
// 返回 \"haN zhoNg kang\"

strings.Split(s, sep string) []string

使用分隔符 sep 分割字符串 s，返回字符串切片

strings.Split(\"go-Js- \", \"-\")
// 返回 [\"go\", \"Js\", \" \"]

strings.SplitAfter(s, sep string) []string

在分隔符 sep 后分割字符串 s，返回字符串切片

strings.SplitAfter(\"go-Js- \", \"-\")
// 返回 [\"go-\", \"Js-\", \" \"]

strings.SplitAfterN(s, sep string, n int) []string

在分隔符 sep 后分割字符串 s，使用 n 限定分割的元素数量，n<0全部子字符串，n>0最后一个子字符串包含余下内容，n==0返回nil。返回子字符串切片。

strings.SplitAfterN(\"go-Js- \", \"-\", 2)
// 返回 [\"go-\", \"Js- \"]

strings.SplitN(s, sep string, n int) []string

在分隔符 sep 分割字符串 s，使用 n 限定分割的元素数量，n<0全部子字符串，n>0最后一个子字符串包含余下内容，n==0返回nil。返回子字符串切片。

strings.SplitN(\"go-Js- \", \"-\", 2)
// 返回 [\"go\", \"Js- \"]

strings. (s string) string

返回 化的字符串。

strings. (\"hello Hank\'s go\")
// 返回 \"Hello Hank\'s Go\"

strings.ToLower(s string) string

转换字符串 s 到小写。

strings.ToLower(\"Hank\'s Go Guide\")
// 返回 \"hank\'s go guide\"

strings.ToLowerSpecial(c unicode.SpecialCase, s string) string

使用特定的规则转换字符串 s 到小写。

strings.ToLowerSpecial(unicode.TurkishCase, \"Önnek İş\")
// 返回 önnek iş

strings.To (s string) string

返回全部字符都 化的字符串。

strings. (\"hello Hank\'s go\")
// 返回 \"HELLO HANK\'S GO\"

strings.To Special(c unicode.SpecialCase, s string) string

使用特定的规则将全部字符都 化。

strings.To Special(unicode.TurkishCase, \"dünyanın ilk borsa yapısı Aizonai kabul edilir\")
// 返回 \"DÜNYANIN İLK BORSA YAPISI AİZONAİ KABUL EDİLİR\"

strings.ToUpper(s string) string

将字符串 s 中所有字符转换为大写。

strings.ToUpper(\"hello Hank\'s go\")
// 返回 \"HELLO HANK\'S GO\"

strings.ToUpperSpecial(c unicode.SpecialCase, s string) string

使用特定的规则将字符串 s 中所有字符转换为大写。

strings.ToUpperSpecial(unicode.TurkishCase, \"örnek iş\")
// 返回 \"ÖRNEK İŞ\"

strings.Trim(s string, cutset string) string

截取字符串 s 两端包裹的特定字符集 cutset。

strings.Trim(\" user name  \", \" \")
// 返回 \"user name\"

strings.TrimFunc(s string, f func(rune) bool) string

截取字符串 s 两端满足函数 f 的字符。

fn := func(c rune) bool {
 return strings.ContainsRune(\",|/\", c)
}
strings.TrimFunc(\"|/user name,/\", fn)
// 返回 \"user name\"

strings.TrimLeft(s string, cutset string) string

截取字符串 s 左边包裹的特定字符集 cutset。

strings.TrimLeft(\" user name  \", \" \")
// 返回 \"user name  \"

strings.TrimLeftFunc(s string, f func(rune) bool) string

截取字符串 s 左边满足函数 f 的字符。

fn := func(c rune) bool {
 return strings.ContainsRune(\",|/\", c)
}
strings.TrimLeftFunc(\"|/user name,/\", fn)
// 返回 \"user name,/\"

strings.TrimPrefix(s, prefix string) string

截取字符串 s 的前缀 prefix。

strings.TrimPrefix(\"hank_goGuide\", \"hank_\")
// 返回 \"goGuide\"

strings.TrimRight(s string, cutset string) string

截取字符串 s 右边包裹的特定字符集 cutset。

strings.TrimRight(\" user name  \", \" \")
// 返回 \" user name\"

strings.TrimRightFunc(s string, f func(rune) bool) string

截取字符串 s 右边满足函数 f 的字符。

fn := func(c rune) bool {
 return strings.ContainsRune(\",|/\", c)
}
strings.TrimRightFunc(\"|/user name,/\", fn)
// 返回 \"|/user name\"

strings.TrimSpace(s string) string

截取字符串 s 两端的空白字符。

strings.TrimSpace(\" \\t\\n Hello, Gophers \\n\\t\\r\\n\")
// 返回 \"Hello, Gophers\"

strings.TrimSuffix(s, suffix string) string

截取字符串 s 的后缀 suffix。

strings.TrimSuffix(\"goGuide_beta\", \"_beta\")
// 返回 \"goGuide\"

总结

以上所述是小编给大家介绍的Go语言中的字符串处理方法示例详解，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对脚本之家网站的支持！