"在 golang 中，使用 make vs {} 初始化的地图之间是否存在性能差异"

Question

我们知道有两种初始化地图的方法（如下所列）。 我想知道这两种方法之间是否存在任何性能差异。

var myMap map[string]int

Answer 1

在我的机器上，它们看起来大致相当。

您可以轻松地进行基准测试以进行比较。 例如：

package bench

import "testing"

var result map[string]int

func BenchmarkMakeLiteral(b *testing.B) {
        var m map[string]int
        for n := 0; n < b.N; n++ {
                m = InitMapLiteral()
        }
        result = m
}

func BenchmarkMakeMake(b *testing.B) {
        var m map[string]int
        for n := 0; n < b.N; n++ {
                m = InitMapMake()
        }
        result = m
}

func InitMapLiteral() map[string]int {
        return map[string]int{}
}

func InitMapMake() map[string]int {
        return make(map[string]int)
}

在3次不同的运行中产生的结果足够接近无关紧要：

第一次运行

$ go test -bench=.
testing: warning: no tests to run
PASS
BenchmarkMakeLiteral-8  10000000               160 ns/op
BenchmarkMakeMake-8     10000000               171 ns/op
ok      github.com/johnweldon/bench     3.664s

第二轮

$ go test -bench=.
testing: warning: no tests to run
PASS
BenchmarkMakeLiteral-8  10000000               182 ns/op
BenchmarkMakeMake-8     10000000               173 ns/op
ok      github.com/johnweldon/bench     3.945s

第三次运行

$ go test -bench=.
testing: warning: no tests to run
PASS
BenchmarkMakeLiteral-8  10000000               170 ns/op
BenchmarkMakeMake-8     10000000               170 ns/op
ok      github.com/johnweldon/bench     3.751s

Answer 2

分配空映射时没有区别，但是make可以传递第二个参数来预先分配map中的空间。 这将在填充地图时节省大量重新分配。

基准

package maps

import "testing"

const SIZE = 10000

func fill(m map[int]bool, size int) {
    for i := 0; i < size; i++ {
        m[i] = true
    }
}

func BenchmarkEmpty(b *testing.B) {
    for n := 0; n < b.N; n++ {
        m := make(map[int]bool)
        fill(m, SIZE)
    }
}

func BenchmarkAllocated(b *testing.B) {
    for n := 0; n < b.N; n++ {
        m := make(map[int]bool, 2*SIZE)
        fill(m, SIZE)
    }
}

结果

go test -benchmem -bench .
BenchmarkEmpty-8             500       2988680 ns/op      431848 B/op        625 allocs/op
BenchmarkAllocated-8        1000       1618251 ns/op      360949 B/op         11 allocs/op

Answer 3

一年前，我实际上很难过这样一个事实，即如果您的值不是静态的，那么使用显式分配空间的make<\/code>比使用 map 文字更好

这样做

return map[string]float {
    "key1": SOME_COMPUTED_ABOVE_VALUE,
    "key2": SOME_COMPUTED_ABOVE_VALUE,
    // more keys here
    "keyN": SOME_COMPUTED_ABOVE_VALUE,
}