Golang练习

下面代码里的 counter 的输出值？ package main import "fmt" func main() { var m = map[string]int{ "A": 21, "B": 22, "C": 23, } counter := 0 for k, v := range m { if counter == 0 { delete(m, "A") } counter++ fmt.Println(k, v) } fmt.Println("counter is ", counter) } A. 2 B. 3 C. 2 或 3 🔑 答案解析： C Go在线运行 for range map 是无序的，如果第一次循环到 A，则输出 3；否则输出 2。

下面这段代码输出结果正确吗？为什么？ package main import "fmt" type Foo struct { bar string } func main() { s1 := []Foo{ {"A"}, {"B"}, {"C"}, } s2 := make([]*Foo, len(s1)) for i, value := range s1 { s2[i] = &value } fmt.Println(s1[0], s1[1], s1[2]) fmt.Println(s2[0], s2[1], s2[2]) } // 输出： // {A} {B} {C} // &{A} &{B} &{C} 🔑 答案解析： Go在线运行 这个问题要看Go版本，在Go版本<1.22时输出的结果为 // 输出： // {A} {B} {C} // &{C} &{C} &{C} 而1.22以后的版本输出的结果是 // 输出： // {A} {B} {C} // &{A} &{B} &{C} 在1.22以前 for i, value := range s1 中会复用value的地址。 s2[i] = &value 记录的地址都是同一个地址。 每次循环迭代中value的内容不断的变换，直到遍历到最后一个值即{C} ...

下面这段代码输出什么？ package main import "fmt" func main() { var a = []int{1, 2, 3, 4, 5} var r [5]int for i, v := range a { if i == 0 { a[1] = 12 a[2] = 13 } r[i] = v } fmt.Println("r = ", r) fmt.Println("a = ", a) } 🔑 答案解析： r = [1 12 13 4 5] a = [1 12 13 4 5] Go在线运行 遍历的虽然是a的副本，但是在不发生扩容的情况下，副本和a指向的都是同一个底层数组，因此可以修改到a的内容

下面这段代码输出什么？ package main import "fmt" func change(s ...int) { s = append(s, 3) } func main() { slice := make([]int, 5, 5) slice[0] = 1 slice[1] = 2 change(slice...) fmt.Println(slice) change(slice[0:2]...) fmt.Println(slice) } 🔑 答案解析： [1 2 0 0 0] [1 2 3 0 0] Go在线运行

下面这段代码输出什么？ package main import "fmt" func main() { var a = [5]int{1, 2, 3, 4, 5} var r [5]int for i, v := range a { if i == 0 { a[1] = 12 a[2] = 13 } r[i] = v } fmt.Println("r = ", r) fmt.Println("a = ", a) } 🔑 答案解析： r = [1 2 3 4 5] a = [1 12 13 4 5] Go在线运行 数组的 range 行为：当使用 range 遍历数组时，Go 会先创建原数组的副本，遍历的是这个副本。因此，循环中对原数组的修改不会影响迭代中的值。

下面这段代码输出什么？为什么？ package main import "fmt" type People interface { Show() } type Student struct{} func (stu *Student) Show() { } func main() { var s *Student if s == nil { fmt.Println("s is nil") } else { fmt.Println("s is not nil") } var p People = s if p == nil { fmt.Println("p is nil") } else { fmt.Println("p is not nil") } } 🔑 答案解析： s is nil p is not nil 记住一点，当且仅当动态值和动态类型都为 nil 时，接口类型值才为 nil。 代码解析： 1. 变量 s 的判断 var s *Student 声明了一个 *Student 类型的指针变量 s，默认值为 nil 直接判断 s == nil 为 true，输出 s is nil 2. 变量 p 的判断 var p People = s 将 s（值为 nil 的指针）赋值给接口类型 People 的变量 p Go 接口的底层结构：接口变量 p 包含两个字段： 动态类型（*Student）：存储赋值给接口的具体类型 动态值（nil）：存储具体类型的值 接口判空规则：只有当接口的 动态类型 和 动态值 同时为 nil 时，接口变量才等于 nil 本例中，p 的 动态类型 是 *Student（非 nil），动态值 是 nil，因此 p == nil 为 false，输出 p is not nil 关键结论 指针判空：var s *T 的默认值是 nil 接口判空： 如果直接将 nil 赋给接口（如 var p People = nil），则接口的 动态类型 和 动态值 均为 nil，此时 p == nil 为 true 如果通过具体类型的 nil 指针赋给接口（如 var p People = s），则接口的 动态类型 会被记录为具体类型（非 nil），即使值为 nil，接口变量也不等于 nil 总结： ...

