go-vet

Check the Go package in the current directory

$ go vet

$ go vet [path/to/file_or_directory]

$ go tool vet help

$ go tool vet help [check_name]

$ go vet -c=[n]

$ go vet -json

go vet [flags] [packages]

-all
    Report all findings by all analyzers.

-asmdecl
    Check assembly declarations.

-assign
    Check for useless assignments.

-atomic
    Check for common mistakes using the sync/atomic package.

-bools
    Check for boolean expression errors, such as "a == true".

-buildtags
    Check build tags.

-composite
    Check for unkeyed composite literals.

-copylocks
    Check for locks erroneously passed by value.

-httpresponse
    Check for mistakes using HTTP responses.

-ifaceassert
    Check for impossible interface type assertions.

-loopclosure
    Check for references to loop variables from within nested functions.

-lostcancel
    Check for failure to cancel calls to functions returning a cancelation context.

-methods
    Check for common method signature mistakes.

-nilfunc
    Check for invalid nil function calls.

-printf
    Check consistency of Printf format strings.

-shift
    Check for shifts that exceed the width of the integer type.

-structtag
    Check for problems in struct tags.

-unsafeptr
    Check for invalid uses of unsafe.Pointer.

-unusedresult
    Check for unused results of calls to certain functions.

-v
    Enable verbose output.

packages
    Specifies the packages to analyze. Can be a list of package names or import paths.

The `go vet` command examines Go source code and reports suspicious constructs, such as unused variables, format string errors, unreachable code, and data race conditions. It is a crucial tool for improving code quality and catching potential bugs early in the development process. `go vet` operates by analyzing the abstract syntax tree (AST) of the Go code and applying a series of checks defined by various analysis tools (known as analyzers). These analyzers can detect a wide variety of issues that compilers might miss. The command is designed to be integrated into automated build processes to provide continuous feedback on code quality and help maintainability. Using `go vet` helps to ensure program reliability and adheres to best practices. It's a powerful instrument for detecting potential errors and improving the overall quality and correctness of Go applications. The command is easily invoked and requires no extra tooling or external dependencies.

The checks performed by `go vet` are not exhaustive and may not catch all possible errors. It's recommended to combine `go vet` with other static analysis tools and thorough testing.

Basic Usage:
`go vet ./...`
This command analyzes all Go packages in the current directory and its subdirectories.

Specifying Packages:
`go vet mypackage otherpackage`
This command analyzes the `mypackage` and `otherpackage` packages.

Running a specific analyzer:
`go vet -printf ./...`
This command analyzes the printf format of the package.

Running all analyzers:
`go vet -all ./...`
This command will run every check available in the toolset

Many Go IDEs and editors provide built-in support for `go vet`, allowing developers to run the tool directly from their development environment. This provides immediate feedback on code quality and helps to catch potential errors early in the development cycle.

The `go vet` command has been part of the Go toolchain since its early days. It has evolved over time with the addition of new analyzers and improvements to existing checks. It is regularly updated with new Go releases to reflect language changes and best practices.

go(1), go-fmt(1), go-lint(1) (external tool)