golang dapat komen

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:

1. go/doc Penggunaan asas pakej
2. Cara mendapatkan ulasan tentang kaedah dan fungsi
3. Cara mendapatkan struktur dan Komen antara muka
4. Bersarang dan menapis ulasan

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.

1. Dapatkan anotasi fungsi

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.

2. Dapatkan anotasi kaedah

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.

1. Dapatkan anotasi struktur

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)
}

Dalam kod di atas, kami memperoleh maklumat anotasi struktur bernama

melalui targetPkg.Types["MyStruct"] dan mencetaknya ke konsol. MyStruct

Dapatkan ulasan antara muka

Serupa dengan struktur, kita juga boleh menggunakan medan

Jenisgo/doc.Doc` untuk mendapatkan maklumat ulasan antara muka. 类型中的

func Example() {
    targetPkg := ...

    // 获取接口的注释
    typ := targetPkg.Types["MyInterface"]
    fmt.Println(typ.Doc)
}

Dalam kod di atas, kami memperoleh maklumat anotasi antara muka bernama

melalui targetPkg.Types["MyInterface"] dan mencetaknya ke konsol. MyInterface

4. Bersarang dan menapis ulasan

Di Golang, ulasan boleh bersarang dalam ulasan lain, yang bermaksud kita boleh mencari komen bersarang dengan merentasi ulasan. Tambahan pula, kadangkala kami hanya berminat dengan anotasi yang mengandungi teks tertentu. Dalam kes ini, kami boleh menggunakan ungkapan biasa atau penapis lain untuk menapis ulasan.

Dapatkan ulasan bersarang

Dalam taip

.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 的注释。

2. 使用过滤器来过滤注释

有时候我们只对包含特定文本的注释感兴趣。在这种情况下，我们可以使用正则表达式或其他过滤器来过滤注释。下面示例代码演示了如何使用正则表达式过滤注释。

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!