Why doesn't the compiler warn about bad formatters?

Why doesn't the compiler warn about bad formatters? In programming, a formatter is a tool used to beautify code. It can automatically adjust the indentation, spaces, line breaks, etc. of the code to make the code more readable. However, sometimes we may make some formatter errors, such as missing brackets, extra semicolons, etc. Although these errors may lead to logical errors in the code, the compiler often does not warn about these errors. So why doesn't the compiler warn about these bad formatters? First of all, the main task of the compiler is to convert the source code into executable machine code. It will check for syntax errors to ensure the correctness of the code. However, formatter errors tend to be semantic rather than syntactic errors. In other words, these errors do not affect the executability of the code, they just make the code less readable. Therefore, the compiler has no obligation to warn about these errors. Second, formatter errors are often subjective, and different developers have different coding styles and preferences. For example, some people like to use braces in their code, while others don't. The compiler cannot determine which style is correct and therefore cannot warn about formatter errors. Finally, warn that formatter errors may generate a large number of false positives. In large projects, the size of the code is often very large, and a small formatter error can cause thousands of warnings. This will not only cause trouble to developers, but also increase the difficulty of code maintenance. To avoid this

Question content

I would expect the following code to at least issue a warning during compilation because the formatter is inconsistent with the type of the variable:

package main

import "fmt"

func main() {
    s := "hello"
    fmt.printf("1 %w", s)
    fmt.printf("2 %s", s)
}

The type of the variable is known at compile time and the string formatter parses it in a deterministic way - is there a reason why the error is not raised at this point?

What I get is the output code

1 %!w(string=hello)2 hello

This seems to be some kind of message telling %w that the type is wrong for string (but only at runtime)

Workaround

fmt.printf Format string parameters are interpreted at runtime, not compile time.

func printf(format string, a ...any) (n int, err error)

printf formats according to the format specifier and writes to standard output. It returns the number of bytes written and any write errors encountered.

Use static analysis linter, such as go vet.

go command - cmd/go - go package

Report possible errors in the package

usage:

go vet [-n] [-x] [-vettool prog] [build flags] [vet flags] [packages]

vet Run the go vet command on the package named by the import path.

For more information about vet and its flags, see "go doc cmd /vet".

so.go：

package main

import "fmt"

func main() {
    s := "hello"
    fmt.printf("1 %w\n", s)
    fmt.printf("2 %s\n", s)
}

Linter Check:

$ go vet so.go
./so.go:7:2: fmt.printf format %w has arg s of wrong type string, 
             see also https://pkg.go.dev/fmt#hdr-printing
$

Runtime:

$ go run so.go
1 %!w(string=hello)
2 hello
$

The above is the detailed content of Why doesn't the compiler warn about bad formatters?. For more information, please follow other related articles on the PHP Chinese website!