go-vet
Analyze Go code for common mistakes
TLDR
Check the Go package in the current directory
Check the Go package in the specified path
List available checks that can be run with go vet
View details and flags for a particular check
Display offending lines plus n lines of surrounding context
Output analysis and errors in JSON format
SYNOPSIS
go vet [flags] [packages]
PARAMETERS
-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.
DESCRIPTION
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.
CAVEATS
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.
USAGE EXAMPLES
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
INTEGRATION WITH IDES
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.
HISTORY
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.