go vet中的那些检测项(1)

vet is a tool for static analysis of Go programs.
vet examines Go source code and reports suspicious constructs,
such as Printf calls whose arguments do not align with the format
string. It uses heuristics that do not guarantee all reports are
genuine problems, but it can find errors not caught by the compilers.
Registered analyzers:
    asmdecl      report mismatches between assembly files and Go declarations
    assign       check for useless assignments
    atomic       check for common mistakes using the sync/atomic package
    bools        check for common mistakes involving boolean operators
    buildtag     check //go:build and // +build directives
    cgocall      detect some violations of the cgo pointer passing rules
    composites   check for unkeyed composite literals
    copylocks    check for locks erroneously passed by value
    directive    check Go toolchain directives such as //go:debug
    errorsas     report passing non-pointer or non-error values to errors.As
    framepointer report assembly that clobbers the frame pointer before saving it
    httpresponse check for mistakes using HTTP responses
    ifaceassert  detect impossible interface-to-interface type assertions
    loopclosure  check references to loop variables from within nested functions
    lostcancel   check cancel func returned by context.WithCancel is called
    nilfunc      check for useless comparisons between functions and nil
    printf       check consistency of Printf format strings and arguments
    shift        check for shifts that equal or exceed the width of the integer
    sigchanyzer  check for unbuffered channel of os.Signal
    slog         check for invalid structured logging calls
    stdmethods   check signature of methods of well-known interfaces
    stringintconv check for string(int) conversions
    structtag    check that struct field tags conform to reflect.StructTag.Get
    testinggoroutine report calls to (*testing.T).Fatal from goroutines started by a test.
    tests        check for common mistaken usages of tests and examples
    timeformat   check for calls of (time.Time).Format or time.Parse with 2006-02-01
    unmarshal    report passing non-pointer or non-interface values to unmarshal
    unreachable  check for unreachable code
    unsafeptr    check for invalid conversions of uintptr to unsafe.Pointer
    unusedresult check for unused results of calls to some functions
By default all analyzers are run.
To select specific analyzers, use the -NAME flag for each one,
 or -NAME=false to run all analyzers not explicitly disabled.
