欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-05-28 20:43:46
1 概述 字符串,string,一串固定长度的字符连接起来的字符集合。go语言的字符串是使用utf-8编码的。utf-8是unicode的实现方式之一。 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|javascript", fn)
// 返回 ["go" "python" "c++" "c" "js" "javascript"]

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|javascript", 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|javascript", 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|javascript")
// 返回 "go-js-javascript"

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-javascript", "-")
// 返回 ["go", "js", "javascript"]

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

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

strings.splitafter("go-js-javascript", "-")
// 返回 ["go-", "js-", "javascript"]

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

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

strings.splitaftern("go-js-javascript", "-", 2)
// 返回 ["go-", "js-javascript"]

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

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

strings.splitn("go-js-javascript", "-", 2)
// 返回 ["go", "js-javascript"]

strings.title(s string) string

返回title化的字符串。

strings.title("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.totitle(s string) string

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

strings.title("hello hank's go")
// 返回 "hello hank's go"

strings.totitlespecial(c unicode.specialcase, s string) string

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

strings.totitlespecial(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语言中的字符串处理方法示例详解,希望对大家有所帮助