So passen Sie Linter (statisches Prüftool) in der Go-Sprache an

Vorwort

Normalerweise verwenden wir statische Code-Überprüfungstools, um die Codequalität in Geschäftsprojekten sicherzustellen. Durch statische Code-Überprüfungstools können wir einige Probleme im Voraus finden, wie z. B. undefinierte Variablen, Typkonflikte und Probleme mit dem Variablenbereich , Array-Index außerhalb der Grenzen, Speicherlecks usw., das Tool klassifiziert den Schweregrad des Problems gemäß seinen eigenen Regeln und gibt verschiedene Identifizierungs- und Eingabeaufforderungen. Die statische Codeinspektion hilft uns, Probleme so früh wie möglich zu finden, Die am häufigsten verwendeten statischen Code-Inspektionstools in der Go-Sprache sind golint, einige Regeln wurden in diesen Tools formuliert, obwohl sie dies können erfüllen bereits die meisten Szenarien. Manchmal müssen wir jedoch benutzerdefinierte Regeln für spezielle Szenarien erstellen. In diesem Artikel erfahren Sie, wie Sie die Linter-Anforderungen anpassen. Go语言中常用的静态代码检查工具有golang-lint、golint，这些工具中已经制定好了一些规则，虽然已经可以满足大多数场景，但是有些时候我们会遇到针对特殊场景来做一些定制化规则的需求，所以本文我们一起来学习一下如何自定义linter需求；

Go语言中的静态检查是如何实现？

众所周知Go

🎜🎜Wie implementiert man statische Überprüfungen in der Go-Sprache? 🎜🎜Wir alle wissen

Der Compiler übersetzt Hochsprache in Maschinensprache. Er führt zunächst eine lexikalische Analyse des Quellcodes durch. Dabei werden Zeichenfolgen in Token umgewandelt : Schlüsselwörter, Bezeichner, Literale (einschließlich Zahlen, Zeichenfolgen), Sonderzeichen (z. B. Pluszeichen, Gleichheitszeichen), generieren TokenNach der Sequenz muss eine Syntaxanalyse durchgeführt werden. Nach der weiteren Verarbeitung wird ein Syntaxbaum mit Ausdrücken als Knoten generiert. Dieser Syntaxbaum ist das, was wir oft verwenden say ; dann ist der abstrakte Syntaxbaum lang? Wie sieht er aus? Wir können den von go/token Paket zum AusdruckenAST</ Code>, spezifisch< Codestil=" schriftgr rechts: links: rgba mono consolas monaco menlo monospace break-all rgb>Wir können das Beispiel unten für what AST sehen sieht aus wie ;

Linter-Regeln entwickeln

Angenommen, wir möchten nun in unserem Team eine solche Codespezifikation formulieren. Der erste Parametertyp aller Funktionen muss Context, wir geben eine Warnung aus, wenn es nicht der Spezifikation entspricht; OK, jetzt sind die Regeln festgelegt, jetzt haben wir sie Um einen Weg zu finden, es umzusetzen; zunächst ein problematisches Beispiel: Context，不符合该规范的我们要给出警告；好了，现在规则已经定好了，现在我们就来想办法实现它；先来一个有问题的示例：

// example.go
package main

func add(a, b int) int {
 return a + b
}

对应AST如下：

