cmd: use errrors.New instead of empty fmt.Errorf

[jsvisa]

Seems errors.New is super fast then the empty fmt.Errorf, here is an benchmark test case from https://blog.imberkay.com/errorsnew-vs-fmterrorf

package main

import (
    "errors"
    "fmt"
    "time"
)

func testErrors() error {
    return errors.New("test errors package")
}

func testFmt() error {
    return fmt.Errorf("test fmt package")
}

func main() {
    repeat := 100000000
    start := time.Now()
    for i := 0; i < repeat; i++ {
        testErrors()
    }
    duration := time.Since(start)
    fmt.Println("errors.New", duration)

    start = time.Now()
    for i := 0; i < repeat; i++ {
        testFmt()
    }
    duration = time.Since(start)
    fmt.Println("fmt.Errorf", duration)
}

In my macbook air m1, the result as below:

$ go version
go version go1.20.3 darwin/arm64

$ go run t.go

errors.New 63.858083ms
fmt.Errorf 5.240530083s

[holiman]

I played around a bit with your example code.

It's not really that errors.New is awesome, or that fmt.Errorf is slow, the reason is that string formatting takes time (even if there's nothing to format), and also that the errors.New is optimized away.

package main

import (
	"errors"
	"fmt"
	"time"
)

func testErrors(txt string) error {
	return errors.New(txt)
}

func testFmt(txt string) error {
	return fmt.Errorf(txt)
}

func main() {
	repeat := 100000000
	start := time.Now()
	var a, b error
	var c string
	for i := 0; i < repeat; i++ {
		a = testErrors("test")
	}
	duration := time.Since(start)
	fmt.Println("errors.New", duration)

	start = time.Now()
	for i := 0; i < repeat; i++ {
		b = fmt.Errorf("test")
	}
	duration = time.Since(start)
	fmt.Println("fmt.Errorf", duration)
	//
	start = time.Now()
	for i := 0; i < repeat; i++ {
		c = fmt.Sprintf("test")
	}
	duration = time.Since(start)
	fmt.Println("fmt.Sprintf", duration)
	fmt.Printf(c)
	fmt.Printf(a.Error())
	fmt.Printf(b.Error())
}

Output:

errors.New 4.762584711s
fmt.Errorf 11.254008468s
fmt.Sprintf 6.893002654s

So ~5s is added to errors.New if we prevent the compiler from removing the entire call, by catching the returnvalue.
And the string-formatting accounts for ~7s. So the ratio between errors.New and fmt.Errorf, for strings without args, are closer to 5:12 than 0.063:5

[holiman]

LGTM, it's the right thing to do, even if the article is a bit flawed and the results are is a bit misleading

[jsvisa]

So ~5s is added to errors.New if we prevent the compiler from removing the entire call, by catching the returnvalue.

Thanks for this tip. It seems that the return value of errors.New is not being used, so the compiler has optimized this line of code.

[s1na]

LGTM