What is the most efficient way to print an array in golang

In Golang, the most efficient way to print an array is to use the Println function in the fmt package. By passing an array as a parameter to the Println function, it automatically formats and prints the contents of the array. This method is very simple and efficient and works for any size array. In addition, Golang also provides some other methods for printing arrays, such as using the Join function in the strings package to connect array elements into strings and then printing them out, or using a loop to traverse the array and print each element. But relatively speaking, using the Println function directly is the simplest and most effective method. Whether during development or debugging, printing arrays is a very common operation. Mastering the most effective method can improve development efficiency.

Question content

I am new to programming and would like to know more about built-in functions:

This is the program:

func main() {
    start := time.now()

    fmt.println(os.args)

    fmt.println(time.since(start))
}

and its output:

[a b c d e f g h i j k l m n o p] 124.009µs

This is my for loop:

package main

import (
"fmt"
"os"
"time"
)

func main() {
start := time.Now()

    var s string
    for i:=0; i<len(os.Args); i++{
        s += os.Args[i] + " " 
    }
    fmt.Println(s)
    
    fmt.Println(time.Since(start))

}

The output is as follows:

/tmp/go-build994847456/b001/exe/main a b c d e f g h i j k l m n o p 25.71μs

I wish the built-in functions in the standard library would be faster.

Will slicing reduce the efficiency of my code?

Should I use a for loop or the standard library fmt.println?

I am also confusedstrings.join(os.args\[1:\], " ") How to perform 74.293μs

Solution

Use benchmark ：

var slice = []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p"}

func benchmarkfmt(b *testing.b) {
    b.reportallocs()
    for n := 0; n < b.n; n++ {
        _ = fmt.sprint(slice)
    }
}

func benchmarkstringconcat(b *testing.b) {
    b.reportallocs()
    for n := 0; n < b.n; n++ {
        var str string
        for _, s := range slice {
            str += s + " "
        }
    }
}

func benchmarkstringsbuilder(b *testing.b) {
    b.reportallocs()
    for n := 0; n < b.n; n++ {
        var l int
        for _, s := range slice {
            l += len(s)
        }
        var sb strings.builder
        sb.grow(l + len(slice)*len(" "))
        for _, s := range slice {
            sb.writestring(s)
            sb.writestring(" ")
        }
        _ = sb.string()
    }
}

func benchmarkstringsjoin(b *testing.b) {
    b.reportallocs()
    for n := 0; n < b.n; n++ {
        _ = strings.join(slice, " ")
    }
}

BenchmarkFMT
BenchmarkFMT-8                    734088          1633 ns/op         616 B/op         34 allocs/op
BenchmarkStringConcat
BenchmarkStringConcat-8          1290666           919.1 ns/op      1200 B/op         32 allocs/op
BenchmarkStringsBuilder
BenchmarkStringsBuilder-8        6074888           198.6 ns/op        64 B/op          1 allocs/op
BenchmarkStringsJoin
BenchmarkStringsJoin-8           4941542           241.7 ns/op        64 B/op          1 allocs/op
PASS

The above is the detailed content of What is the most efficient way to print an array in golang. For more information, please follow other related articles on the PHP Chinese website!