来自 ruby，考虑 golang 指针确实需要转变思维。

在红宝石中，

• 变量是对对象的引用。
• 当您将一个变量分配给另一个变量时，两个变量都指向同一个对象。
• 通过任何变量更改对象将反映在所有引用中

# variable array_a is a reference to an array object
array_a = [1,2,3]

# array_b and array_c now points to the same array object as array_a
array_b = array_a
array_c = array_a

# updating array_b will update the underlying array object defined by 'array_a'
# array_a, array_b and array_c will have the same output
array_b << 4
puts "a: " + array_a
puts "b: " + array_b
puts "c: " + array_c

# output
# a: [1,2,3,4]
# b: [1,2,3,4]
# c: [1,2,3,4]

在 go 中：

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

• 变量可以存储实际值或指向值的指针（内存地址）。
• 将一个变量分配给另一个变量将复制该值
  • 这会产生两个自变量
• 指针允许您从多个变量引用相同的数据。-

go 指针（*type）引用存储数据的内存地址。 它需要像 *string=0x14000114180 这样的东西。 go 值（类型）保存实际数据 复制会创建一个新的独立实例

// main.go

package main

import "fmt"

func main() {
  // create an array of length 4, with initial values [1, 2, 3, 0]
  array_a := [4]int{1,2,3}

  // 'array_b' references the same underlying array as 'array_a'
  array_b := array_a
  array_c := array_c

  array_b[3] = 4
  fmt.println("array_a: " array_a)
  fmt.println("array_b: " array_b)
  fmt.println("array_c: " array_c)
}

// output
// array_a:  [1 2 3 0]
// array_b:  [1 2 3 4] <-- only b changed
// array_c:  [1 2 3 0]

为了达到与 ruby​​ 相同的结果，我们需要确保我们没有将 array_a 的值“复制”到 array_b 和 array_c。

相反，我们需要为 array_b 和 array_c 分配一个指向 array_a 的指针。

// main.go

package main

import "fmt"

func main() {
  // Create an array of length 4, with initial values [1, 2, 3, 0]
  array_a := [4]int{1,2,3}

  // 'array_b' and 'array_c' is a pointer to the memory address that stores the value of 'array_a'
  array_b := &array_a
  array_c := &array_c

  array_b[3] = 4

  // Since array_a does not store a pointer, we print it directly
  // array_a (value)
  // +-------------------+
  // | [1, 2, 3, 4]      |
  // +-------------------+
  //     ^
  //     |
  // &array_a (address) <--- array_c, array_b (pointers)
  //
  fmt.Println("array_a: ", array_a)
  // '*array_b' is called dereferencing
  // Since 'array_b' stores the pointer to 'array_a', weneed to "dereference it"
  fmt.Println("array_b: ", *array_b)
  fmt.Println("array_c: ", *array_c)
}

// output
// array_a:  [1 2 3 4]
// array_b:  [1 2 3 4] 
// array_c:  [1 2 3 4]