Home > Backend Development > Golang > Is There a Performance Difference Between \'make\' and \'{}\' for Initializing Maps in Go?

Is There a Performance Difference Between \'make\' and \'{}\' for Initializing Maps in Go?

Barbara Streisand
Release: 2024-11-01 01:11:02
Original
809 people have browsed it

 Is There a Performance Difference Between

In Go, Unveiling the Performance Gap Between Maps Initialized Using "make" vs "{}"

In Go, developers have the flexibility to initialize maps in two ways: "make" and "{} syntax. This naturally raises the question of whether there are any performance differences between these approaches.

To compare the performance, a benchmark test can be created to measure the time taken to initialize a map using both methods. The provided benchmark test, as shown below, illustrates this:

<code class="go">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)
}</code>
Copy after login

Running this benchmark on multiple occasions yields results that suggest they are practically equivalent in terms of performance:

$ 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
Copy after login

This indicates that, on average, the performance difference between initializing maps using "make" vs "{} syntax is negligible and can be considered essentially equivalent.

The above is the detailed content of Is There a Performance Difference Between \'make\' and \'{}\' for Initializing Maps in Go?. For more information, please follow other related articles on the PHP Chinese website!

source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Latest Articles by Author
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template