臂架..

Question

a := [...]int{5, 4: 1, 0, 2: 3, 2, 1: 4 }
fmt.Println(a)

结果为[5 4 3 2 1 0]。怎么样？

a := [...]int{5, 4: 1, 0, 2: 3, 2, 1: 4 ,12,11,10}
fmt.Println(a)

结果是

prog.go:8: duplicate index in array literal: 2
prog.go:8: duplicate index in array literal: 3
prog.go:8: duplicate index in array literal: 4
 [process exited with non-zero status]

谁可以解释这两个结果？

Answer 1

前几天我看到Dave Cheney发了这条推文。我的理解是：

第一个 - 戴夫正在工作

<number_here>:是数组中的索引。这个＆＃34;设置＆＃34;当前索引..这就是为什么索引必须进一步进入声明的原因＆＃34; reset＆＃34;回到数组中。所以，第一个数字是5（索引0），第二个数字是＃34;条目＆＃34;索引为4: ..因此值1将位于索引4：

5 _ _ _ 1 _
         ^ index is currently here

..下一个没有索引，但会在给出最后一个索引后继续。这是4+1 ..因此索引5获取值0：

5 _ _ _ 1 0
           ^ index is here.. it needs to be reset

现在索引将超出..因此它会进一步设置。下一个是2: ..因此，将值设置为值3：

5 _ 3 _ 1 0
     ^ index is here

接下来再继续，因为它没有索引：

5 _ 3 2 1 0
       ^ index is here

然后最后一个具有索引1: ..，其值为4：

5 4 3 2 1 0

第二个 - 你的坏人。

第二个是相同的 - 但你没有保护当前放置的索引的覆盖。让我们一步一步：

索引0处的值5：

5 _ _ _ _ _ _ _ _
 ^ index is here

索引4处的值1：

5 _ _ _ 1 _ _ _ _
         ^ index is here

索引5处的值0（请记住，它会继续）：

5 _ _ _ 1 0 _ _ _
           ^ index is here

索引2处的值3：

5 _ 3 _ 1 0 _ _ _
     ^ index is here

索引3处的值2（再次，它继续：

5 _ 3 2 1 0 _ _ _
       ^ index is here

索引1处的值4：

5 4 3 2 1 0 _ _ _
   ^ index is here ... you're awfully close to overwriting the next value

索引2处的值12：

5 4 12 2 1 0 _ _ _
    ^^^^^ BOOOM

臂架..

..你已经覆盖了值3，并且在索引为剩余值的位置继续这样做。这就是问题..

Answer 2

Composite literals

复合文字构造结构，数组，切片和的值   映射并在每次评估时创建新值。他们包括   值的类型后跟一个大括号括号的复合列表   元素。元素可以是单个表达式或键值对。

Iota

在常量声明中，预先声明的标识符iota   表示连续的无类型整数常量。它被重置为0   只要保留字const出现在源中并递增   在每个ConstSpec之后。它可以用来构造一组相关的   常数

例如，使用基于iota的密钥，以下内容是等效的，

package main

import "fmt"

func main() {
    a := [...]int{5, 4: 1, 0, 2: 3, 2, 1: 4}
    fmt.Println(a)
    b := [...]int{0: 5, 4: 1, 5: 0, 2: 3, 3: 2, 1: 4}
    fmt.Println(b)
    c := make([]int, 6)
    i := 0
    c[i] = 5
    i = 4
    c[i] = 1
    i++
    c[i] = 0
    i = 2
    c[i] = 3
    i++
    c[i] = 2
    i = 1
    c[i] = 4
    fmt.Println(c)
}

输出：

[5 4 3 2 1 0]
[5 4 3 2 1 0]
[5 4 3 2 1 0]

碰撞会导致错误，例如a隐式和b显式，

package main

import "fmt"

func main() {
    a := [...]int{5, 4: 1, 0, 2: 3, 2, 1: 4, 12, 11, 10}
    fmt.Println(a)
    b := [...]int{0: 5, 4: 1, 5: 0, 2: 3, 3: 2, 1: 4, 2: 12, 3: 11, 4: 10}
    fmt.Println(b)
}

输出：

prog.go:6: duplicate index in array literal: 2
prog.go:6: duplicate index in array literal: 3
prog.go:6: duplicate index in array literal: 4
prog.go:8: duplicate index in array literal: 2
prog.go:8: duplicate index in array literal: 3
prog.go:8: duplicate index in array literal: 4

关于golang数组

2 个答案:

第一个 - 戴夫正在工作

第二个 - 你的坏人。

臂架..