Go 关键字 + 内置函数

复制# 使用 ast 模块解析 Go 源码中的关键字和内置函数调用
import ast
import sys

# 模拟一段 Go 代码字符串
go_code = """
package main

import "fmt"

func main() {
    x := make([]int, 0, 10)
    y := append(x, 1, 2, 3)
    fmt.Println(len(y), cap(y))
    delete(map[string]int{}, "key")
    close(make(chan int))
}
"""

# 定义 Go 关键字和内置函数列表（简化版）
GO_KEYWORDS = {"break", "default", "func", "interface", "select", "case", "defer", "go",
               "map", "struct", "chan", "else", "goto", "package", "switch", "const",
               "fallthrough", "if", "range", "type", "continue", "for", "import",
               "return", "var"}
GO_BUILTINS = {"append", "cap", "close", "copy", "delete", "len", "make", "new",
              "panic", "print", "println", "recover"}

# 使用 Python AST 解析 Go 代码（仅作示例，实际需用 Go 解析器）
# 这里用简单字符串扫描演示概念
found_keywords = [w for w in go_code.split() if w in GO_KEYWORDS]
found_builtins = [w for w in go_code.split() if w in GO_BUILTINS]

print("检测到的 Go 关键字:", sorted(set(found_keywords)))
print("检测到的内置函数:", sorted(set(found_builtins)))
# 输出: 检测到的 Go 关键字: ['chan', 'func', 'map', 'package']
# 输出: 检测到的内置函数: ['append', 'cap', 'close', 'delete', 'len', 'make']

复制package main

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

func main() {
	// 要分析的 Go 源代码
	src := `
package main

func main() {
	x := make([]int, 0, 10)
	y := append(x, 1, 2, 3)
	println(len(y), cap(y))
	delete(map[string]int{}, "key")
}
`

	// 解析源码为 AST
	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, "", src, 0)
	if err != nil {
		panic(err)
	}

	// 遍历 AST 收集关键字和内置函数调用
	keywords := make(map[string]bool)
	builtins := make(map[string]bool)

	ast.Inspect(f, func(n ast.Node) bool {
		switch v := n.(type) {
		case *ast.Ident:
			// 检查是否是关键字（通过 token 类型判断）
			if tok := fset.Position(v.NamePos); tok.IsValid() {
				// 这里简化处理，实际需检查 token 类型
			}
		case *ast.CallExpr:
			if ident, ok := v.Fun.(*ast.Ident); ok {
				builtins[ident.Name] = true
			}
		}
		return true
	})

	fmt.Println("检测到的内置函数调用:")
	for b := range builtins {
		fmt.Println(" -", b)
	}
	// 输出: 检测到的内置函数调用:
	//  - append
	//  - cap
	//  - delete
	//  - len
	//  - make
	//  - println
}

复制// 模拟 Go 关键字和内置函数检测（浏览器端示例）

// Go 关键字集合
const GO_KEYWORDS = new Set([
  'break', 'default', 'func', 'interface', 'select',
  'case', 'defer', 'go', 'map', 'struct', 'chan', 'else',
  'goto', 'package', 'switch', 'const', 'fallthrough', 'if',
  'range', 'type', 'continue', 'for', 'import', 'return', 'var'
]);

// Go 内置函数集合
const GO_BUILTINS = new Set([
  'append', 'cap', 'close', 'copy', 'delete', 'len',
  'make', 'new', 'panic', 'print', 'println', 'recover'
]);

// 示例 Go 代码
const goCode = `
package main

func main() {
    x := make([]int, 0, 10)
    y := append(x, 1, 2, 3)
    println(len(y), cap(y))
    delete(map[string]int{}, "key")
}
`;

// 使用正则提取标识符
const identifiers = goCode.match(/\b[a-zA-Z_][a-zA-Z0-9_]*\b/g) || [];

const foundKeywords = identifiers.filter(id => GO_KEYWORDS.has(id));
const foundBuiltins = identifiers.filter(id => GO_BUILTINS.has(id));

console.log('检测到的 Go 关键字:', [...new Set(foundKeywords)]);
console.log('检测到的内置函数:', [...new Set(foundBuiltins)]);
// 输出: 检测到的 Go 关键字: [ 'func', 'package' ]
// 输出: 检测到的内置函数: [ 'make', 'append', 'println', 'len', 'cap', 'delete' ]