Go语言基础语法 - 03

切片

package main

import "fmt"

func main() {

    s := make([]string, 3)
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("get:", s[2])   // c
    fmt.Println("len:", len(s)) // 3

    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println(s) // [a b c d e f]

    c := make([]string, len(s))
    copy(c, s)
    fmt.Println(c) // [a b c d e f]

    fmt.Println(s[2:5]) // [c d e]
    fmt.Println(s[:5])  // [a b c d e]
    fmt.Println(s[2:])  // [c d e f]

    good := []string{"g", "o", "o", "d"}
    fmt.Println(good) // [g o o d]
}

1. 切片声明和初始化
   • 切片不同于数组，可以动态调整长度，并且提供了更多的操作方法。
   • 使用 make 函数创建一个切片，例如 s := make([]string, 3) 创建一个长度为 3 的字符串切片 s。
2. 切片元素赋值
   • 切片可以像数组一样通过索引访问和赋值元素，例如 s[0] = "a" 将切片 s 的第一个元素赋值为 "a"。
3. 切片元素访问
   • 通过索引访问切片元素，例如 s[2] 获取切片 s 的第三个元素。
   • 使用 fmt.Println("get:", s[2]) 打印切片 s 的第三个元素。
4. 切片长度
   • 使用内置函数 len 获取切片的长度，例如 len(s) 返回切片 s 的长度。
   • 使用 fmt.Println("len:", len(s)) 打印切片 s 的长度。
5. 追加元素
   • 使用 append 函数向切片追加元素，例如 s = append(s, "d") 向切片 s 追加元素 "d"。
   • 注意：append 函数会返回一个新的切片，因此需要将结果赋值回原切片变量。
6. 切片复制
   • 使用 copy 函数将一个切片的内容复制到另一个切片，例如 copy(c, s) 将切片 s 的内容复制到切片 c。
7. 切片操作
   • 切片支持类似 Python 的切片操作，例如 s[2:5] 表示获取切片 s 的第 2 到第 5 个元素（不包括第 5 个元素）。
   • s[:5] 表示获取切片 s 的前 5 个元素。
   • s[2:] 表示获取切片 s 的第 2 个元素到最后一个元素。
   • 注意：Go 语言的切片操作不支持负数索引。
8. 切片初始化
   • 切片可以在声明时进行初始化，例如 good := []string{"g", "o", "o", "d"} 声明并初始化一个字符串切片 good。
   • 使用 fmt.Println(good) 打印切片 good 的所有元素。

map

package main

import "fmt"

func main() {
    m := make(map[string]int)
    m["one"] = 1
    m["two"] = 2
    fmt.Println(m)           // map[one:1 two:2]
    fmt.Println(len(m))      // 2
    fmt.Println(m["one"])    // 1
    fmt.Println(m["unknow"]) // 0

    r, ok := m["unknow"]
    fmt.Println(r, ok) // 0 false

    delete(m, "one")

    m2 := map[string]int{"one": 1, "two": 2}
    var m3 = map[string]int{"one": 1, "two": 2}
    fmt.Println(m2, m3)
}

1. map 声明和初始化
   • 在 Go 语言中，map 是一种键值对数据结构，类似于其他编程语言中的哈希表或字典。
   • 使用 make 函数创建一个空的 map，例如 m := make(map[string]int) 创建一个键类型为 string，值类型为 int 的 map。
2. 存储键值对
   • 可以向 map 中存储键值对，例如 m["one"] = 1 将键 "one" 的值设置为 1。
3. 访问键值对
   • 通过键访问 map 中的值，例如 m["one"] 获取键 "one" 对应的值。
   • 使用 fmt.Println(m["one"]) 打印键 "one" 对应的值。
4. map 长度
   • 使用内置函数 len 获取 map 的长度，例如 len(m) 返回 map 中键值对的数量。
   • 使用 fmt.Println(len(m)) 打印 map 的长度。
5. 访问不存在的键
   • 访问 map 中不存在的键时，会返回值类型的零值，例如 m["unknow"] 返回 0。
   • 使用 r, ok := m["unknow"] 获取键 "unknow" 对应的值和一个布尔值 ok，表示键是否存在。
   • 使用 fmt.Println(r, ok) 打印键 "unknow" 对应的值和是否存在的布尔值。
6. 删除键值对
   • 使用 delete 函数从 map 中删除键值对，例如 delete(m, "one") 删除键 "one" 及其对应的值。
7. map 初始化
   • 可以在声明 map 的同时进行初始化，例如 m2 := map[string]int{"one": 1, "two": 2} 声明并初始化一个 map。
   • 使用 fmt.Println(m2) 打印 map m2 的所有键值对。
8. map 的无序性
   • Go 语言中的 map 是无序的，遍历时不会按照字母顺序或插入顺序输出，而是随机顺序。

range

range 遍历切片

• range 可以用于遍历切片，返回两个值：索引和对应位置的值。

nums := []int{2, 3, 4}
sum := 0
for i, num := range nums {
    sum += num
    if num == 2 {
        fmt.Println("index:", i, "num:", num) // index: 0 num: 2
    }
}
fmt.Println(sum) // 9

忽略索引

• 如果不需要索引，可以使用下划线 _ 来忽略

for _, num := range nums {
    sum += num
}

range 遍历 map

• range 也可以用于遍历 map，返回两个值：键和值。

m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
    fmt.Println(k, v) // a A; b B
}

只遍历键

• 如果只需要键，可以省略值，

for k := range m {
    fmt.Println("key", k) // key a; key b
}