Core flags:
  -V    print version and exit
  -all
        no effect (deprecated)
  -asmdecl
        enable asmdecl analysis
  -assign
        enable assign analysis
  -atomic
        enable atomic analysis
  -bool
        deprecated alias for -bools
  -bools
        enable bools analysis
  -buildtag
        enable buildtag analysis
  -buildtags
        deprecated alias for -buildtag
  -c int
        display offending line with this many lines of context (default -1)
  -cgocall
        enable cgocall analysis
  -composites
        enable composites analysis
  -compositewhitelist
        deprecated alias for -composites.whitelist (default true)
  -copylocks
        enable copylocks analysis
  -directive
        enable directive analysis
  -errorsas
        enable errorsas analysis
  -flags
        print analyzer flags in JSON
  -framepointer
        enable framepointer analysis
  -httpresponse
        enable httpresponse analysis
  -ifaceassert
        enable ifaceassert analysis
  -json
        emit JSON output
  -loopclosure
        enable loopclosure analysis
  -lostcancel
        enable lostcancel analysis
  -methods
        deprecated alias for -stdmethods
  -nilfunc
        enable nilfunc analysis
  -printf
        enable printf analysis
  -printfuncs value
        deprecated alias for -printf.funcs (default (*log.Logger).Fatal,(*log.Logger).Fatalf,(*log.Logger).Fatalln,(*log.Logger).Panic,(*log.Logger).Panicf,(*log.Logger).Panicln,(*log.Logger).Print,(*log.Logger).Printf,(*log.Logger).Println,(*testing.common).Error,(*testing.common).Errorf,(*testing.common).Fatal,(*testing.common).Fatalf,(*testing.common).Log,(*testing.common).Logf,(*testing.common).Skip,(*testing.common).Skipf,(testing.TB).Error,(testing.TB).Errorf,(testing.TB).Fatal,(testing.TB).Fatalf,(testing.TB).Log,(testing.TB).Logf,(testing.TB).Skip,(testing.TB).Skipf,fmt.Append,fmt.Appendf,fmt.Appendln,fmt.Errorf,fmt.Fprint,fmt.Fprintf,fmt.Fprintln,fmt.Print,fmt.Printf,fmt.Println,fmt.Sprint,fmt.Sprintf,fmt.Sprintln,log.Fatal,log.Fatalf,log.Fatalln,log.Panic,log.Panicf,log.Panicln,log.Print,log.Printf,log.Println,runtime/trace.Logf)
  -rangeloops
        deprecated alias for -loopclosure
  -shift
        enable shift analysis
  -sigchanyzer
        enable sigchanyzer analysis
  -slog
        enable slog analysis
  -source
        no effect (deprecated)
  -stdmethods
        enable stdmethods analysis
  -stringintconv
        enable stringintconv analysis
  -structtag
        enable structtag analysis
  -tags string
        no effect (deprecated)
  -testinggoroutine
        enable testinggoroutine analysis
  -tests
        enable tests analysis
  -timeformat
        enable timeformat analysis
  -unmarshal
        enable unmarshal analysis
  -unreachable
        enable unreachable analysis
  -unsafeptr
        enable unsafeptr analysis
  -unusedfuncs value
        deprecated alias for -unusedresult.funcs (default context.WithCancel,context.WithDeadline,context.WithTimeout,context.WithValue,errors.New,fmt.Errorf,fmt.Sprint,fmt.Sprintf,sort.Reverse)
  -unusedresult
        enable unusedresult analysis
  -unusedstringmethods value
        deprecated alias for -unusedresult.stringmethods (default Error,String)
  -v    no effect (deprecated)
To see details and flags of a specific analyzer, run 'vet help name'.

