字符串

  1. 字符串只能用双引号定义,
  2. go里单引号和双引号不通过,可以使用`` 号来定义原始输出,不会进行转义,相当于python 里的三引号

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    package main

    import "fmt"

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

    输出

    1
    2
    3
    4
    杨彦星

    adgfgfg
    \n\t
  3. 字符串是不可改变的

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    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),有中文的情况下使用字符数组

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    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. 字符串与字节数组与字符数组的相互转换

    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"

    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. 字符串的遍历

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    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)
    }
    }

    结果为

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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. 字符串的拼接

    可以直接使用 + 拼接

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    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方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    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包的常用方法

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

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
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
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)
}
}