Dengan pembangunan berterusan bahasa pengaturcaraan Go, semakin ramai pengaturcara memilih Go sebagai bahasa pengaturcaraan utama mereka. Bermula dari Go versi 1.17, pakej go/doc baharu telah ditambahkan pada pustaka standard bahasa Go, yang memudahkan dan memudahkan Golang mendapatkan ulasan.
Dalam artikel ini, kami akan meneroka cara mendapatkan ulasan dalam kod sumber Golang menggunakan pakej go/doc. Kami akan menerangkannya dari aspek berikut:
go/doc Penggunaan asas pakej 1. Penggunaan asas pakej go/doc
go/doc ialah perpustakaan standard serba lengkap Go bahasa Didatangkan dalam pakej dan boleh digunakan tanpa pemasangan. Pakej ini menyediakan cara yang sangat mudah untuk menghuraikan maklumat anotasi daripada kod sumber Golang.
Pertama, kita perlu mengimport pakej go/doc dan menggunakan fungsi go/doc.New(pak *ast.Package, importPath string, mode Mode) untuk mencipta objek jenis go/doc.Package. Parameter pertama fungsi ini ialah penunjuk jenis *ast.Package, yang mewakili pakej Go yang kami ingin dapatkan anotasi daripadanya; parameter kedua ialah jenis rentetan, yang mewakili laluan untuk mengimport pakej itu; go/doc.Mode taip, digunakan untuk menentukan maklumat yang ingin kami tanyakan.
package main
import (
"go/ast"
"go/doc"
"go/parser"
"go/token"
)
func main() {
// 从本地源码文件解析 Go 代码
fset := token.NewFileSet()
astFile, _ := parser.ParseFile(fset, "example.go", nil, parser.ParseComments)
packageName := "example"
pkg := &ast.Package{
Name: packageName,
Files: map[string]*ast.File {
"example.go": astFile,
},
}
// 创建一个 go/doc.Package 对象
targetPkg := doc.New(pkg, packageName, 0)
}Kod di atas mencipta objek targetPkg bernama go/doc.Package, yang mengandungi semua maklumat pakej example. Di bawah kami akan menerangkan langkah demi langkah cara menggunakan objek ini untuk mendapatkan maklumat anotasi.
2. Bagaimana untuk mendapatkan ulasan tentang kaedah dan fungsi
Di Golang, kaedah dan fungsi adalah elemen kod biasa. Di bawah kami akan menerangkan cara mendapatkan anotasi mereka.
Dalam jenis go/doc.Package, terdapat medan bernama Funcs, yang mengandungi semua fungsi dan kaedah maklumat anotasi. Medan ini ialah peta dengan nama fungsi sebagai kunci dan nilai jenis go/doc.Func sebagai nilai.
func Example() {
targetPkg := ...
// 获取函数的注释
f := targetPkg.Funcs["foo"]
fmt.Println(f.Doc) // 输出函数 foo 的注释
}Dalam kod di atas, kami menggunakan targetPkg.Funcs["foo"] untuk mendapatkan maklumat anotasi fungsi foo dan mencetaknya ke konsol.
Di Golang, kaedah merujuk kepada fungsi yang dikaitkan dengan struktur. Jika kita ingin mendapatkan anotasi kaedah, kita boleh menggunakan medan go/doc dalam jenis Package.Types. Setiap objek *go/doc.Type mengandungi semua maklumat anotasi yang berkaitan dengannya, termasuk kaedah.
Kita boleh menggunakan kaedah Name() untuk mendapatkan nama jenis, dan kemudian lelaran melalui senarai kaedahnya untuk mendapatkan maklumat anotasi setiap kaedah.
func Example() {
targetPkg := ...
// 获取结构体的注释和方法的注释
for _, t := range targetPkg.Types {
fmt.Println(t.Doc) // 输出结构体的注释
for _, m := range t.Methods {
fmt.Println(m.Doc) // 输出方法的注释
}
}
}Dalam kod di atas, kami menggunakan targetPkg.Types untuk mendapatkan anotasi semua struktur dan kaedah. Melintasi targetPkg.Types, untuk setiap jenis, kita boleh menggunakan t.Doc untuk mendapatkan maklumat anotasinya dan melintasi t.Methods untuk mendapatkan maklumat anotasi setiap kaedah.
3. Cara mendapatkan ulasan tentang struktur dan antara muka
Di Golang, struktur dan antara muka juga merupakan elemen kod biasa. Sama seperti fungsi dan kaedah, kita juga boleh mendapatkan maklumat anotasinya.
Dalam jenis go/doc.Package, terdapat medan bernama Types, yang mengandungi semua struktur dan antara muka maklumat. Medan ini ialah peta dengan nama jenis sebagai kunci dan nilai jenis go/doc.Type sebagai nilai.
Kita boleh menggunakan medan go/doc.Type dalam jenis untuk mendapatkan maklumat anotasi struktur. Doc
func Example() {
targetPkg := ...
// 获取结构体的注释
typ := targetPkg.Types["MyStruct"]
fmt.Println(typ.Doc)
} melalui targetPkg.Types["MyStruct"] dan mencetaknya ke konsol. MyStruct
Jenisgo/doc.Doc` untuk mendapatkan maklumat ulasan antara muka. 类型中的
func Example() {
targetPkg := ...
// 获取接口的注释
typ := targetPkg.Types["MyInterface"]
fmt.Println(typ.Doc)
} melalui targetPkg.Types["MyInterface"] dan mencetaknya ke konsol. MyInterface
.go/doc, maklumat ulasan bersarang dalam ulasan lain. Kita boleh mencari komen bersarang dengan menggelungkannya. Kod contoh berikut menunjukkan cara merentasi maklumat anotasi untuk mencari anotasi bersarang. Package
func Example() {
targetPkg := ...
// 遍历注释来查找嵌套的注释
for _, f := range targetPkg.Funcs {
ast.Inspect(f.Decl, func(node ast.Node) bool {
switch n := node.(type) {
case *ast.CommentGroup:
for _, c := range n.List {
if strings.Contains(c.Text, "TODO") {
fmt.Println(c)
}
}
}
return true
})
}
}上述代码中，我们使用 targetPkg.Funcs 获取所有函数和方法的注释。然后，我们使用 go/ast.Inspect 函数将注释树作为根节点输入，并遍历树中的所有注释。如果找到了包含特定文本的注释，则将其打印到控制台。在上述示例中，我们打印了所有包含 TODO 的注释。
有时候我们只对包含特定文本的注释感兴趣。在这种情况下，我们可以使用正则表达式或其他过滤器来过滤注释。下面示例代码演示了如何使用正则表达式过滤注释。
func Example() {
targetPkg := ...
// 使用正则表达式过滤注释
pattern, _ := regexp.Compile(`@deprecated`)
for _, f := range targetPkg.Funcs {
if pattern.MatchString(f.Doc) {
fmt.Printf("Function %s is deprecated: %s
", f.Name, f.Doc)
}
}
}上述代码中，我们创建了一个名为 pattern 的正则表达式。然后，我们遍历 targetPkg.Funcs，并使用 pattern 过滤所有包含 @deprecated 的注释。对于匹配的注释，我们将其打印到控制台。
总结
在本文中，我们探讨了如何使用 go/doc 包获取 Golang 源代码中的注释。我们介绍了基本的使用方法，并讲解了如何获取函数和方法、结构体和接口的注释。此外，我们还讨论了如何遍历注释以查找嵌套的注释，以及如何使用正则表达式或其他过滤器来过滤注释。希望本文能够帮助你更好地理解 Golang 的注释机制，并在实践中发挥作用。
Atas ialah kandungan terperinci golang dapat komen. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