vet 是一个用于对 Go 程序进行静态分析的工具。
vet 检查 Go 源代码并报告可疑的结构，例如 Printf 调用的参数与格式字符串不对齐。它使用的启发式方法不能保证所有报告都是真正的问题，但它可以发现编译器没有捕获的错误。
已注册的分析器：
- asmdecl：报告汇编文件和 Go 声明之间的不匹配
- assign：检查无用的赋值
- atomic：检查使用 sync/atomic 包的常见错误
- bools：检查涉及布尔运算符的常见错误
- buildtag：检查 //go:build 和 // +build 指令
- cgocall：检测一些违反 cgo 指针传递规则的情况
- composites：检查未键控的复合文字
- copylocks：检查错误地通过值传递的锁
- directive：检查 Go 工具链指令，如 //go:debug
- errorsas：报告将非指针或非错误值传递给 errors.As 的情况
- framepointer：报告在保存帧指针之前破坏帧指针的汇编
- httpresponse：检查使用 HTTP 响应时的错误
- ifaceassert：检测不可能的接口到接口类型断言
- loopclosure：检查在嵌套函数内部引用循环变量的情况
- lostcancel：检查是否调用了由 context.WithCancel 返回的 cancel 函数
- nilfunc：检查函数与 nil 的无用比较
- printf：检查 Printf 格式字符串和参数的一致性
- shift：检查移位是否等于或超过整数的宽度
- sigchanyzer：检查未缓冲的 os.Signal 通道
- slog：检查无效的结构化日志调用
- stdmethods：检查众所周知接口的方法签名
- stringintconv：检查 string(int) 转换
- structtag：检查结构体字段标记是否符合 reflect.StructTag.Get
- testinggoroutine：报告从测试启动的 goroutine 中调用 (*testing.T).Fatal。
- tests：检查测试和示例的常见错误用法
- timeformat：检查调用 (time.Time).Format 或 time.Parse 是否使用 2006-02-01
- unmarshal：报告将非指针或非接口值传递给 unmarshal 的情况
- unreachable：检查无法到达的代码
- unsafeptr：检查将 uintptr 转换为 unsafe.Pointer 的无效转换
- unusedresult：检查某些函数调用的未使用结果
默认情况下，所有分析器都会运行。要选择特定的分析器，请为每个分析器使用 -NAME 标志，或者使用 -NAME=false 运行未明确禁用的所有分析器。
核心标志：
- -V：打印版本并退出
- -all：无效（已弃用）
- -asmdecl：启用 asmdecl 分析
- -assign：启用 assign 分析
- -atomic：启用 atomic 分析
- -bool：-bools 的已弃用别名
- -bools：启用 bools 分析
- -buildtag：启用 buildtag 分析
- -buildtags：-buildtag 的已弃用别名
- -c int：以这么多行的上下文显示有问题的代码行（默认值为 -1）
- -cgocall：启用 cgocall 分析
- -composites：启用 composites 分析
- -compositewhitelist：-composites.whitelist 的已弃用别名（默认值为 true）
- -copylocks：启用 copylocks 分析
- -directive：启用 directive 分析
- -errorsas：启用 errorsas 分析
- -flags：以 JSON 格式输出分析器标志
- -framepointer：启用 framepointer 分析
- -httpresponse：启用 httpresponse 分析
- -ifaceassert：启用 ifaceassert 分析
- -json：发出 JSON 输出
- -loopclosure：启用 loopclosure 分析
- -lostcancel：启用 lostcancel 分析
- -methods：-stdmethods 的已弃用别名
- -nilfunc：启用 nilfunc 分析
- -printf：启用 printf 分析
- -printfuncs value：-printf.funcs 的已弃用别名（默认值为 (*log.Logger).Fatal,(*log.Logger).Fatalf,(*log.Logger).Fatalln,(*log.Logger).Panic,(*log.Logger).Panicf,(*log.Logger).Panicln,(*log.Logger).Print,(*log.Logger).Printf,(*log.Logger).Println,(*testing.common).Error,(*testing.common).Errorf,(*testing.common).Fatal,(*testing.common).Fatalf,(*testing.common).Log,(*testing.common).Logf,(*testing.common).Skip,(*testing.common).Skipf,(testing.TB).Error,(testing.TB).Errorf,(testing.TB).Fatal,(testing.TB).Fatalf,(testing.TB).Log,(testing.TB).Logf,(testing.TB).Skip,(testing.TB).Skipf,fmt.Append,fmt.Appendf,fmt.Appendln,fmt.Errorf,fmt.Fprint,fmt.Fprintf,fmt.Fprintln,fmt.Print,fmt.Printf,fmt.Println,fmt.Sprint,fmt.Sprintf,fmt.Sprintln,log.Fatal,log.Fatalf,log.Fatalln,log.Panic,log.Panicf,log.Panicln,log.Print,log.Printf,log.Println,runtime/trace.Logf）
- -rangeloops：-loopclosure 的已弃用别名
- -shift：启用 shift 分析
- -sigchanyzer：启用 sigchanyzer 分析
- -slog：启用 slog 分析
- -source：无效（已弃用）
- -stdmethods：启用 stdmethods 分析
- -stringintconv：启用 stringintconv 分析
- -structtag：启用 structtag 分析
- -tags string：无效（已弃用）
- -testinggoroutine：启用 testinggoroutine 分析
- -tests：启用 tests 分析
- -timeformat：启用 timeformat 分析
- -unmarshal：启用 unmarshal 分析
- -unreachable：启用 unreachable 分析
- -unsafeptr：启用 unsafeptr 分析
- -unusedfuncs value：-unusedresult.funcs 的已弃用别名（默认值为 context.WithCancel,context.WithDeadline,context.WithTimeout,context.WithValue,errors.New,fmt.Errorf,fmt.Sprint,fmt.Sprintf,sort.Reverse）
- -unusedresult：启用 unusedresult 分析
- -unusedstringmethods value：-unusedresult.stringmethods 的已弃用别名（默认值为 Error,String）
- -v：无效（已弃用）
要查看特定分析器的详细信息和标志，请运行 'vet help name'。

