《Go语言从入门到精通》Go语言中的字符串处理

Go语言中的字符串处理Go语言从入门到精通了解字符串的基本概念掌握Go语言中字符串处理的常用函数与逻辑01STRING02ENCODING03FUNCTIONStarget目标了解字符串的编码及非英文字符的特殊处理目录导航7.1字符串相关的基础知识Contents字符串的概念一串字符连起来的序列

字节（byte）

ASCII字符编码byte、uint8和int8类型

byte类型实质上是uint8类型的别名

uint8类型是8位二进制数据表达的无符号整数

byte（uint8）类型的数据范围是[0,255]

int8是用8位二进制数据来表达有符号整数，表达的范围是[-128,127][]byte与string

var

s

string

s

=

"abz"

byteSlice

:=

[]byte(s)

fmt.Printf("byteSlice的类型是：%T，数值是：%v\n",

byteSlice,

byteSlice)

[]byte转换为string

byteSlice

:=

[]byte{97,

98,

122}

s

:=

string(byteSlice)

fmt.Printf("s的类型是：%T，数值是：%v\n",

s,

s)

字符串的基本操作

var

s1

string

//

用常规方法声明字符串变量s1

s1

=

"abc"//

给字符串变量赋值

s2

:=

"12345"//

用简化方式声明字符串变量s2并赋值

s3

:=

s1

+

s2//

用加号“+”来连接（合并）两个字符串

//

用内置函数len获取字符串的长度

t.Printfln("s1的长度是：%v",

len(s1))

t.Printfln("s2的长度是：%v",

len(s2))

t.Printfln("s3=%v,

s3的长度是：%v",

s3,

len(s3))

//

用索引访问的方式获取字符串变量中指定位置的字符，返回值是byte类型

b

:=

s1[0]

t.Printfln("s1的第一个字符是：%v，变量类型是：%T",

b,

b)

//

用切片中截取子切片的方式来截取子字符串，返回值还是string类型

subStr1

:=

s3[2:5]