下面这段代码输出什么？ package main import "fmt" const ( a = iota b = iota ) const ( name = "name" c = iota d = iota ) func main() { fmt.Println(a) fmt.Println(b) fmt.Println(c) fmt.Println(d) } 🔑 答案解析： 0 1 1 2 在线运行 代码解析： 第一个 const 块 a = iota: iota 在 const 块中从 0 开始计数，因此 a = 0 b = iota: iota 自增到 1，因此 b = 1 第二个 const 块 name = "name": 未使用 iota，但 iota 初始值为 0，声明后自增到 1 c = iota: 当前 iota 值为 1，因此 c = 1 d = iota: iota 继续自增到 2，因此 d = 2 关键规则 iota 在每个 const 块中从 0 开始计数 每行常量声明（无论是否使用 iota）都会使 iota 自增 1 不同 const 块的 iota 相互独立

下面这段代码输出什么？为什么？ package main import ( "fmt" ) func main() { s1 := []int{1, 2, 3} s2 := s1[1:] s2[1] = 4 fmt.Println(s1) s2 = append(s2, 5, 6, 7) fmt.Println(s2) } 🔑 答案解析： [1 2 4] [2 4 5 6 7] 在线运行 切片共享底层数组 s1 初始化为 []int{1, 2, 3}，底层数组为 [1, 2, 3]，长度和容量均为 3。 s2 := s1[1:] 创建了 s1 的子切片。此时： s2 的底层数组与 s1 相同。 s2 的起始索引为 1，长度为 2（元素为 [2, 3]），容量为 2（原切片容量 3 - 起始索引 1 = 2）。 修改共享元素 s2[1] = 4 修改的是底层数组的第三个元素（索引 2）。由于 s1 和 s2 共享底层数组，s1 变为 [1, 2, 4]。 append 触发扩容 s2 = append(s2, 5, 6, 7) 时，原容量 2 不足以容纳 5 个元素（原长度 2 + 3 个新增元素），触发扩容。 扩容后，s2 的底层数组变为全新的数组，与原 s1 完全独立。 新 s2 的元素为 [2, 4, 5, 6, 7]，而 s1 不受影响。

下面这段代码输出什么？为什么？ package main import ( "fmt" ) func main() { s1 := []int{1, 2, 3} s2 := s1[1:] s2[1] = 4 fmt.Println(s1) s2 = append(s2, 5, 6, 7) fmt.Println(s1) } 🔑 答案解析： [1 2 4] [1 2 4] 在线运行 切片共享底层数组 初始化切片 s1： s1 初始化为 []int{1, 2, 3}，底层数组容量为 3。 创建新切片 s2： s2 := s1[1:] 创建了一个新切片，起始索引为 1，长度为 2（元素为 2, 3），容量为 2（原数组容量 3 减去起始索引 1）。 修改共享元素： s2[1] = 4 修改的是底层数组的索引 2（对应 s1[2]），因此 s1 变为 [1, 2, 4]。 append 触发扩容： 当执行 s2 = append(s2, 5, 6, 7) 时，原切片 s2 的容量已满（长度 2，容量 2）。 追加操作触发底层数组扩容，系统分配新数组，原数据被复制到新数组，后续修改不再影响 s1 的底层数组。 两次输出结果一致： ...

下面的代码有几处语法问题，各是什么？ package main import ( "fmt" ) func main() { var x string = nil if x == nil { x = "default" } fmt.Println(x) } 🔑 答案解析： ./prog.go:8:17: cannot use nil as string value in variable declaration ./prog.go:9:10: invalid operation: x == nil (mismatched types string and untyped nil) var x string = nil 错误 在 Go 语言中，string 类型的零值是空字符串 ""，而不是 nil。nil 通常用于指针、切片、映射、通道、接口等类型。因此，将 nil 赋值给 string 类型的变量 x 会导致编译错误。 正确的写法应该是：var x string 或 var x string = ""。 if x == nil 错误 由于 x 是 string 类型，不能与 nil 进行比较。string 类型的变量应该与空字符串 "" 进行比较。 ...