• Golang那些违背直觉的编程陷阱

    目录

    知识点1：切片拷贝之后都是同一个元素

    知识点2：方法集合决定接口实现，类型方法集合是接口方法集合的超集则认定为实现接口，否则未实现接口

    切片拷贝之后都是同一个元素
    1. package main
    2.  
    3. import (
    4. 	"encoding/json"
    5. 	"fmt"
    6. )
    7.  
    8. func arr1() {
    9. 	var nn []int
    10. 	for i := 0; i < 5; i++ {
    11. 		nn = append(nn, i)
    12. 	}
    13. 	marshal, _ := json.Marshal(nn)
    14. 	// [0,1,2,3,4]
    15. 	fmt.Println(string(marshal))
    16. }
    17.  
    18. func arr2() {
    19. 	var nn []*int
    20. 	for i := 0; i < 5; i++ {
    21.         // 出错原因：每次都是i的地址，i的地址始终是一个，所以最终数组元素是5
    22.         // 解决方法，每次新生命一个变量，之后使用每次新分配的变量进行赋值。参见arr3
    23. 		nn = append(nn, &i)
    24. 	}
    25. 	//[5,5,5,5,5]
    26. 	marshal, _ := json.Marshal(nn)
    27. 	fmt.Println(string(marshal))
    28. }
    29.  
    30. func arr3() {
    31. 	var nn []*int
    32. 	for i := 0; i < 5; i++ {
    33.         // 
    34. 		s := i
    35. 		nn = append(nn, &s)
    36. 	}
    37. 	marshal, _ := json.Marshal(nn)
    38. 	//[0,1,2,3,4]
    39. 	fmt.Println(string(marshal))
    40. }
    41.  
    42. func main() {
    43. 	arr1()
    44. 	arr2()
    45. 	arr3()
    46. }

    主要看一下arr2与arr3函数即可知晓，很好理解却又很容易疏忽。接下来看一个类似问题的变种，跟struct方法有关系示例：

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"time"
    6. )
    7.  
    8. type field struct {
    9. 	name string
    10. }
    11.  
    12. func (p *field) print() {
    13. 	fmt.Println(p.name)
    14. }
    15.  
    16. func main() {
    17.  
    18. 	data1 := []*field{{"one"}, {"two"}, {"three"}}
    19. 	for _, v := range data1 {
    20. 		go v.print()
    21. 	}
    22.  
    23. 	data2 := []field{{"four"}, {"five"}, {"six"}}
    24. 	for _, v := range data2 {
    25. 		go v.print()
    26. 	}
    27.  
    28.  
    29. 	time.Sleep(3 * time.Second)
    30. }

    | 这个代码执行输出结果：

    看到结果是不是很意外，为什么有3个six呢？接下来分下一下：由于field的print方法是指针类型，所以data2每次在调用print方法时都是v指向的内存对象，这个对象最后一次赋值是six，所以输出的是3个six（其实此处存在不确定性，main协程与子协程的调度顺序，如果每次调度main协程之后立马就去调度子协程可能结果就是正确的了）。

    那怎么修复问题呢？

    方法1：

    将filed的print方法的接受者修改为值类型，这样每次调用时都会拷贝一个副本进行调用，就会背面这个问题了，具体如下：

    1. func (p field) print() {
    2. 	fmt.Println(p.name)
    3. }

    方法2：

    每次调用时重新声明一个变量进行调用，这个底层原理也是拷贝一个副本进行调用，具体修改如下：

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"time"
    6. )
    7.  
    8. type field struct {
    9. 	name string
    10. }
    11.  
    12. func (p *field) print() {
    13. 	fmt.Println(p.name)
    14. }
    15.  
    16. func main() {
    17.  
    18. 	data1 := []*field{{"one"}, {"two"}, {"three"}}
    19. 	for _, v := range data1 {
    20. 		go v.print()
    21. 	}
    22.  
    23. 	data2 := []field{{"four"}, {"five"}, {"six"}}
    24. 	for _, v := range data2 {
    25. 		replica := v
    26.         // 此处每次都是重新分配一个内存存储v的副本
    27. 		go replica.print()
    28. 	}
    29.  
    30. 	time.Sleep(3 * time.Second)
    31. }
    方法集合决定接口实现，类型方法集合是接口方法集合的超集则认定为实现接口，否则未实现接口
    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"reflect"
    6. )
    7.  
    8. type Interface interface {
    9. 	M1()
    10. 	M2()
    11. }
    12.  
    13. type T struct{}
    14.  
    15. func (t T) M1()  {}
    16. func (t *T) M2() {}
    17.  
    18. func DumpMethodSet(i interface{}) {
    19. 	v := reflect.TypeOf(i)
    20. 	elemTyp := v.Elem()
    21.  
    22. 	n := elemTyp.NumMethod()
    23. 	if n == 0 {
    24. 		fmt.Printf("%s's method set is empty!\n", elemTyp)
    25. 		return
    26. 	}
    27.  
    28. 	fmt.Printf("%s's method set:\n", elemTyp)
    29. 	for j := 0; j < n; j++ {
    30. 		fmt.Println("-", elemTyp.Method(j).Name)
    31. 	}
    32. 	fmt.Printf("\n")
    33. }
    34. func main() {
    35. 	var t T
    36. 	var pt *T
    37.  
    38. 	var i Interface
    39. 	//Cannot use 't' (type T) as type Interface
    40. 	//Type does not implement 'Interface' as 'M2' method has a pointer receiver
    41. 	// 言外之意就是类型T没有实现接口的M2方法
    42. 	i = t
    43. 	i = pt
    44. }

    此处主要需要了解Go方法集合规范是什么才能更好解释问题。如下工具方法可以用于查看类型的方法集合，具体代码如下：

    1. func DumpMethodSet(i interface{}) {
    2. 	v := reflect.TypeOf(i)
    3. 	elemTyp := v.Elem()
    4.  
    5. 	n := elemTyp.NumMethod()
    6. 	if n == 0 {
    7. 		fmt.Printf("%s's method set is empty!\n", elemTyp)
    8. 		return
    9. 	}
    10.  
    11. 	fmt.Printf("%s's method set:\n", elemTyp)
    12. 	for j := 0; j < n; j++ {
    13. 		fmt.Println("-", elemTyp.Method(j).Name)
    14. 	}
    15. 	fmt.Printf("\n")
    16. }

    调用：

    1. var t T
    2. var pt *T
    3. DumpMethodSet(&t)
    4. DumpMethodSet(&pt)
    5. DumpMethodSet((*Interface)(nil))

    输出：

    因为T类型的方法集合只有M1，所以导致上面将T类型实例赋值给接口类型会报错。

    重点：Golang方法集合规范

    1. 对于非接口类型的自定义类型T，其方法集合由所有receiver为T类型的方法组成；

    2. 而类型*T的方法集合则包含所有receiver为T和*T类型的方法。也正因为如此，pt才能成功赋值给Interface类型变量。

    特别提示：在进行组合时候，内嵌的是指针或值类型的结构体所以涉及引入的方法集是不一样的，也遵循上面规范。一般来说内嵌指针的方法集大于等于值得方法集。参见代码：

    1. package main
    2.  
    3. import "51788.net/golang-day01/dump_method_set"
    4.  
    5. //main.T1's method set:
    6. //- T1M1
    7. //- T1M2
    8.  
    9. //*main.T1's method set:
    10. //- PT1M3
    11. //- T1M1
    12. //- T1M2
    13. type T1 struct{}
    14.  
    15. func (T1) T1M1()   { println("T1's M1") }
    16. func (T1) T1M2()   { println("T1's M2") }
    17. func (*T1) PT1M3() { println("PT1's M3") }
    18.  
    19. //main.T2's method set:
    20. //- T2M1
    21. //- T2M2
    22. //
    23. //*main.T2's method set:
    24. //- PT2M3
    25. //- T2M1
    26. //- T2M2
    27. type T2 struct{}
    28.  
    29. func (T2) T2M1()   { println("T2's M1") }
    30. func (T2) T2M2()   { println("T2's M2") }
    31. func (*T2) PT2M3() { println("PT2's M3") }
    32.  
    33. //main.T's method set:
    34. //- PT2M3
    35. //- T1M1
    36. //- T1M2
    37. //- T2M1
    38. //- T2M2
    39. //
    40. //*main.T's method set:
    41. //- PT1M3
    42. //- PT2M3
    43. //- T1M1
    44. //- T1M2
    45. //- T2M1
    46. //- T2M2
    47. type T struct {
    48. 	T1
    49. 	*T2
    50. }
    51.  
    52. func main() {
    53. 	t := T{
    54. 		T1: T1{},
    55. 		T2: &T2{},
    56. 	}
    57. 	pt := &t
    58.  
    59. 	var t1 T1
    60. 	var pt1 *T1
    61. 	dump_method_set.DumpMethodSet(&t1)
    62. 	dump_method_set.DumpMethodSet(&pt1)
    63.  
    64. 	var t2 T2
    65. 	var pt2 *T2
    66. 	dump_method_set.DumpMethodSet(&t2)
    67. 	dump_method_set.DumpMethodSet(&pt2)
    68.  
    69. 	dump_method_set.DumpMethodSet(&t)
    70. 	dump_method_set.DumpMethodSet(&pt)
    71. }

    结论：

    • T类型的方法集合 = T1的方法集合 + *T2的方法集合；
    • *T类型的方法集合 = *T1的方法集合 + *T2的方法集合。
    接口方法覆盖
    1. package main
    2.  
    3. import "51788.net/golang-day01/dump_method_set"
    4.  
    5. type Interface1 interface {
    6. 	M1()
    7. }
    8.  
    9. type Interface2 interface {
    10. 	M1()
    11. 	M2()
    12. }
    13.  
    14. type Interface3 interface {
    15. 	Interface1
    16. 	Interface2 // Go 1.14之前版本报错：duplicate method M1
    17. }
    18.  
    19. type Interface4 interface {
    20. 	Interface2
    21. 	M2() // Go 1.14之前版本报错：duplicate method M2
    22. }
    23.  
    24. func main() {
    25. 	dump_method_set.DumpMethodSet((*Interface3)(nil))
    26. }

    在golang1.14版本之后允许接口中相同方法的覆盖。

    类型里面内嵌多个接口，多个接口方法集合存在交集

    当多个接口方法存在交集时，交集方法必须在类型上进行显示实现，否则调用交集方法时会报错。（当然如果不显示实现，而且后续不调用交集方法的话也不会报错。如果使用交集方法就要一定在类型上实现交集方法）。

    示例1:

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type IRun1 interface {
    6. 	M1()
    7. 	M2()
    8. }
    9.  
    10. type IRun2 interface {
    11. 	M2()
    12. 	M3()
    13. }
    14.  
    15. type IRun1Impl struct{}
    16.  
    17. func (IRun1Impl) M1() {
    18. 	fmt.Println(" (IRun1Impl) M1()")
    19. }
    20.  
    21. func (IRun1Impl) M2() {
    22. 	fmt.Println(" (IRun1Impl) M2()")
    23. }
    24.  
    25. type IRun2Impl struct{}
    26.  
    27. func (IRun2Impl) M2() {
    28. 	fmt.Println(" (IRun2Impl) M2()")
    29. }
    30.  
    31. func (IRun2Impl) M3() {
    32. 	fmt.Println(" (IRun2Impl) M3()")
    33. }
    34.  
    35. type TRun struct {
    36. 	IRun1
    37. 	IRun2
    38. }
    39.  
    40. func (e TRun) M1() {
    41. 	fmt.Println("t m1")
    42. }
    43.  
    44. // 一定在类型上实现交集方法
    45. func (e TRun) M2() {
    46. 	fmt.Println("t m2")
    47. }
    48.  
    49. func main() {
    50. 	e := TRun{
    51. 		IRun1: &IRun1Impl{},
    52. 		IRun2: &IRun2Impl{},
    53. 	}
    54. 	e.M1()
    55. 	e.M2()
    56. 	e.M3()
    57. 	//	输出：
    58. 	//t m1
    59. 	//t m2
    60. 	// (IRun2Impl) M3()
    61. }

    示例2：

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type IRun1 interface {
    6. 	M1()
    7. 	M2()
    8. }
    9.  
    10. type IRun2 interface {
    11. 	M2()
    12. 	M3()
    13. }
    14.  
    15. type IRun1Impl struct{}
    16.  
    17. func (IRun1Impl) M1() {
    18. 	fmt.Println(" (IRun1Impl) M1()")
    19. }
    20.  
    21. func (IRun1Impl) M2() {
    22. 	fmt.Println(" (IRun1Impl) M2()")
    23. }
    24.  
    25. type IRun2Impl struct{}
    26.  
    27. func (IRun2Impl) M2() {
    28. 	fmt.Println(" (IRun2Impl) M2()")
    29. }
    30.  
    31. func (IRun2Impl) M3() {
    32. 	fmt.Println(" (IRun2Impl) M3()")
    33. }
    34.  
    35. type TRun struct {
    36. 	IRun1
    37. 	IRun2
    38. }
    39.  
    40. func (e TRun) M1() {
    41. 	fmt.Println("t m1")
    42. }
    43.  
    44. func main() {
    45. 	e := TRun{
    46. 		IRun1: &IRun1Impl{},
    47. 		IRun2: &IRun2Impl{},
    48. 	}
    49. 	e.M1()
    50. 	// 不在类型上声明M2方法，虽然两个接口都有声明M2方法，但是也会报错：
    51. 	// 编译器报错：Ambiguous reference 'M2'
    52. 	e.M2()
    53. 	e.M3()
    54.  
    55. }

    示例三：

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type IRun1 interface {
    6. 	M1()
    7. 	M2()
    8. }
    9.  
    10. type IRun2 interface {
    11. 	M2()
    12. 	M3()
    13. }
    14.  
    15. type IRun1Impl struct{}
    16.  
    17. func (IRun1Impl) M1() {
    18. 	fmt.Println(" (IRun1Impl) M1()")
    19. }
    20.  
    21. func (IRun1Impl) M2() {
    22. 	fmt.Println(" (IRun1Impl) M2()")
    23. }
    24.  
    25. type IRun2Impl struct{}
    26.  
    27. func (IRun2Impl) M2() {
    28. 	fmt.Println(" (IRun2Impl) M2()")
    29. }
    30.  
    31. func (IRun2Impl) M3() {
    32. 	fmt.Println(" (IRun2Impl) M3()")
    33. }
    34.  
    35. type TRun struct {
    36. 	IRun1
    37. 	IRun2
    38. }
    39.  
    40. func (e TRun) M1() {
    41. 	fmt.Println("t m1")
    42. }
    43.  
    44. func main() {
    45. 	e := TRun{
    46. 		IRun1: &IRun1Impl{},
    47. 		IRun2: &IRun2Impl{},
    48. 	}
    49. 	e.M1()
    50. 	// 虽然没有在类型上声明M2方法，但是不调用M2方法的话也不会存在编译错误
    51. 	// 满足原则：你用你写，不用不写(u can u up)
    52. 	//e.M2()
    53. 	e.M3()
    54. }

    小提示：现实中应该避免这种复杂编程，显然无疑的提高了问题复杂度，并无显著收益。

    类型里面内嵌接口
    1.  
    2. type InterfaceX interface {
    3. 	M1()
    4. 	M2()
    5. }
    6.  
    7. type TS struct {
    8. 	InterfaceX
    9. }
    10.  
    11. func (TS) M3() {}

    类型TS内嵌接口InterfaceX是允许的，而且编译器不要求强制必须实现M1与M2方法，这个如果有Java经验的话会很违背经验。但是Golang就是允许的，但是如果你调用未实现的方法就会报错：

    1. func main() {
    2. 	var t TS
    3. 	t.M1()
    4. }

    查看一下方法集合：

    1. func main() {
    2. 	dump_method_set.DumpMethodSet((*InterfaceX)(nil))
    3. 	var t TS
    4. 	var pt *TS
    5. 	dump_method_set.DumpMethodSet(&t)
    6. 	dump_method_set.DumpMethodSet(&pt)
    7. }

    输出：

    类型中内嵌接口，命名冲突的方法调用优先级
    1. package main
    2.  
    3. type Interface interface {
    4. 	M1()
    5. 	M2()
    6. }
    7.  
    8. type T struct {
    9. 	Interface
    10. }
    11.  
    12. // 类型T上实现了接口M1方法，但是类型T未实现M2方法
    13. func (T) M1() {
    14. 	println("T's M1")
    15. }
    16.  
    17. type S struct{}
    18.  
    19. func (S) M1() {
    20. 	println("S's M1")
    21. }
    22. func (S) M2() {
    23. 	println("S's M2")
    24. }
    25.  
    26. func main() {
    27. 	var t = T{
    28. 		Interface: S{},
    29. 	}
    30. 	// 因为类型实现了M1方法，所以直接调用M1的方法
    31. 	t.M1()
    32. 	// 因为接口类型没有实现M2方法，所以调用会从内嵌的接口上寻找方法
    33. 	t.M2()
    34. }

  • 相关阅读:
    自动驾驶：2022 apollo day 观后感（三）
    springboot集成logback打印彩色日志
    低代码助力中小企业数字化
    2023最新UI工作室官网个人主页源码/背景音乐/随机壁纸/一言
    单链表的定义— 不带头结点 + 带头结点
    高性能 MySQL（十二）：分区表
    oracle行转列、列转行总结
    顾客为什么不到店了？
    如何快速开发app？小程序+插件少不了
    leetcode 20. 有效的括号
  • 原文地址：https://blog.csdn.net/Dax1n/article/details/138025773