t.Printfln("subStr1=%v，变量类型是：%T",

subStr1,

subStr1)双引号或反引号括起字符串双引号（”）括起来的字符串允许有转义字符，例如”abc\n123”中的”\n”反引号（`）括起来的字符串称作“原始字符串”（rawstring），其中如果有转义字符的话不会被转义反引号中的字符串可以是多行的目录导航7.2字符串支持多语言编码的特殊处理Contents中文字符和其他一些多字节语言的处理问题s

:=

"我们OK。"

t.Printfln("s的长度：%v",

len(s))

s的长度：11UTF-8编码可变长度的编码方式,每个字符用1至4个字节长度的编码来表示对于ASCII码表中原有的字符（包括所有的英语字母、数字和英文符号等），仍然占用一个字节我们常用的中文字符则一般要占据3个字节s的长度：11byteSlice：[2301361452281871727975227128130]1110011011100100010011110100101111100011验证UTF-8编码s

:=

"我们OK。"

t.Printfln("s的长度：%v",

len(s))

byteSlice

:=

[]byte(s)

t.Printfln("byteSlice：%v",

byteSlice)

t.Printfln("%08b",

uint8(230))rune与[]rune

rune类型是uint32类型的别名是32个二进制位表示的无符号整数，可以说是由4个字节组成

rune类型是Go语言中专门用于表示Unicode编码的数据类型，更具体地说是表示UTF-8类型的Unicode编码rune类型可以表示任何用UTF-8编码的字符，其中不足4个字节的将在左侧补0s的长度：11runeSlice：[2510520204797512290]，runeSlice的长度：5rune切片s

:=

"我们OK。"

t.Printfln("s的长度：%v",

len(s))

runeSlice

:=

[]rune(s)

t.Printfln("runeSlice：%v，runeSlice的长度：%v",

runeSlice,

len(runeSlice))

用rune对中文字符串进行遍历s

:=

"大家都说nice。"

for

i

:=

0;

i

<

len(s);

i++

{

t.Printfln("字节序号：%d，内容：%v，类型：%T",

i,

s[i],

s[i])}

for

i,

v

:=

range

s

{

t.Printfln("字节序号：%d，内容：%v，类型：%T",

i,

v,

v)}

runeSlice

:=

[]rune(s)

for

i

:=

0;

i

<

len(runeSlice);

i++

{

t.Printfln("字节序号：%d，内容：%v，类型：%T",

i,

runeSlice[i],

runeSlice[i])}

for

i,

v

:=

range

runeSlice

{

t.Printfln("字节序号：%d，内容：%v，类型：%T",

i,

v,

v)}注意几种遍历方式的区别目录导航7.3常见的字符串操作Contents判断字符串中是否含有某个子串

if

strings.Contains(s,

"OK")

{

t.Printfln("%v

中含有子串

%v",

s,

"OK")

}

else

{

t.Printfln("%v

中不含有子串

%v",

s,

"OK")

}

获取字符串中子串的位置

s

:=

"我们OK。"

pos

:=

strings.Index(s,

"们O")

t.Printfln("子串的位置在第%v个字节处开始。",

pos)

注意几种序号从零开始（返回结果pos为3）获取字符串中子串第n次出现的位置s

:=

"我们不能只靠我们自己，要寻找帮助我们的力量。"tmpS

:=

s

count

:=

0totalIndex

:=

0

strLen

:=

len(s)subLen

:=

len("我们")

for

{

index

:=

strings.Index(tmpS,

"我们")

if

index

<

0

{

break

}

count++

totalIndex

+=

index

if

totalIndex

>=

strLen

{

break

}

if

count

>=

3

{

break

}

totalIndex

+=

subLen

tmpS

=

s[totalIndex:]}获取字符串中子串第n次出现的位置（方法1）s

:=

"我们不能只靠我们自己，要寻找帮助我们的力量。"tmpS

:=

s

count

:=

0totalIndex

:=

0

strLen

:=

len(s)subLen

:=

len("我们")

for

{

index

:=

strings.Index(tmpS,

"我们")

if

index

<

0

{

break

}

count++

totalIndex

+=

index

if

totalIndex

>=

strLen

{

break

}

if

count

>=

3

{

break

}

totalIndex

+=

subLen

tmpS

=

s[totalIndex:]}循环切片法获取字符串中子串第n次出现的位置（方法2）s

:=

"我们不能只靠我们自己，要寻找帮助我们的力量。"

subLen

:=

len("我们")

list

:=

strings.SplitN(s,

"我们",

4)

if

len(list)

<

4

{

t.Printfln("没有找到要求搜索的内容")}

else

{

totalIndex

:=

len(list[0])

+

subLen

+

len(list[1])

+

subLen

+

len(list[2])

t.Printfln("子串第3次出现的位置在%v，前面的字符串是\"%v\"，后面的字符串是\"%v\"",

totalIndex,

s[:totalIndex],

s[totalIndex+subLen:])}

使用strings.SplitN函数统计字符串中子串出现的次数s

:=

"我们不能只靠我们自己，要寻找帮助我们的力量。"

t.Printfln(`子串"我们"共出现了%v次`,

strings.Count(s,

"我们"))

判断字符串的起始或结尾子串//

EndsWith

检查字符串strA结尾是否是subStrAfunc

EndsWith(strA

string,

subStrA

string)

bool

{

return

strings.HasSuffix(strA,

subStrA)}

比较两个字符串fmt.Printf("%x,

%x\n",

'我',

'们')

s1

:=

"我们"s2

:=

"\u6211\U00004eec"

if

s1

==

s2

{

fmt.Printf(`字符串"%v"与"%v"相等\n`,

s1,

s2)}

else

{

fmt.Printf(`字符串"%v"与"%v"不相等\n`,

s1,

s2)}

去除字符串首尾空白或其他字符//

Trim

去除字符串首尾的空白字符func

Trim(strA

string)

string

{

return

strings.TrimSpace(strA)}s

:=

"----大家都说nice。----"

t.Printfln("字符串s：%v",

s)

t.Printfln("去除首部指定的字符后：%v",

strings.TrimLeft(s,

"-大"))

t.Printfln("去除尾部指定的字符后：%v",

strings.TrimRight(s,

"-大"))t.Printfln("去除首部指定的字符串后：%v",

strings.TrimPrefix(s,

"----大家"))

t.Printfln("去除尾部指定的字符串后：%v",

strings.TrimSuffix(s,

"nice。----"))

替换字符串中的子串oldString

:=

"天下是天下人的天下，不是一个人的天下。"

newString

:=

strings.Replace(oldString,

"天下",

"___",

3)

t.Printfln("第1次替换结果是：%v",

newString)

t.Printfln("第2次替换结果是：%v",

strings.Replace(oldString,

"天下",

"___",

-1))

第1次替换结果是：___是___人的___，不是一个人的天下。第2次替换结果是：___是___人的___，不是一个人的___。字符串大小写的转换oldString

:=

"We

are

so

happy."

newString

:=

strings.ToUpper(oldString)

t.Printfln("全部转换为大写后是：%v",

newString)

t.Printfln("再次转换为全小写后是：%v",

strings.ToLower(newString))

切分字符串oldString

:=

"天下是天下人的天下，不是一个人的天下。"

strList

:=

strings.Split(oldString,

"天下")

t.Printfln("%#v",

strList)

strList

=

strings.Split(oldString,

"")

t.Printfln("%#v",

strList)

strList

=

strings.Split(oldString,

"天下是天下人的天下，不是一个人的天下。")

t.Printfln("%#v",

strList)

合并字符串切片s1

:=

"1,2,3,4,5"

strList

:=

strings.Split(s1,

",")

t.Printfln("%v",

strings.Join(strList,

"-"))

s2

:=

"

We

are

\n

very

happy.

"

strList

=

strings.Fields(s2)

t.Printfln("%v",

strings.Join(strList,

"

"))

生成重复子串组成的字符串t.Printfln("%v",

"我真的"+strings.Repeat("很想",

3)+"你")我真的很想很想很想你几个Unicode包中的操作unicode.IsControl函数：用于判断字符是否是控制字符；unicode.IsDigit函数：用于判断字符是否是10进制数字字符；unicode.IsNumber函数：用于判断字符是否为数字（与unicode.IsDigit函数功能接近，但能够识别的数字更多，例如Unicode中的罗马数字字符也能识别）；unicode.IsLetter函数：用于判断字符是否为字母（注意包括汉字等，如果要鉴别字母，需要结合unicode.IsLower函数和unicode.IsUpper函数）；unicode.IsLower函数：用于判断字符是否为小写字母；unicode.IsUpper函数：用于判断字符是否为大写字母；unicode.IsPunct函数：用于判断字符是否为标点符号；unicode.IsSpace函数：用于判断字符是否为空白字符；unicode.IsSymbol函数：用于判断字符是否为符号字符；unicode.ToLower函数：用于将字符转换为小写（如果可以转换的话，否则维持原样）；unicode.ToUpper函数：用于将字符转换为大写（如果可以转换的话，否则维持原样）；unicode.ToTitle函数：用于将字符转换为标题字符目录导航7.4高级字符串操作Contents生成随机字符串countT

:=

10

//

生成10个字符长度的字符串

rand.Seed(time.Now().Unix())

//

初始化伪随机序列

//

准备码表baseT

:=

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"

//

初始化字符串resultT

:=

""

//

循环逐个字符生成for

i

:=

0;

i

<

countT;

i++

{

idxT

:=

rand.Intn(len(baseT))

resultT

+=

baseT[idxT:(idxT

+

1)]}关键代码7.4.2 用strings.Builder实现不断增长的字符串var

builderT

strings.Buildervar

idxT

int

for

i

:=

0;

i

<

countT;

i++

{

idxT

=

rand.Intn(len(baseT))

builderT.WriteByte(baseT[idxT])}

println(builderT.String())

关键代码用于字符串内容读取的strings.Readers

:=

"这是一个10斤重的西瓜。"readerT

:=

strings.NewReader(s)t.Printfln("字符串长度为：%v",

readerT.Len())for

{

charT,

sizeT,

errT

:=

readerT.ReadRune()

if

errT

!=

nil

{

break

}

t.Printfln("读取的字符为：%c(编码：%v)，字节数为：%v",

charT,

charT,

sizeT)}readerT.Seek(12,

io.SeekStart)

charT,

sizeT,

errT

:=

readerT.ReadRune()

if

errT

==

nil

{

t.Printfln("从字节索引12开始读取的字符为：%c(编码：%v)，字节数为：%v",

charT,

charT,

sizeT)}

buf1

:=

make([]byte,

5)

n,

errT

:=

readerT.ReadAt(buf1,

9)字符串与数字的相互转化int类型转换为string类型：strconv.Itoa(n)二进制整数类型转换为string类型：strconv.FormatInt(n,2)十进制整数转换为string类型：strconv.FormatInt(n,10)十六进制整数转换为string类型：strconv.FormatInt(n,16)byte类型转换为string类型：

strconv.FormatInt(int64(n),10)任意整数类型转换为字符串//

IntegerToString

所有整数类型转换为string类型func

IntegerToString(valueA

interface{})

string

{

switch

valueA.(type)

{

case

byte:

return

strconv.FormatInt(int64(valueA.(byte)),

10)

case

rune:

return

strconv.FormatInt(int64(valueA.(rune)),

10)

case

int64:

return

strconv.FormatInt(valueA.(int64),

10)

default:

return

""

}}

使用空接口（interface{}）类型作为参数的用途：可以接收任意类型的参数，然后可以用switch+.(type)语法分别处理从strings.Builder理解Go语言的接口var

buf

strings.Builder

for

i

:=

0;

i

<

3;

i++

{

fmt.Fprintf(&buf,

"这是第%