字符串

  1. 字符串只能用双引号定义,
  2. go里单引号和双引号不通过,可以使用`` 号来定义原始输出,不会进行转义,相当于python 里的三引号
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
    package main

    import "fmt"

    func main() {
        name := "杨彦星\n"
        s := `杨
        adgfgfg
        \n\t
        `
        fmt.Println(name,s)
    }
    ```

    输出
    ```go
    杨彦星
    杨
        adgfgfg
        \n\t
    ```

3. 字符串是不可改变的
   
    我们说字符串是不可变的指的是字符串内部⽤用指针指向 UTF-8 字节数组,所指向的字节数组不能单独改变。并不是指字符串指向一个新的UTF-8数组

    ```go
    package main

    import "fmt"

    func main() {
        var name string
        var name1 = []byte("yangyanxing汉字")
        name = string(name1)
        fmt.Println(&name,name)

        name = "杨彦星" //这个是可以的
        fmt.Println(&name) //name 的地址不会改变

        //非法
        //name[0] = "a"

    }

    ```

    如果想要改变字符串中的值需要先将字符串转为字节数组(\[\]byte)或者字符数组(\[\]rune),有中文的情况下使用字符数组

    ```go
    package main

    import "fmt"

    func main() {
        var name = "yangyanxing"
        fmt.Println(&name,name)
        names := []byte(name)
        //字节数组需要使用单引号,双引号是字符串了
        names[0] = 'f' 
        fmt.Println(&name,string(names))

        name = "杨彦星" //这个是可以的
        //如果有汉字的话需要使用字符数组
        namer := []rune(name)
        //需要使用单引号
        namer[0] = '饭'
        //name 的地址不会改变
        fmt.Println(&name,string(namer)) 
    }

    ```

4. 字符串与字节数组与字符数组的相互转换

    ```go
    package main

    import "fmt"

    func main() {
        var name = "yangyanxing"
        fmt.Println(&name,name)
        names := []byte(name)
        fmt.Printf("%T\n",names)
        names[0] = 'f' //字节数组需要使用单引号,双引号是字符串了
        name = string(names)
        fmt.Println(&name,name)

        name = "杨彦星"
        //如果有汉字的话需要使用字符数组
        namer := []rune(name)
        fmt.Printf("%T\n",namer)
        namer[0] = '饭'
        name = string(namer)
        fmt.Println(&name,name) //name 的地址不会改变
    }

    ```

5. 字符串的遍历

    字符串可以按字节或者字符来遍历

    ```go
    package main

    import "fmt"

    func main() {
        var name = "yang杨彦星"
        //按字节遍历
        for i:=0;i<len(name);i++{
            fmt.Printf("%v %T:%v\n",i,name[i],name[i])
        }

        fmt.Println("")

        //按字符遍历
        for _,r := range name{
            //%c 为输出数值所表示的 Unicode 字符,不带单引号 如 y
            //%q 输出数值所表示的 Unicode 字符(带单引号)如 '杨'
            fmt.Printf("%c",r)
        }
    }

    ```

    结果为

    ```go
    0 uint8:121
    1 uint8:97
    2 uint8:110
    3 uint8:103
    4 uint8:230
    5 uint8:157
    6 uint8:168
    7 uint8:229
    8 uint8:189
    9 uint8:166
    10 uint8:230
    11 uint8:152
    12 uint8:159

    yang杨彦星
    Process finished with exit code 0

    ```

6. 字符串的拼接

    可以直接使用 ` + ` 拼接

    ```go
    package main

    import "fmt"

    func main() {
        //字符串可以使用+进行拼接
        var name = "yang" + "yan" + "xing"
        fmt.Println(name)
        //使用+=在原字符串后面追加字符串
        name += "杨彦星"
        fmt.Println(name)

        // + 不能在行首,只能写在行尾,就和if else中的else那样
        s := "BeiJing" +
            " TongZhou"
        fmt.Println(s)

    }

    ```

    在循环中使用 + 号进行拼接并不是高效的方法,可以使用` strings.Join `方法

    ```go
    package main

    import (
        "fmt"
        "strings"
    )

    func main() {
        var names = []string{"yang","fan","zhang","li","chen"}
        n := strings.Join(names," ")
        fmt.Println(n)

        s := "yang&aaa&bbb&ccc"
        //以&分割
        str := strings.Split(s,"&")
        fmt.Println(str)

    }

    ```

    >yang fan zhang li chen
    [yang aaa bbb ccc]

# strings包的常用方法
该包提供了字符串操作的常用方法

```go
package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "yang& yan&xing"
    //HasPrefix 判断字符串 s 是否以 prefix 开头
    fmt.Println(strings.HasPrefix(s,"y"))
    //HasSuffix 判断字符串 s 是否以 suffix 结尾
    fmt.Println(strings.HasSuffix(s,"aaa"))
    //Contains 判断字符串 s 是否包含 substr
    fmt.Println(strings.Contains(s,"yang"))
    //Replace替换字符串,最后一个参数为数量,-1为替换全部
    fmt.Println(strings.Replace(s,"y","Y",-1))

    //ToLower 将字符串中的 Unicode 字符全部转换为相应的小写字符
    ss := "AAA杨彦星BbbbB"
    fmt.Println(strings.ToLower(ss))
    //ToUpper 将字符串中的 Unicode 字符全部转换为相应的大写字符
    fmt.Println(strings.ToUpper(ss))

    //strings.TrimSpace(s) 来剔除字符串开头和结尾的空白符号
    //中间的不能删除
    sp := "  aaa bbb ccc  "
    fmt.Println(strings.TrimSpace(sp))
    //还可以去除开头或者结尾指定的字符
    ssp := "aaa Hey, how are you George?aaaa"
    fmt.Println(strings.TrimLeft(ssp,"He"))
    fmt.Println(strings.TrimRight(ssp,"ge"))
    fmt.Println(strings.Trim(ssp,"aaa"))

    //strings.Fields(s) 将会利用
    //strings.Split(s, sep) 用于自定义分割符号来对指定字符串进行分割
    sp2 := "  aa a b bb ccc  "
    fmt.Println(strings.Fields(sp2))
    fmt.Println(strings.Split(sp2," ")) //使用空格分割

    //Join 用于将元素类型为 string 的 slice 使用分割符号来拼接组成一个字符串
    sp3 := []string{"aa","a","b","bb","ccc"}
    fmt.Println(strings.Join(sp3,"$$$"))

}

结果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
true
false
true
Yang& Yan&xing
aaa杨彦星bbbbb
AAA杨彦星BBBBB
aaa bbb ccc
aaa Hey, how are you George?aaaa
aaa Hey, how are you George?aaaa
Hey, how are you George?
[aa a b bb ccc]
[  aa a b bb ccc  ]
aa$$$a$$$b$$$bb$$$ccc

字符串与其它类型的转换

使用strconv包中的方法可以实现字符串与其它类型的转换

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import (
	"fmt"
	"strconv"
)

func main() {
	//Itoa 将数字转为字符串
	fmt.Println(strconv.Itoa(35))
	// Atoi 将字符串转为其它类型并不一定会成功
	fmt.Println(strconv.Atoi("100"))
	fmt.Println(strconv.ParseBool("true")) //可以成功
	v,e := strconv.ParseBool("trues")//会有err
	if e!=nil{
		fmt.Println(e.Error())
	}else{
		fmt.Println(v)
	}
}