*ast.FuncDecl {
     8  .  .  .  Name: *ast.Ident {
     9  .  .  .  .  NamePos: 3:6
    10  .  .  .  .  Name: "add" 
    11  .  .  .  .  Obj: *ast.Object {
    12  .  .  .  .  .  Kind: func
    13  .  .  .  .  .  Name: "add" // 函数名
    14  .  .  .  .  .  Decl: *(obj @ 7)
    15  .  .  .  .  }
    16  .  .  .  }
    17  .  .  .  Type: *ast.FuncType {
    18  .  .  .  .  Func: 3:1
    19  .  .  .  .  Params: *ast.FieldList {
    20  .  .  .  .  .  Opening: 3:9
    21  .  .  .  .  .  List: []*ast.Field (len = 1) {
    22  .  .  .  .  .  .  0: *ast.Field {
    23  .  .  .  .  .  .  .  Names: []*ast.Ident (len = 2) {
    24  .  .  .  .  .  .  .  .  0: *ast.Ident {
    25  .  .  .  .  .  .  .  .  .  NamePos: 3:10
    26  .  .  .  .  .  .  .  .  .  Name: "a"
    27  .  .  .  .  .  .  .  .  .  Obj: *ast.Object {
    28  .  .  .  .  .  .  .  .  .  .  Kind: var
    29  .  .  .  .  .  .  .  .  .  .  Name: "a"
    30  .  .  .  .  .  .  .  .  .  .  Decl: *(obj @ 22)
    31  .  .  .  .  .  .  .  .  .  }
    32  .  .  .  .  .  .  .  .  }
    33  .  .  .  .  .  .  .  .  1: *ast.Ident {
    34  .  .  .  .  .  .  .  .  .  NamePos: 3:13
    35  .  .  .  .  .  .  .  .  .  Name: "b"
    36  .  .  .  .  .  .  .  .  .  Obj: *ast.Object {
    37  .  .  .  .  .  .  .  .  .  .  Kind: var
    38  .  .  .  .  .  .  .  .  .  .  Name: "b"
    39  .  .  .  .  .  .  .  .  .  .  Decl: *(obj @ 22)
    40  .  .  .  .  .  .  .  .  .  }
    41  .  .  .  .  .  .  .  .  }
    42  .  .  .  .  .  .  .  }
    43  .  .  .  .  .  .  .  Type: *ast.Ident {
    44  .  .  .  .  .  .  .  .  NamePos: 3:15
    45  .  .  .  .  .  .  .  .  Name: "int" // 参数名
    46  .  .  .  .  .  .  .  }
    47  .  .  .  .  .  .  }
    48  .  .  .  .  .  }
    49  .  .  .  .  .  Closing: 3:18
    50  .  .  .  .  }
    51  .  .  .  .  Results: *ast.FieldList {
    52  .  .  .  .  .  Opening: -
    53  .  .  .  .  .  List: []*ast.Field (len = 1) {
    54  .  .  .  .  .  .  0: *ast.Field {
    55  .  .  .  .  .  .  .  Type: *ast.Ident {
    56  .  .  .  .  .  .  .  .  NamePos: 3:20
    57  .  .  .  .  .  .  .  .  Name: "int"
    58  .  .  .  .  .  .  .  }
    59  .  .  .  .  .  .  }
    60  .  .  .  .  .  }
    61  .  .  .  .  .  Closing: -
    62  .  .  .  .  }
    63  .  .  .  }

方式一：标准库实现custom linter

通过上面的AST结构我们可以找到函数参数类型具体在哪个结构上，因为我们可以根据这个结构写出解析代码如下：

package main

import (
 "fmt"
 "go/ast"
 "go/parser"
 "go/token"
 "log"
 "os"
)

func main() {
 v := visitor{fset: token.NewFileSet()}
 for _, filePath := range os.Args[1:] {
  if filePath == "--" { // to be able to run this like "go run main.go -- input.go"
   continue
  }

  f, err := parser.ParseFile(v.fset, filePath, nil, 0)
  if err != nil {
   log.Fatalf("Failed to parse file %s: %s", filePath, err)
  }
  ast.Walk(&v, f)
 }
}

type visitor struct {
 fset *token.FileSet
}

func (v *visitor) Visit(node ast.Node) ast.Visitor {
 funcDecl, ok := node.(*ast.FuncDecl)
 if !ok {
  return v
 }

 params := funcDecl.Type.Params.List // get params
 // list is equal of zero that don't need to checker.
 if len(params) == 0 {
  return v
 }

 firstParamType, ok := params[0].Type.(*ast.SelectorExpr)
 if ok && firstParamType.Sel.Name == "Context" {
  return v
 }

 fmt.Printf("%s: %s function first params should be Context\n",
  v.fset.Position(node.Pos()), funcDecl.Name.Name)
 return v
}

然后执行命令如下：

$ go run ./main.go -- ./example.go
./example.go:3:1: add function first params should be Context

通过输出我们可以看到，函数add()第一个参数必须是Context；这就是一个简单实现，因为AST

.
├── firstparamcontext
│   └── firstparamcontext.go
├── go.mod
├── go.sum
└── testfirstparamcontext
    ├── example.go
    └── main.go

entspricht AST lautet wie folgt: 🎜

package firstparamcontext

import (
 "go/ast"

 "golang.org/x/tools/go/analysis"
)

var Analyzer = &analysis.Analyzer{
 Name: "firstparamcontext",
 Doc:  "Checks that functions first param type is Context",
 Run:  run,
}

func run(pass *analysis.Pass) (interface{}, error) {
 inspect := func(node ast.Node) bool {
  funcDecl, ok := node.(*ast.FuncDecl)
  if !ok {
   return true
  }

  params := funcDecl.Type.Params.List // get params
  // list is equal of zero that don't need to checker.
  if len(params) == 0 {
   return true
  }

  firstParamType, ok := params[0].Type.(*ast.SelectorExpr)
  if ok && firstParamType.Sel.Name == "Context" {
   return true
  }

  pass.Reportf(node.Pos(), "''%s' function first params should be Context\n",
   funcDecl.Name.Name)
  return true
 }

 for _, f := range pass.Files {
  ast.Inspect(f, inspect)
 }
 return nil, nil
}

🎜🎜🎜Methode 1: Standardbibliothek implementiert benutzerdefinierten Linter🎜🎜 durch den oben genannten AST Struktur Wir können herausfinden, auf welcher Struktur sich der Funktionsparametertyp befindet, da wir den Parsing-Code basierend auf dieser Struktur wie folgt schreiben können : 🎜

package main

import (
 "asong.cloud/Golang_Dream/code_demo/custom_linter/firstparamcontext"
 "golang.org/x/tools/go/analysis/singlechecker"
)

func main() {
 singlechecker.Main(firstparamcontext.Analyzer)
}

🎜 Dann führen Sie den Befehl wie folgt aus: 🎜

$ go run ./main.go -- ./example.go 
/Users/go/src/asong.cloud/Golang_Dream/code_demo/custom_linter/testfirstparamcontext/example.go:3:1: ''add' function first params should be Context

🎜Wir können durch die Ausgabe sehen, dass die Funktion Der erste Parameter von add() muss Context sein; dies ist ein einfache Implementierung, weil 方式二：go/analysis

看过上面代码的朋友肯定有点抓狂了，有很多实体存在，要开发一个linter，我们需要搞懂好多实体，好在go/analysis进行了封装，go/analysis为linter 提供了统一的接口，它简化了与IDE,metalinters，代码Review等工具的集成。如，任何go/analysislinter都可以高效的被go vet执行，下面我们通过代码方式来介绍go/analysis的优势；

新建一个项目代码结构如下：

.
├── firstparamcontext
│   └── firstparamcontext.go
├── go.mod
├── go.sum
└── testfirstparamcontext
    ├── example.go
    └── main.go

添加检查模块代码，在firstparamcontext.go添加如下代码：

package firstparamcontext

import (
 "go/ast"

 "golang.org/x/tools/go/analysis"
)

var Analyzer = &analysis.Analyzer{
 Name: "firstparamcontext",
 Doc:  "Checks that functions first param type is Context",
 Run:  run,
}

func run(pass *analysis.Pass) (interface{}, error) {
 inspect := func(node ast.Node) bool {
  funcDecl, ok := node.(*ast.FuncDecl)
  if !ok {
   return true
  }

  params := funcDecl.Type.Params.List // get params
  // list is equal of zero that don't need to checker.
  if len(params) == 0 {
   return true
  }

  firstParamType, ok := params[0].Type.(*ast.SelectorExpr)
  if ok && firstParamType.Sel.Name == "Context" {
   return true
  }

  pass.Reportf(node.Pos(), "''%s' function first params should be Context\n",
   funcDecl.Name.Name)
  return true
 }

 for _, f := range pass.Files {
  ast.Inspect(f, inspect)
 }
 return nil, nil
}

然后添加分析器：

package main

import (
 "asong.cloud/Golang_Dream/code_demo/custom_linter/firstparamcontext"
 "golang.org/x/tools/go/analysis/singlechecker"
)

func main() {
 singlechecker.Main(firstparamcontext.Analyzer)
}

命令行执行如下：

$ go run ./main.go -- ./example.go 
/Users/go/src/asong.cloud/Golang_Dream/code_demo/custom_linter/testfirstparamcontext/example.go:3:1: ''add' function first params should be Context

如果我们想添加更多的规则，使用golang.org/x/tools/go/analysis/multichecker追加即可。

集成到golang-cli

我们可以把golang-cli的代码下载到本地，然后在pkg/golinters 下添加firstparamcontext.go，代码如下：

import (
 "golang.org/x/tools/go/analysis"

 "github.com/golangci/golangci-lint/pkg/golinters/goanalysis"

 "github.com/fisrtparamcontext"
)


func NewfirstparamcontextCheck() *goanalysis.Linter {
 return goanalysis.NewLinter(
  "firstparamcontext",
  "Checks that functions first param type is Context",
  []*analysis.Analyzer{firstparamcontext.Analyzer},
  nil,
 ).WithLoadMode(goanalysis.LoadModeSyntax)
}

然后重新make一个golang-cli可执行文件，加到我们的项目中就可以了；

总结

golang-cli仓库中pkg/golinters目录下存放了很多静态检查代码，学会一个知识点的最快办法就是抄代码，先学会怎么使用的，慢慢再把它变成我们自己的；本文没有对AST标准库做过多的介绍，因为这部分文字描述比较难以理解，最好的办法还是自己去看官方文档、加上实践才能更快的理解。

本文所有代码已经上传：https://github.com/asong2020/Golang_Dream/tree/master/code_demo/custom_linter

Das obige ist der detaillierte Inhalt vonSo passen Sie Linter (statisches Prüftool) in der Go-Sprache an. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!