golang (#606)

Co-authored-by: jiangbingjie <jiangbingjie@yidian-inc.com>

public/dicts/go_builtin.json

@@ -0,0 +1,278 @@
+[
+  {
+    "name": "bool",
+    "trans": [
+      "bool 是布尔值的集合，true 和 false。"
+    ]
+  },
+  {
+    "name": "true",
+    "trans": [
+      "true 和 false 是两个无类型布尔值。"
+    ]
+  },
+  {
+    "name": "false",
+    "trans": [
+      "true 和 false 是两个无类型布尔值。"
+    ]
+  },
+  {
+    "name": "uint8",
+    "trans": [
+      "uint8 是所有无符号8位整数的集合。范围：0 到 255。"
+    ]
+  },
+  {
+    "name": "uint16",
+    "trans": [
+      "uint16 是所有无符号16位整数的集合。范围：0 到 65535。"
+    ]
+  },
+  {
+    "name": "uint32",
+    "trans": [
+      "uint32 是所有无符号32位整数的集合。范围：0 到 4294967295。"
+    ]
+  },
+  {
+    "name": "uint64",
+    "trans": [
+      "uint64 是所有无符号64位整数的集合。范围：0 到 18446744073709551615。"
+    ]
+  },
+  {
+    "name": "int8",
+    "trans": [
+      "int8 是所有有符号8位整数的集合。范围：-128 到 127。"
+    ]
+  },
+  {
+    "name": "int16",
+    "trans": [
+      "int16 是所有有符号16位整数的集合。范围：-32768 到 32767。"
+    ]
+  },
+  {
+    "name": "int32",
+    "trans": [
+      "int32 是所有有符号32位整数的集合。范围：-2147483648 到 2147483647。"
+    ]
+  },
+  {
+    "name": "int64",
+    "trans": [
+      "int64 是所有有符号64位整数的集合。范围：-9223372036854775808 到 9223372036854775807。"
+    ]
+  },
+  {
+    "name": "float32",
+    "trans": [
+      "float32 是所有IEEE-754标准的32位浮点数的集合。"
+    ]
+  },
+  {
+    "name": "float64",
+    "trans": [
+      "float64 是所有IEEE-754标准的64位浮点数的集合。"
+    ]
+  },
+  {
+    "name": "complex64",
+    "trans": [
+      "complex64 是所有由float32实部和虚部构成的复数的集合。"
+    ]
+  },
+  {
+    "name": "complex128",
+    "trans": [
+      "complex128 是所有由float64实部和虚部构成的复数的集合。"
+    ]
+  },
+  {
+    "name": "string",
+    "trans": [
+      "string 是所有由8位字节组成的字符串的集合，通常但不一定表示UTF-8编码的文本。字符串可以为空，但不可以为nil。string类型的值是不可变的。"
+    ]
+  },
+  {
+    "name": "int",
+    "trans": [
+      "int 是至少为32位大小的有符号整数类型。它是一个独立的类型，不是 int32 的别名。"
+    ]
+  },
+  {
+    "name": "uint",
+    "trans": [
+      "uint 是至少为32位大小的无符号整数类型。它是一个独立的类型，不是 uint32 的别名。"
+    ]
+  },
+  {
+    "name": "uintptr",
+    "trans": [
+      "uintptr 是一个足够大以容纳任何指针的位模式的整数类型。"
+    ]
+  },
+  {
+    "name": "byte",
+    "trans": [
+      "byte 是 uint8 的别名，在所有方面都等同于 uint8。它通常用于区分字节值和8位无符号整数值。"
+    ]
+  },
+  {
+    "name": "rune",
+    "trans": [
+      "rune 是 int32 的别名，在所有方面都等同于 int32。它通常用于区分字符值和整数值。"
+    ]
+  },
+  {
+    "name": "any",
+    "trans": [
+      "any 是 interface{} 的别名，在所有方面都等同于 interface{}。"
+    ]
+  },
+  {
+    "name": "comparable",
+    "trans": [
+      "comparable 是由所有可比较类型（布尔值、数字、字符串、指针、通道、由可比较类型组成的数组、其字段全都是可比较类型的结构体）实现的接口。comparable 接口只能用作类型参数约束，不能用作变量类型。"
+    ]
+  },
+  {
+    "name": "iota",
+    "trans": [
+      "iota 是一个预声明的标识符，表示当前常量声明中的无类型整数序数编号（通常在括号中的 const 声明中）。它从零开始索引。"
+    ]
+  },
+  {
+    "name": "nil",
+    "trans": [
+      "nil 是一个预声明的标识符，表示指针、通道、函数、接口、映射或切片类型的零值。"
+    ]
+  },
+  {
+    "name": "Type",
+    "trans": [
+      "Type 仅用于文档目的。它是任何 Go 类型的代替，但对于任何给定的函数调用，表示相同的类型。"
+    ]
+  },
+  {
+    "name": "Type1",
+    "trans": [
+      "Type1 仅用于文档目的。它是任何 Go 类型的代替，但对于任何给定的函数调用，表示相同的类型。"
+    ]
+  },
+  {
+    "name": "IntegerType",
+    "trans": [
+      "IntegerType 仅用于文档目的。它是任何整数类型的代替：int、uint、int8 等。"
+    ]
+  },
+  {
+    "name": "FloatType",
+    "trans": [
+      "FloatType 仅用于文档目的。它是任何浮点类型的代替：float32 或 float64。"
+    ]
+  },
+  {
+    "name": "ComplexType",
+    "trans": [
+      "ComplexType 仅用于文档目的。它是任何复数类型的代替：complex64 或 complex128。"
+    ]
+  },
+  {
+    "name": "append",
+    "trans": [
+      "append 内建函数将元素添加到切片的末尾。如果切片具有足够的容量，则会重新切片以容纳新元素。如果没有足够的容量，将分配一个新的底层数组。append 返回更新后的切片。因此，需要存储 append 的结果，通常在保存切片本身的变量中：   tslice = append(slice, elem1, elem2)  tslice = append(slice, anotherSlice...)  作为特例，允许将字符串追加到字节切片中，如下所示：   tslice = append([]byte( hello  ),  world ...) "
+    ]
+  },
+  {
+    "name": "copy",
+    "trans": [
+      "copy 内建函数将元素从源切片复制到目标切片。 (作为特例，它还会将字节从字符串复制到字节切片。) 源和目标可能重叠。copy 返回复制的元素数，这将是 len(src) 和 len(dst) 中的较小者。"
+    ]
+  },
+  {
+    "name": "delete",
+    "trans": [
+      "delete 内建函数从映射中删除具有指定键（m[key]）的元素。如果 m 为 nil 或不存在这样的元素，则 delete 无效。"
+    ]
+  },
+  {
+    "name": "len",
+    "trans": [
+      "len 内建函数根据其类型返回 v 的长度：   t数组：v 中的元素数。   数组指针：*v 中的元素数（即使 v 为 nil）。           切片或映射：v 中的元素数；如果 v 为 nil，则 len(v) 为零。   字符串：v 中的字节数。           通道：通道缓冲区中排队（未读）的元素数；如果 v 为 nil，则 len(v) 为零。          对于某些参数，例如字符串字面值或简单的数组表达式，结果可以是常量。有关详细信息，请参阅 Go 语言规范中的“长度和容量”部分。"
+    ]
+  },
+  {
+    "name": "cap",
+    "trans": [
+      "cap 内建函数根据其类型返回 v 的容量：   t数组：v 中的元素数（与 len(v) 相同）。               数组指针：*v 中的元素数（与 len(v) 相同）。               切片：重新切片时切片可以达到的最大长度；如果 v 为 nil，则 cap(v) 为零。               通道：通道缓冲区容量，以元素为单位；如果 v 为 nil，则 cap(v) 为零。              对于某些参数，例如简单的数组表达式，结果可以是常量。有关详细信息，请参阅 Go 语言规范中的“长度和容量”部分。"
+    ]
+  },
+  {
+    "name": "make",
+    "trans": [
+      "make 内建函数分配并初始化类型为切片、映射或通道（仅限）的对象。与 new 不同，第一个参数是类型，而不是值。与 new 不同，make 的返回类型与其参数的类型相同，而不是其指针。结果的规范取决于类型：   t切片：size 指定长度。切片的容量等于其长度。可以提供第二个整数参数以指定不同的容量；它必须不小于长度。例如，make([]int, 0, 10) 分配一个大小为 10 的底层数组，并返回长度为 0、容量为 10 的切片，由此底层数组支持。                   映射：分配一个空映射，足够大以容纳指定数量的元素。可以省略大小，此情况下将分配一个较小的起始大小。                   通道：通道的缓冲区以指定的缓冲区容量进行初始化。如果为零，或省略大小，则通道是无缓冲的。"
+    ]
+  },
+  {
+    "name": "new",
+    "trans": [
+      "new 内建函数分配内存。第一个参数是类型，不是值，返回的值是指向新分配的零值的指针。"
+    ]
+  },
+  {
+    "name": "complex",
+    "trans": [
+      "complex 内建函数从两个浮点值构造一个复数值。实部和虚部必须具有相同的大小，即 float32 或 float64（或可分配给它们）。返回值将是相应的复数类型（float32 为 complex64，float64 为 complex128）。"
+    ]
+  },
+  {
+    "name": "real",
+    "trans": [
+      "real 内建函数返回复数数 c 的实部。返回值将是与 c 的类型相对应的浮点类型。"
+    ]
+  },
+  {
+    "name": "imag",
+    "trans": [
+      "imag 内建函数返回复数数 c 的虚部。返回值将是与 c 的类型相对应的浮点类型。"
+    ]
+  },
+  {
+    "name": "close",
+    "trans": [
+      "close 内建函数关闭通道，必须是双向的或只发送的。它只能由发送者执行，永远不会由接收者执行，并且在接收到最后一个发送的值后，会关闭通道。从关闭通道 c 接收到的任何接收将不会阻塞，会返回通道元素的零值。形式如   tx, ok := <-c  也会为已关闭且为空的通道设置 ok 为 false。"
+    ]
+  },
+  {
+    "name": "panic",
+    "trans": [
+      "panic 内建函数停止当前 Goroutine 的正常执行。当函数 F 调用 panic 时，F 的正常执行立即停止。由 F 推迟执行的任何函数都会按照通常的方式运行，然后 F 返回给其调用者。对于调用者 G，对 F 的调用则像是对 panic 的调用，终止 G 的执行并运行任何推迟的函数。这将一直继续，直到执行 Goroutine 中的所有函数都停止，以相反的顺序进行。在那时，程序将以非零退出码终止。此终止序列称为 panic，可以通过内建函数 recover 来控制。"
+    ]
+  },
+  {
+    "name": "recover",
+    "trans": [
+      "recover 内建函数允许程序管理处于 panic 状态的 Goroutine 的行为。在延迟函数（但不是由它调用的任何函数）中执行 recover 调用会通过恢复正常执行来停止 panic 序列，并检索传递给 panic 调用的错误值。如果在延迟函数之外调用 recover，则不会停止 panic 序列。在这种情况下，或者 Goroutine 不在 panic 状态，或者传递给 panic 的参数为 nil，recover 返回 nil。因此，从 recover 返回的返回值报告 Goroutine 是否处于 panic 状态。"
+    ]
+  },
+  {
+    "name": "print",
+    "trans": [
+      "print 内建函数以特定于实现的方式格式化其参数，并将结果写入标准错误。print 用于引导和调试；不保证保留在语言中。"
+    ]
+  },
+  {
+    "name": "println",
+    "trans": [
+      "println 内建函数以特定于实现的方式格式化其参数，并将结果写入标准错误。参数之间始终添加空格，并附加换行符。println 用于引导和调试；不保证保留在语言中。"
+    ]
+  },
+  {
+    "name": "error",
+    "trans": [
+      "error 内建接口类型是表示错误条件的传统接口，nil 值表示没有错误。"
+    ]
+  }
+]

public/dicts/go_keyword.json

@@ -0,0 +1,27 @@
+[
+	{ "name": "var", "trans": ["n. 用于声明变量"] },
+	{ "name": "break", "trans": ["n. 用于提前结束循环或分支"] },
+	{ "name": "default", "trans": ["n. 用于指定默认分支"] },
+	{ "name": "func", "trans": ["n. 用于定义函数"] },
+	{ "name": "interface", "trans": ["n. 用于定义接口"] },
+	{ "name": "select", "trans": ["n. 用于选择通信操作"] },
+	{ "name": "case", "trans": ["n. 用于指定分支情况"] },
+	{ "name": "defer", "trans": ["n. 用于延迟函数执行"] },
+	{ "name": "go", "trans": ["n. 用于并发执行函数"] },
+	{ "name": "map", "trans": ["n. 用于声明映射数据结构"] },
+	{ "name": "struct", "trans": ["n. 用于定义结构体"] },
+	{ "name": "chan", "trans": ["n. 用于声明通道"] },
+	{ "name": "else", "trans": ["n. 用于条件不成立时执行的分支"] },
+	{ "name": "goto", "trans": ["n. 用于跳转到标签位置"] },
+	{ "name": "package", "trans": ["n. 用于定义包"] },
+	{ "name": "switch", "trans": ["n. 用于多条件选择"] },
+	{ "name": "const", "trans": ["n. 用于声明常量"] },
+	{ "name": "fallthrough", "trans": ["n. 用于执行下一个分支代码"] },
+	{ "name": "if", "trans": ["n. 用于条件判断"] },
+	{ "name": "range", "trans": ["n. 用于在循环中迭代元素"] },
+	{ "name": "type", "trans": ["n. 用于定义自定义类型"] },
+	{ "name": "continue", "trans": ["n. 用于跳过当前迭代"] },
+	{ "name": "for", "trans": ["n. 用于循环"] },
+	{ "name": "import", "trans": ["n. 用于导入外部包"] },
+	{ "name": "return", "trans": ["n. 用于从函数中返回"] }
+]

src/resources/dictionary.ts

@@ -1831,6 +1831,28 @@ const programming: DictionaryResource[] = [
     language: 'code',
     languageCategory: 'code',
   },
+  {
+    id: 'go_keyword',
+    name: 'golang-keyword',
+    description: 'go语言关键字,',
+    category: '代码练习',
+    tags: ['golang'],
+    url: '/dicts/go_keyword.json',
+    length: 25,
+    language: 'code',
+    languageCategory: 'code',
+  },
+  {
+    id: 'go_builtin',
+    name: 'golang-builtin',
+    description: 'go语言内建函数和类型',
+    category: '代码练习',
+    tags: ['golang'],
+    url: '/dicts/go_builtin.json',
+    length: 46,
+    language: 'code',
+    languageCategory: 'code',
+  },
 ]
 
 // 日语词典