为什么golang在slice和map之间的`[]`运算符上实现不同的行为？ [重复]

type S struct {
    e int
}

func main() {
    a := []S{{1}}
    a[0].e = 2

    b := map[int]S{0: {1}}
    b[0].e = 2 // error
}

a[0] is addressable but b[0] is not.

I know first 0 is an index and second 0 is a key.

Why golang implement like this? Any further consideration?

I've read source code of map in github.com/golang/go/src/runtime and map structure already supported indirectkey and indirectvalue if maxKeySize and maxValueSize are little enough.

type maptype struct {
    ...
    keysize       uint8  // size of key slot
    indirectkey   bool   // store ptr to key instead of key itself
    valuesize     uint8  // size of value slot
    indirectvalue bool   // store ptr to value instead of value itself
    ...
}

I think if golang designers want this syntax, it works easy now.

Of course indirectkey indirectvalue may cost more resource and GC also need do more work.

So performance is the only reason for supporting this?

Or any other consideration?

In my opinion, supporting syntax like this is valuable.

</div>

As far as I known,

That's because a[0] can be replaced with address of array.

Similarly, a[1] can be replace with a[0]+(keySize*1).

But, In case of map one cannot do like that, hash algorithm changes from time to time based on your key, value pairs and number of them.

They are also rearranged from time to time.

specific computation is needed in-order to get the address of value.

Arrays or slices are easily addressable, but in case of maps it's like multiple function calls or structure look-ups ...

If one is thinking to replace it with what ever computation is needed, then binary size is going to be increased in orders of magnitude, and more over hash algorithm can keep changing from time to time.