package main
func main() {
    x := 1
    x = x  // 将变量赋值给自身
    y, z := 1, 2
    y, z, _ = 1, 2  // 左边的变量数量和右边的值数量不一致
    var a int
    a = "hello"  // 将一个字符串赋给一个整型变量
    b := true
    b = 1  // 在 if、for、switch 等语句中，将一个值赋给一个布尔型变量而不是比较表达式
    c = 1  // 使用了未定义的变量
}

# command-line-arguments
./main.go:5:5: self-assignment of x
./main.go:7:9: assignment mismatch: 2 variables but 3 values
./main.go:9:5: cannot use "hello" (type string) as type int in assignment
./main.go:11:5: b is bool, suggest `b == 1` instead
./main.go:13:5: undefined: c

package main
import (
  "sync/atomic"
)
func main() {
  var x int64
  x = atomic.AddInt64(&x, 1) //  direct assignment to atomic value
}

# command-line-arguments
./main.go:9:2: direct assignment to atomic value

// +build linux darwin
package myutil
import "fmt"
func PrintHello() {
    fmt.Println("Hello, World!")
}

# myutil
.\myutil.go:1:2: invalid +build comment: unknown compile target "linux"

// +build windows
package main
import "myutil"
func main() {
    myutil.PrintHello()
}

type Person struct {
    Name string
    Age  int
}

p1 := Person{Name: "Alice", Age: 30}
p2 := Person{"Bob", 25}

package main
import (
  "sync"
)
type myStruct struct {
  sync.Mutex
  value int
}
func main() {
  var original myStruct
  var copy = original // 这里复制了一个含有锁的值
  copy.Lock()
  copy.value = 5
  copy.Unlock()
}

$ go vet main.go
# command-line-arguments
./main.go:13:13: assignment copies lock value to copy: main.myStruct contains sync.Mutex

package main
func main() {
    // 死循环
    for {
    }
    // 空循环
    for ; ; {
    }
    // 无条件跳转
    goto label
label:
}

package main
import (
  "errors"
  "fmt"
  "reflect"
)
func main() {
  err1 := errors.New("error 1")
  err2 := errors.New("error 2")
  // 使用 reflect.DeepEqual 比较两个错误。
  if reflect.DeepEqual(err1, err2) {
    fmt.Println("The errors are equal.")
  } else {
    fmt.Println("The errors are not equal.")
  }
}

//  start := time.Now()
//  ...
//  defer recordLatency(time.Since(start)) // error: call to time.Since is not deferred
//
// The correct code is:
//
//  defer func() { recordLatency(time.Since(start)) }()

package main
import (
  "fmt"
  "time"
)
func main() {
  start := time.Now()
  fmt.Println("当前时间:", start)
  defer recordLatency(time.Since(start))
  time.Sleep(3 * time.Second)
}
func recordLatency(duration time.Duration) {
  fmt.Println("共耗时:", duration)
}

package main
import (
  "fmt"
  "time"
)
func main() {
  start := time.Now()
  fmt.Println("当前时间:", start)
  defer func() {
    recordLatency(time.Since(start))
  }()
  time.Sleep(3 * time.Second)
}
func recordLatency(duration time.Duration) {
  fmt.Println("共耗时:", duration)
}

当前时间: 2023-07-25 16:44:26.90604 +0800 CST m=+0.000169751
共耗时: 3.001356959s

package main
import (
  "errors"
  "fmt"
)
func main() {
  err := &MyError{}
  var target error
  fmt.Println(errors.As(err, &target))
}
type MyError struct{}
func (err *MyError) Error() string {
  return "oops!"
}