Go语言——string、数组、切片以及map

一、string、数组、切片代码

1. package main
3. import "fmt"
5. // 定义结构体
6. type student struct {
7.         id    int
8.         name  string
9.         age   int
10.         score float32
11. }
13. func main() {
14.         // 使用var声明切片
15.         var slice1 []int
16.         slice1 = append(slice1, 1)
17.         slice1 = append(slice1, 2)
18.         slice1 = append(slice1, 3)
19.         fmt.Println("打印切片 = ", slice1)
20.         // 使用make关键字初始化，下面的意思为长度为5，容量为10
21.         slice2 := make([]int, 5, 10)
22.         slice2[0] = 1
23.         fmt.Println("打印make切片 = ", slice2)
24.         // 打印长度和其容量
25.         fmt.Printf("切片的长度 = %d，切片的容量 = %d\n", len(slice2), cap(slice2))
26.         // 切片化：语法u[low:high]创建对已存在数组进行操作的切片
27.         slice3 := []int{1, 2, 3, 4}
28.         fmt.Println("slice3 = ", slice3, len(slice3), cap(slice3))
29.         newSlice := slice3[1:]
30.         fmt.Println("newSlice = ", newSlice, len(newSlice), cap(newSlice))
31.         // 新创建的切片与最初的切片指向的底层其实是同一个数组，只是他们的指针的位置不一样，我们如果修改数组某个值，他们全都会修改
32.         newSlice[0] = 20
33.         fmt.Println("slice3 = ", slice3)
34.         fmt.Println("newSlice = ", newSlice)
35.         // 如果对新创建的切片进行append操作，如果没有发生扩容会向原数组中插入数据，如果发生扩容，新切片会创建一个新的数组，这条同样适用与原始切片
36.         newSlice = append(newSlice, 5)
37.         fmt.Println("添加元素后newSlice = ", newSlice)
38.         newSlice[0] = 10
39.         fmt.Println("添加元素后修改newSlice = ", newSlice)
40.         fmt.Println("添加元素后newSlice的 slice3 = ", slice3)
42.         // 使用var声明数组
43.         var intList1 [5]int
44.         intList1 = [5]int{1, 2, 3, 4, 5}
45.         fmt.Println("intList1 = ", intList1)
46.         // 短声明
47.         intList2 := [5]int{3, 4, 5, 6, 7}
48.         fmt.Println("intList2 = ", intList2)
49.         // 证明：在go语言中，数组是值传递的，修改传入的数组，发现原数组不变
50.         updateArray(intList2)
51.         fmt.Println("修改后的原数组 = ", intList2)
52.         // 声明结构体变量
53.         var s1 student
54.         s1.score = 1
55.         s1.age = 18
56.         s1.name = "小明"
57.         // 短声明
58.         s2 := student{
59.                 id:    1,
60.                 name:  "小贵",
61.                 age:   30,
62.                 score: 100,
63.         }
64.         // 使用&获取结构体指针
65.         p := &s2
66.         fmt.Println("s2.name", s2.name)
67.         fmt.Println("p.name", p.name)
68.         // 使用s2修改属性
69.         s2.name = "小新"
70.         fmt.Println("s2.name", s2.name)
71.         fmt.Println("p.name", p.name)
72.         // 使用p修改属性
73.         p.name = "小p"
74.         fmt.Println("s2.name", s2.name)
75.         fmt.Println("p.name", p.name)
76.         // 定义一个字符串
77.         name := "lucky"
78.         // 将字符串转化为字节数组给nameCopy
79.         nameCopy := []byte(name)
80.         // 修改第二个字符
81.         nameCopy[1] = 'l'
82.         fmt.Printf("nameCopy = [%s]\n", string(nameCopy))
84.         // 定义空字符串
85.         var school string
86.         fmt.Println("school = ", school)
87.         // 字符串支持 + 运算
88.         newName := name + " " + "day"
89.         fmt.Println("newName = ", newName)
90.         // 字符串支持 += 运算
91.         newName += "s"
92.         fmt.Println("newName = ", newName)
93.         if name != newName {
94.                 fmt.Println("ok")
95.         }
96.         // 使用`初始化字符串
97.         text := `ABCD
98. EFG`
99.         fmt.Println("text = ", text)
100. }
102. func updateArray(arr [5]int) {
103.         arr[0] = 100
104.         fmt.Println("修改后的数组 = ", arr)
105. }

复制代码

二、map代码

1. package main
3. import (
4.         "fmt"
5. )
7. func main() {
8.         // map的声明
9.         names := map[int]string{
10.                 1: "小明",
11.                 2: "小李",
12.                 3: "小刘",
13.         }
14.         names[4] = "小蓝"
15.         // 更新之后，原map也被修改，说明是引用传递
16.         updateNames(names)
17.         ages := make(map[int]int)
18.         ages[1] = 10
19.         ages[2] = 34
20.         ages[3] = 18
21.         fmt.Println(names)
22.         // map删除某个key
23.         delete(names, 4)
24.         fmt.Println(names)
26.         // 遍历map，每次打印结果不一样，表示是无序的
27.         for k, v := range names {
28.                 fmt.Println(k, v)
29.         }
30.         // map与数组一样，也存在扩容的问题，为了防止频繁扩容，最好给一个初始值
31.         initMap := make(map[int]int, 10)
32.         fmt.Println(len(initMap))
33. }
35. func updateNames(names map[int]string) {
36.         names[1] = "小王"
37. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。