Golang学习笔记之字符串的使用

字符串的定义
字符串的声明
字符串的操作
总结

字符串的定义

golang当中的字符串本质是只读的字符型数组，和C语言当中的char[]类似，但是golang为它封装了一个变量类型，叫做string。

字符串的声明

1.使用双引号

str := "I am a string"

使用反引号

str := `I am a string too`

反引号的特点：不解析内部字符串，因此不需要反斜杠\转义，例如：

str := `{"name": "zhangsan", "age": 18}`

先声明，再赋值

var str string
str = "I am a string"

字符串的操作

字符串的长度

len("hello")

结果是：5

len("hello 世界")

结果是：12

为什么不是8呢？因为在utf-8编码当中，一个汉字需要3个字节编码。要想按照我们希望的统计出结果为 8，就需要使用到rune（具体rune章节会介绍），它表示单个unicode字符。
因此，可以这样统计中文：

len([]rune("hello 世界"))

结果是： 8

字符串的拼接

str1 := "hello"
str2 := "world"
str3 := str1 + str2
fmt.Println(str3)

结果是： helloworld

也可以使用fmt.Sprintf()，例如：

str2 := "world"
str3 := fmt.Sprintf("hello %s", str2)
fmt.Println(str3)

结果也是：hello world

类型的转换

从长度计算的例子中，我们其实就已经使用到了类型转换：[]rune("hello 世界") 将一个字符串转换成 rune类型。

1. 将字符串转换成rune和[]byte类型：

str1 := "I am a string"

// 转化成rune
rune1 := []rune(str1)
fmt.Println(rune1)

// 转化成[]byte类型
byte1 := []byte(str1)
fmt.Println(byte1)

2. 字符串与整数互转

str2 := "100"
num2, _ := strconv.Atoi(str2)
fmt.Println(reflect.TypeOf(num2))  //结果为： int

num3, _ := strconv.ParseInt(str2, 10, 64)
fmt.Println(num3, reflect.TypeOf(num3))   //结果为：100 int64

num1 := 200
str3 := strconv.Itoa(num1)
fmt.Println(reflect.TypeOf(str3))  //结果为： string

其中 strconv.ParseInt(str2, 10, 64) 中，第二个参数10表示十进制，第三个参数64表示值的范围，并不影响结果数据类型。例如：

str2 := "300"
num3, _ := strconv.ParseInt(str2, 10, 0)
fmt.Println(num3, reflect.TypeOf(num3))     //结果为：300 int64

num4, _ := strconv.ParseInt(str2, 10, 8)
fmt.Println(num4, reflect.TypeOf(num4))     //结果为：127 int64

num5, _ := strconv.ParseInt(str2, 10, 32)
fmt.Println(num5, reflect.TypeOf(num5))     //结果为：300 int64

类型都是 int64, 但是最大和最小值，受到范围的影响。第三个8位，表示int8的取值范围[-127，127]的区间，因此最大值只能是127

3. 整数或者浮点数转字符串

整数转字符串除了上面使用的strconv.Itoa外，还可以使用strconv.FormatInt来格式化成字符串。

num1 := 200

num6 := strconv.FormatInt(int64(num1), 10)
fmt.Println(num6, reflect.TypeOf(num6))         //结果为：200 string

num7 := strconv.FormatInt(int64(num1), 16)
fmt.Println(num7, reflect.TypeOf(num6))         //结果为：c8 string

浮点数转字符串

num := 1234567.654321

num8 := strconv.FormatFloat(float64(num), 'f', -1, 64)
fmt.Println(num8, reflect.TypeOf(num8))     //结果为：1234567.654321 string

num9 := strconv.FormatFloat(float64(num), 'e', -1, 64)
fmt.Println(num9, reflect.TypeOf(num9))     //结果为： 1.234567654321e+06 string

第二个参数为格式化，'f’表示普通模式,注意这里的’f’是字符，不是字符串，还有其他的格式化模式：

‘f’ 表示普通模式：（-ddd.dddd）
‘b’ 表示指数为二进制：（-ddddp±ddd）
‘e’ 表示十进制指数，也就是科学记数法的模式：(-d.dddde±dd)
‘E’ 和’e’一样，都是科学记数法的模式，只不过字母e大写：(-d.ddddE±dd)
‘g’ 表示指数很大时用’e’模式，否则用‘f’模式
‘G’ 表示指数很大时用’E’模式，否则用’f’模式

4. 布尔类型与字符串互转

strconv包还支持与bool类型进行转换，将字符串转成bool类型用的是ParseBool，它只有一个参数，只接受0,1,t,f,T,F,ture,false,True,False,TRUE,FALSE这几种取值。

字符串转bool

flag, err := strconv.ParseBool("t")
fmt.Println(flag, err)          //结果为：true <nil>

flag, err = strconv.ParseBool("f")
fmt.Println(flag, err)          //结果为：false <nil>

flag, err = strconv.ParseBool("true")
fmt.Println(flag, err)          //结果为：true <nil>

flag, err = strconv.ParseBool("false")
fmt.Println(flag, err)          //结果为：false <nil>

flag, err = strconv.ParseBool("1")
fmt.Println(flag, err)          //结果为：true <nil>

flag, err = strconv.ParseBool("0")
fmt.Println(flag, err)          //结果为：false <nil>

bool转字符串

str := strconv.FormatBool(true)
fmt.Println(str, reflect.TypeOf(str))  //结果为：true string

字符串的运算

strings包提供了很多字符串运算的方法。

1. 字符串的比较

str1 := "hello"
str2 := "hello"
res := strings.Compare(str1, str2)
fmt.Println(res)	//结果为0表示相等，-1表示小于，1表示大于

2. 字符串去空格

str3 := " hello    "
res2 := strings.Trim(str3, " ")
fmt.Println(res2) //结果为：hello

str4 := "123hello123"
res3 := strings.Trim(str4, "123")
fmt.Println(res3) //结果为：hello

3. 字符串是否包含另一个字符串

res5 := strings.Contains("hello", "ell")
fmt.Println(res5) //结果为：true

4. 查找一个字符串在另一个字符串的起始位置

res6 := strings.Index("hello", "e")
fmt.Println(res6)   //结果为：1 ，-1表示不包含

5. 查找一个字符串最后一次出现在另一个字符串的位置

res7 := strings.Index("hello", "l")
fmt.Println(res7)   //结果为：2

res8 := strings.LastIndex("hello", "l")
fmt.Println(res8)  //结果为：3

6. 字符串替换

res9 := strings.Replace("hello world world", "world", "golang", -1)
fmt.Println(res9) //结果为：hello golang golang

res9 = strings.Replace("hello world world", "world", "golang", 1)
fmt.Println(res9) //结果为：hello golang world

最后一个参数表示替换次数，-1表示替换全部，整数表示对应的替换次数

7. 字符串切割

将字符串切割成数组

slice := strings.Split("hello world", " ")
fmt.Println(slice, reflect.TypeOf(slice)) //结果为：[hello world] []string

将数组拼接成字符串

slice1 := []string{
	"hello",
	"golang",
	"world",
}
str := strings.Join(slice1, ",")
fmt.Println(str, reflect.TypeOf(str)) //结果为：hello,golang,world string

以上只展示一些最常见的例子，还有很多字符串运算的方法，在这里就不一一列举了，感兴趣的可以自我尝试一下。

总结

Golang中对字符串的操作和运算提供了大量的方法，本篇只是简单的做一个介绍，比较适合新手当做例子用来查看。针对Golang中的字符串的底层实现原理，请关注《Golang字符串的底层原理》

目录CONTENT