Go编程语言规范[译]

1
2
3
4
5
6
7

Production  = production_name, "=", [ Expression ], "." .
Expression  = Alternative, { "|", Alternative } .
Alternative = Term, { Term } .
Term        = production_name | token, [ "…", token ] | Group | Option | Repetition .
Group       = "(", Expression, ")" .
Option      = "[", Expression, "]" .
Repetition  = "{", Expression, "}" .

1
2
3
4

|   多选一
()  分组
[]  零或一
{}  零或多

1
2
3
4

newline        = ? Unicode 码位 U+000A ? .
unicode_char   = ? newline 以外的任意 Unicode 码位 ? .
unicode_letter = ? 被分类为「字母」的 Unicode 码位 ? .
unicode_digit  = ? 被分类为「数字/十进制数」的 Unicode 码位 ? .

1
2
3
4
5

letter        = unicode_letter | "_" .
decimal_digit = "0" … "9" .
binary_digit  = "0" | "1" .
octal_digit   = "0" … "7" .
hex_digit     = "0" … "9" | "A" … "F" | "a" … "f" .

1
2
3
4
5

identifier = letter, { letter | unicode_digit } .
a
_x9
ThisVariableIsExported
αβ

1
2
3
4
5

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

1
2
3
4
5
6

+    &     +=    &=     &&    ==    !=    (    )
-    |     -=    |=     ||    <     <=    [    ]
*    ^     *=    ^=     <-    >     >=    {    }
/    <<    /=    <<=    ++    =     :=    ,    ;
%    >>    %=    >>=    --    !     ...   .    :
     &^          &^=          ~

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

int_lit        = decimal_lit | binary_lit | octal_lit | hex_lit .
decimal_lit    = "0" | ( "1" … "9" ), [ [ "_" ], decimal_digits ] .
binary_lit     = "0", ( "b" | "B" ), [ "_" ], binary_digits .
octal_lit      = "0", [ "o" | "O" ], [ "_" ], octal_digits .
hex_lit        = "0", ( "x" | "X" ), [ "_" ], hex_digits .

decimal_digits = decimal_digit, { [ "_" ], decimal_digit } .
binary_digits  = binary_digit, { [ "_" ], binary_digit } .
octal_digits   = octal_digit, { [ "_" ], octal_digit } .
hex_digits     = hex_digit, { [ "_" ], hex_digit } .
42
4_2
0600
0_600
0o600
0O600       // 第二个字符是大写字母 'O'
0xBadFace
0xBad_Face
0x_67_7a_2f_cc_40_c6
170141183460469231731687303715884105727
170_141183_460469_231731_687303_715884_105727

_42         // 这是一个标识符，而不是一个整数字面值
42_         // 无效: _ 必须分隔连续数字
4__2        // 无效: 一次只能有一个 _
0_xBadFace  // 无效: _ 必须分隔连续数字

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

float_lit         = decimal_float_lit | hex_float_lit .

decimal_float_lit = decimal_digits, ".", [ decimal_digits ], [ decimal_exponent ] |
                    decimal_digits, decimal_exponent |
                    ".", decimal_digits, [ decimal_exponent ] .
decimal_exponent  = ( "e" | "E" ), [ "+" | "-" ], decimal_digits .

hex_float_lit     = "0", ( "x" | "X" ), hex_mantissa, hex_exponent .
hex_mantissa      = [ "_" ], hex_digits, ".", [ hex_digits ] |
                    [ "_" ], hex_digits |
                    ".", hex_digits .
hex_exponent      = ( "p" | "P" ), [ "+" | "-" ], decimal_digits .
0.
72.40
072.40       // == 72.40
2.71828
1.e+0
6.67428e-11
1E6
.25
.12345E+5
1_5.         // == 15.0
0.15e+0_2    // == 15.0

0x1p-2       // == 0.25
0x2.p10      // == 2048.0
0x1.Fp+0     // == 1.9375
0X.8p-0      // == 0.5
0X_1FFFP-16  // == 0.1249847412109375
0x15e-2      // == 0x15e - 2 （整数减法）

0x.p1        // 无效的： 有效数字无数字
1p-2         // 无效的： p 指数需要十六进制有效数字
0x1.5e-2     // 无效的： hexadecimal mantissa requires p exponent
1_.5         // 无效的： _ 必须分隔连续的数字
1._5         // 无效的： _ 必须分隔连续的数字
1.5_e1       // 无效的： _ 必须分隔连续的数字
1.5e_1       // 无效的： _ 必须分隔连续的数字
1.5e1_       // 无效的： _ 必须分隔连续的数字

1

imaginary_lit = (decimal_digits | int_lit | float_lit), "i" .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

0i
0123i         // == 123i 为了向后兼容
0o123i        // == 0o123 * 1i == 83i
0xabci        // == 0xabc * 1i == 2748i
0.i
2.71828i
1.e+0i
6.67428e-11i
1E6i
.25i
.12345E+5i
0x1p-2i       // == 0x1p-2 * 1i == 0.25i

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

\a   U+0007 警报或蜂鸣声
\b   U+0008 退格
\f   U+000C 换页
\n   U+000A 换行或新行
\r   U+000D 回车
\t   U+0009 水平制表
\v   U+000B 垂直制表
\\   U+005C 反斜杠
\'   U+0027 单引号（只在 rune 字面值中转义才有效）
\"   U+0022 双引号（只在字符串字面值中转义才有效）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

rune_lit         = "'", ( unicode_value | byte_value ), "'" .
unicode_value    = unicode_char | little_u_value | big_u_value | escaped_char .
byte_value       = octal_byte_value | hex_byte_value .
octal_byte_value = `\`, octal_digit, octal_digit, octal_digit .
hex_byte_value   = `\`, "x", hex_digit, hex_digit .
little_u_value   = `\`, "u", hex_digit, hex_digit, hex_digit, hex_digit .
big_u_value      = `\`, "U", hex_digit, hex_digit, hex_digit, hex_digit,
                             hex_digit, hex_digit, hex_digit, hex_digit, .
escaped_char     = `\`, ( "a" | "b" | "f" | "n" | "r" | "t" | "v" | `\` | "'" | `"` ) .
'a'
'ä'
'本'
'\t'
'\000'
'\007'
'\377'
'\x07'
'\xff'
'\u12e4'
'\U00101234'
'\''         // 包含了一个单引号字符的 rune 字面值
'aa'         // 非法：字符太多
'\xa'        // 非法：十六进制数字太少
'\0'         // 非法：八进制数字太少
'\uDFFF'     // 非法：只代理了一半
'\U00110000' // 非法：无效的 Unicode 码位

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

string_lit             = raw_string_lit | interpreted_string_lit .
raw_string_lit         = "`", { unicode_char | newline }, "`" .
interpreted_string_lit = `"`, { unicode_value | byte_value }, `"` .
`abc`                // 同 "abc"
`\n
\n`                  // 同 "\\n\n\\n"
"\n"
"\""                 // 同 `"`
"Hello, world!\n"
"日本語"
"\u65e5本\U00008a9e"
"\xff\u00FF"
"\uD800"             // 非法: 代理了一半
"\U00110000"         // 非法: 无效的 Unicode 码位

1
2
3
4
5

"日本語"                                 // UTF-8 输入文本
`日本語`                                 // 以原始字面值输入的 UTF-8 文本
"\u65e5\u672c\u8a9e"                    // 明确的 Unicode 码位
"\U000065e5\U0000672c\U00008a9e"        // 明确的 Unicode 码位
"\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"  // 明确的 UTF-8 字节

1
2
3
4

var x interface{}  // x 是 nil，它有一个静态类型 interface{}
var v *T           // v 的值为 nil，静态类型为 *T
x = 42             // x 的值为 42，动态类型为 int
x = v              // x 的值为 (*T)(nil)，动态类型为 *T

1
2
3
4
5
6
7

Type      = TypeName | TypeLit | "(", Type, ")" .
Type      = TypeName, [ TypeArgs ] | TypeLit | "(", Type, ")" .
TypeName  = identifier | QualifiedIdent .
TypeArgs  = "[", TypeList, [ "," ], "]" .
TypeList  = Type, { ",", Type } .
TypeLit   = ArrayType | StructType | PointerType | FunctionType | InterfaceType |
            SliceType | MapType | ChannelType .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

uint8       无符号的  8 位整数集合（0 到 255）
uint16      无符号的 16 位整数集合（0 到 65535）
uint32      无符号的 32 位整数集合（0 到 4294967295）
uint64      无符号的 64 位整数集合（0 到 18446744073709551615）

int8        带符号的  8 位整数集合（-128 到 127）
int16       带符号的 16 位整数集合（-32768 到 32767）
int32       带符号的 32 位整数集合（-2147483648 到 2147483647）
int64       带符号的 64 位整数集合（-9223372036854775808 到 9223372036854775807）

float32     所有 IEEE-754 标准的 32 位浮点数数字集合
float64     所有 IEEE-754 标准的 64 位浮点数数字集合

complex64   由 float32 类型的实数和虚数部分所组成的所有复数的集合
complex128  由 float64 类型的实数和虚数部分所组成的所有复数的集合

byte        unit8 的别名
rune        int32 的别名

1
2
3

uint     可以是 32 或 64 位
int      和 uint 大小相同
uintptr  一个大到足够用来存储一个指针值的未解释的比特位的无符号整数

1
2
3

ArrayType   = "[", ArrayLength, "]", ElementType .
ArrayLength = Expression .
ElementType = Type .

1
2
3
4
5

[32]byte
[2*N] struct { x, y int32 }
[1000]*float64
[3][5]int
[2][2][2]float64  // 同 [2]([2]([2]float64))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// file: test0.go
package main

func main() {
  var a []int
  print(a)
}

// file: test1.go
package main

func main() {
  var a []int = nil
  print(a)
}

1
2

go build -o test ./test.go
objdump -d -Mamd64 test > test.s

1

SliceType = "[", "]", ElementType .

1

make([]T, length, capacity)

1
2

make([]int, 50, 100)
new([100]int)[0:50]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

StructType    = "struct", "{", { FieldDecl, ";" }, "}" .
FieldDecl     = (IdentifierList Type | EmbeddedField), [ Tag ] .
EmbeddedField = [ "*" ], TypeName .
Tag           = string_lit .
// 一个空的结构体
struct {}

// 一个有六个字段的结构体
struct {
  x, y int
  u float32
  _ float32  // padding
  A *[]int
  F func()
}

1
2
3
4
5
6
7
8

// 四个类型分别为 T1, *T2, P.T3, *P.T4 的嵌入字段所组成的结构体
struct {
  T1        // 字段名为 T1
  *T2       // 字段名为 T2
  P.T3      // 字段名为 T3
  *P.T4     // 字段名为 T4
  x, y int  // 字段名为 x 和 y
}

1
2
3
4
5

struct {
  T     // 与嵌入字段 *T 和 *P.T 冲突
  *T    // 与嵌入字段  T 和 *P.T 冲突
  *P.T  // 与嵌入字段  T 和   *T 冲突
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

struct {
  x, y float64 ""  // 空的标签字面值和没有标签一样
  name string  "any string is permitted as a tag"
  _    [4]byte "ceci n'est pas un champ de structure"
}

// 对应时间戳协议缓冲区的结构体
// 其标签字符串定义了协议缓冲区的字段号
// 它们遵循了由 reflect 包所概述的转换规则
struct {
  microsec  uint64 `protobuf:"1"`
  serverIP6 uint64 `protobuf:"2"`
}

1
2
3
4

PointerType = "*", BaseType .
BaseType    = Type .
*Point
*[4]int

1
2
3
4
5
6

FunctionType   = "func", Signature .
Signature      = Parameters, [ Result ] .
Result         = Parameters | Type .
Parameters     = "(", [ ParameterList, [ "," ] ], ")" .
ParameterList  = ParameterDecl, { ",", ParameterDecl } .
ParameterDecl  = [ IdentifierList ], [ "..." ], Type .

1
2
3
4
5
6
7
8

func()
func(x int) int
func(a, _ int, z float32) bool
func(a, b int, z float32) (bool)
func(prefix string, values ...int)
func(a, b int, z float64, opt ...interface{}) (success bool)
func(int, int, float64) (float64, *[]int)
func(n int) func(p *T)

1
2
3
4
5
6
7

InterfaceType  = "interface", "{", { InterfaceElem, ";" }, "}" .
InterfaceElem  = MethodElem | TypeElem .
MethodElem     = MethodName, Signature .
MethodName     = identifier .
TypeElem       = TypeTerm, { "|", TypeTerm } .
TypeTerm       = Type | UnderlyingType .
UnderlyingType = "~", Type .

1
2
3
4
5
6

// 一个简单的 File 接口。
interface {
  Read([]byte) (int, error)
  Write([]byte) (int, error)
  Close() error
}

1
2
3
4
5

interface {
  String() string
  String() string  // 非法: String 不是唯一的
  _(x int)         // 非法: 方法不能是空白名
}

1
2
3

func (p T) Read(p []byte) (n int, err error)
func (p T) Write(p []byte) (n int, err error)
func (p T) Close() error

1

interface{}

1
2
3
4

type Locker interface {
  Lock()
  Unlock()
}

1
2

func (p T) Lock() { … }
func (p T) Unlock() { … }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

type Reader interface {
  Read(p []byte) (n int, err error)
  Close() error
}

type Writer interface {
  Write(p []byte) (n int, err error)
  Close() error
}

// ReadWriter 的方法是 Read, Write, Close
type ReadWriter interface {
  Reader  // 在 ReadWriter 的方法集中包含 Reader 的方法
  Writer  // 在 ReadWriter 的方法集中包含 Writer 的方法
}

1
2
3
4

type ReadCloser interface {
  Reader   // 在 ReadCloser 的方法集中包含 Reader 的方法
  Close()  // 非法： Reader.Close 的签名和 Close 的不同
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 仅代表类型 int 的接口。
interface {
  int
}

// 代表具有潜在类型 int 的所有类型的接口
interface {
  ~int
}

// 代表具有潜在类型 int 且实现了 String 方法的所有类型的接口
interface {
  ~int
  String() string
}

// 代表一个空类型集的接口；没有类型能同时是 int 和 string
interface {
  int
  string
}

1
2
3
4
5
6
7

type MyInt int

interface {
  ~[]byte  // []byte 的潜在类型是它自己
  ~MyInt   // 非法： MyInt 的潜在类型不是 MyInt
  ~error   // 非法： error 是一个接口
}

1
2
3
4
5

// Float 接口代表了所有浮点数类型
// （包括所有潜在类型为 float32 或 float64 的命名类型）。
type Float interface {
  ~float32 | ~float64
}

1
2
3
4
5
6

interface {
  P                // 非法： P 是一个类型形参
  int | P          // 非法： P 是一个类型形参
  ~int | MyInt     // 非法： ~int 的类型集和 MyInt 不是不相交的（ ~int 包括了 MyInt ）
  float32 | Float  // 重叠的类型集但 Float 是一个接口
}

1
2
3
4
5
6
7

var x Float                     // 非法： Float 不是一个基本接口

var x interface{} = Float(nil)  // 非法

type Floatish struct {
  f Float                       // 非法
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 非法: Bad 不能嵌入它自己
type Bad interface {
  Bad
}

// 非法: Bad1 不能通过 Bad2 来嵌入它自己
type Bad1 interface {
  Bad2
}
type Bad2 interface {
  Bad1
}

// 非法： Bad3 不能嵌入包含 Bad3 的并集
type Bad3 interface {
  ~int | ~string | Bad3
}

1
2

MapType     = "map", "[", KeyType, "]", ElementType .
KeyType     = Type .

1
2
3

map[string]int
map[*T]struct{ x, y float64 }
map[string]interface{}

1
2

make(map[string]int)
make(map[string]int, 100)

1

ChannelType = ( "chan" | "chan", "<-" | "<-", "chan" ), ElementType .

1
2
3

chan T          // 可用于发送或接收类型为 T 的值
chan<- float64  // 仅用于发送 float64 类型
<-chan int      // 仅用于接收 int 类型

1
2
3
4

chan<- chan int    // 和 chan<- (chan int) 一样
chan<- <-chan int  // 和 chan<- (<-chan int) 一样
<-chan <-chan int  // 和 <-chan (<-chan int) 一样
chan (<-chan int)

1

make(chan int, 100)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

type (
  A1 = string
  A2 = A1
)

type (
  B1 string
  B2 B1
  B3 []B1
  B4 B3
)

func f[P any](x P) { … }

1
2
3
4
5
6
7
8

type Celsius float32
type Kelvin  float32

interface{ int }                          // int
interface{ Celsius|Kelvin }               // float32
interface{ ~chan int }                    // chan int
interface{ ~chan int|~chan<- int }        // chan<- int
interface{ ~[]*data; String() string }    // []*data

1
2
3
4

interface{}                               // 无单一潜在类型
interface{ Celsius|float64 }              // 无单一潜在类型
interface{ chan int | chan<- string }     // 信道有不同的元素类型
interface{ <-chan int | chan<- int }      // 定向信道有不同的方向

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

type (
  A0 = []string
  A1 = A0
  A2 = struct{ a, b int }
  A3 = int
  A4 = func(A3, float64) *A0
  A5 = func(x int, _ float64) *[]string

  B0 A0
  B1 []string
  B2 struct{ a, b int }
  B3 struct{ a, c int }
  B4 func(int, float64) *B0
  B5 func(x int, y float64) *A1
  C0 = B0
  D0[P1, P2 any] struct{ x P1; y P2 }
  E0 = D0[int, string]
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

A0, A1, 和 []string
A2 和 struct{ a, b int }
A3 和 int
A4, func(int, float64) *[]string, 和 A5

B0 和 C0
D0[int, string] 和 E0
[]int 和 []int
struct{ a, b *T5 } 和 struct{ a, b *T5 }
func(x int, y float64) *[]string, func(int, float64) (result *[]string), 和 A5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

x                   T           x 可以被 T 表示的原因是

'a'                 byte        97 在 byte 值集中
97                  rune        rune 是 int32 的别名且 97 在 32 位整数值集中
"foo"               string      "foo" 在 string 值集中
1024                int16       1024 在 16 位整数值集中
42.0                byte        42 在无符号 8 位整数值集中
1e10                uint64      10000000000 在无符号 64 位整数值集中
2.718281828459045   float32     2.718281828459045 约到 2.7182817 后在 float32 值集中
-1e-1000            float64     -1e-1000 约到 IEEE -0.0 后再被进一步简化到 0.0
0i                  int         0 是一个整数值
(42 + 0i)           float32     42.0 （带虚部零）在 float32 值集中
x                   T           x 不能被 T 表示的原因是

0                   bool        0 不在 boolean 值集中
'a'                 string      'a' 是 rune，它不在 string 值集中
1024                byte        1024 不在无符号 8 位整数值集中
-1                  uint16      -1 不在无符号 16 位整数值集中
1.1                 int         1.1 不是一个整数值
42i                 float32     (0 + 42i) 不在 float32 值集中
1e1000              float64     1e1000 约数后溢出了 IEEE +Inf

1
2

Block = "{", StatementList, "}" .
StatementList = { Statement, ";" } .

1
2

Declaration   = ConstDecl | TypeDecl | VarDecl .
TopLevelDecl  = Declaration | FunctionDecl | MethodDecl .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

Types:
  any bool byte comparable
  complex64 complex128 error float32 float64
  int int8 int16 int32 int64 rune string
  uint uint8 uint16 uint32 uint64 uintptr

Constants:
  true false iota

Zero value:
  nil

Functions:
  append cap close complex copy delete imag len
  make new panic print println real recover

1
2
3
4
5

ConstDecl      = "const", ( ConstSpec | "(", { ConstSpec, ";" }, ")", ) .
ConstSpec      = IdentifierList, [ [ Type ], "=", ExpressionList ] .

IdentifierList = identifier { ",", identifier } .
ExpressionList = Expression { ",", Expression } .

1
2
3
4
5
6
7
8

const Pi float64 = 3.14159265358979323846
const zero = 0.0        // 非类型化的浮点数常量
const (
  size int64 = 1024
  eof        = -1       // 非类型化的整数常量
)
const a, b, c = 3, 4, "foo"  // a = 3, b = 4, c = "foo", 非类型化的整数和字符串常量
const u, v float32 = 0, 3    // u = 0.0, v = 3.0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

const (
  Sunday = iota
  Monday
  Tuesday
  Wednesday
  Thursday
  Friday
  Partyday
  numberOfDays  // 这个常量是不暴露的
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

const (
  c0 = iota  // c0 == 0
  c1 = iota  // c1 == 1
  c2 = iota  // c2 == 2
)

const (
  a = 1 << iota  // a == 1  (iota == 0)
  b = 1 << iota  // b == 2  (iota == 1)
  c = 3          // c == 3  (iota == 2，没有使用)
  d = 1 << iota  // d == 8  (iota == 3)
)

const (
  u         = iota * 42  // u == 0     （非类型化的整数常量）
  v float64 = iota * 42  // v == 42.0  （float64 常量）
  w         = iota * 42  // w == 84    （非类型化的整数常量）
)

const x = iota  // x == 0
const y = iota  // y == 0

1
2
3
4
5
6

const (
  bit0, mask0 = 1 << iota, 1<<iota - 1  // bit0 == 1, mask0 == 0  (iota == 0)
  bit1, mask1                           // bit1 == 2, mask1 == 1  (iota == 1)
  _, _                                  //                        (iota == 2，没有使用)
  bit3, mask3                           // bit3 == 8, mask3 == 7  (iota == 3)
)

1
2

TypeDecl     = "type", ( TypeSpec | "(", { TypeSpec, ";" }, ")" ) .
TypeSpec     = AliasDecl | TypeDef .

1

AliasDecl = identifier, "=", Type .

1
2
3
4

type (
  nodeList = []*Node  // nodeList 和 []*Node 的类型一致
  Polar    = polar    // Polar 和 polar 表示的类型一致
)

1

TypeDef = identifier, [ TypeParameters ], Type .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

type (
  Point struct{ x, y float64 }  // Point 和 struct{x, y float64} 是不同的类型
  polar Point                   // polar 和 Point 表示不同的类型
)

type TreeNode struct {
  left, right *TreeNode
  value any
}

type Block interface {
  BlockSize() int
  Encrypt(src, dst []byte)
  Decrypt(src, dst []byte)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// Mutex 是带两个方法——Lock 和 Unlock——的数据类型。
type Mutex struct         { /* 互斥对象字段 */ }
func (m *Mutex) Lock()    { /* Lock 实现 */ }
func (m *Mutex) Unlock()  { /* Unlock 实现 */ }

// NewMutex 和 Mutex 有相同的构成，但是其方法集是空的。
type NewMutex Mutex

// PtrMutex 的潜在类型 *Mutex 的方法集是保持不变的，
// 但 PtrMutex 的方法集是空的。
type PtrMutex *Mutex

// *PrintableMutex 的方法集包含了绑定到它的嵌入字段 Mutex 的方法 Lock 和 Unlock 。
type PrintableMutex struct {
  Mutex
}

// MyBlock 是一个和 Block 有着相同方法集的接口类型。
type MyBlock Block

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

type TimeZone int

const (
  EST TimeZone = -(5 + iota)
  CST
  MST
  PST
)

func (tz TimeZone) String() string {
  return fmt.Sprintf("GMT%+dh", tz)
}

1
2
3
4

type List[T any] struct {
  next  *List[T]
  value T
}

1
2
3
4
5

type T[P any] P    // 非法： P 是一个类型形参

func f[T any]() {
  type L T         // 非法： T 是被封闭函数所声明的一个类型形参
}

1
2

// 方法 Len 会返回连接列表 l 中元素的数量。
func (l *List[T]) Len() int  { … }

1
2
3

TypeParameters  = "[", TypeParamList, [ "," ], "]" .
TypeParamList   = TypeParamDecl, { ",", TypeParamDecl } .
TypeParamDecl   = IdentifierList, TypeConstraint .

1
2
3
4
5

[P any]
[S interface{ ~[]byte|string }]
[S ~[]E, E any]
[P Constraint[int]]
[_ any]

1
2
3

type T[P *C] …
type T[P (C)] …
type T[P *C|Q] …

1
2

type T[P interface{*C}] …
type T[P *C,] …

1

TypeConstraint = TypeElem .

1
2
3
4

[T []P]                      // = [T interface{[]P}]
[T ~int]                     // = [T interface{~int}]
[T int|string]               // = [T interface{int|string}]
type Constraint ~int         // 非法： ~int 不在一个类型参数列表里

1
2
3
4
5
6

int                          // 实现了 comparable
[]byte                       // 未实现 comparable （分片不能被比较）
interface{}                  // 未实现 comparable （见上文）
interface{ ~int | ~string }  // 仅对类型形参而言： 实现了 comparable
interface{ comparable }      // 仅对类型形参而言： 实现了 comparable
interface{ ~int | ~[]byte }  // 仅对类型形参而言： 未实现 comparable （不是所有在类型集中的类型都可以被比较）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

VarDecl     = "var", ( VarSpec | "(", { VarSpec, ";" }, ")", ) .
VarSpec     = IdentifierList, ( Type, [ "=", ExpressionList ] | "=", ExpressionList ) .
var i int
var U, V, W float64
var k = 0
var x, y float32 = -1, -2
var (
  i int
  u, v, s = 2.0, 3.0, "bar"
)
var re, im = complexSqrt(-1)
var _, found = entries[name]  // 映射查找；只关心 "found"

1
2
3
4

var d = math.Sin(0.5)  // d 是 float64
var i = 42             // i 是 int
var t, ok = x.(T)      // t 是 T, ok 是 bool
var n = nil            // 非法

1

ShortVarDecl = IdentifierList, ":=", ExpressionList .

1
2
3
4
5
6

"var", IdentifierList, "=", ExpressionList .
i, j := 0, 10
f := func() int { return 7 }
ch := make(chan int)
r, w, _ := os.Pipe(fd)  // os.Pipe() 返回一个连接着的文件对和一个 error （如果有的话）
_, y, _ := coord(p)  // coord() 返回三个值; 只关心 y 座标

1
2
3

field1, offset := nextField(str, 0)
field2, offset := nextField(str, offset)  // 重复声明了 offset
a, a := 1, 2                              // 非法: a 声明了两次，或者如果 a 已经在其它地方声明的了话那么就没有新的变量了

1
2
3

FunctionDecl = "func", FunctionName, [ TypeParameters ], Signature, [ FunctionBody ] .
FunctionName = identifier .
FunctionBody = Block .

1
2
3
4
5
6
7
8

func IndexRune(s string, r rune) int {
  for i, c := range s {
    if c == r {
      return i
    }
  }
  // 无效: 缺少返回语句
}

1
2
3
4
5
6

func min[T ~int|~float64](x, y T) T {
  if x < y {
    return x
  }
  return y
}

1

func flushICache(begin, end uintptr)  // 由外部实现

1
2

MethodDecl   = "func", Receiver, MethodName, Signature, [ FunctionBody ] .
Receiver     = Parameters .

1
2
3
4
5
6
7
8

func (p *Point) Length() float64 {
  return math.Sqrt(p.x * p.x + p.y * p.y)
}

func (p *Point) Scale(factor float64) {
  p.x *= factor
  p.y *= factor
}

1
2
3
4
5
6
7

type Pair[A, B any] struct {
       a A
       b B
}

func (p Pair[A, B]) Swap() Pair[B, A]  { … }  // 接收器声明了 A, B
func (p Pair[First, _]) First() First  { … }  // 接收器声明了 First ，对应 Pair 中的 A

1
2
3
4

Operand     = Literal | OperandName, [ TypeArgs ] | "(" Expression ")" .
Literal     = BasicLit | CompositeLit | FunctionLit .
BasicLit    = int_lit | float_lit | imaginary_lit | rune_lit | string_lit .
OperandName = identifier | QualifiedIdent .

1

QualifiedIdent = PackageName, ".", identifier .

1

math.Sin  // 表示在包 math 中的 Sin 函数

1
2
3
4
5
6
7
8
9

CompositeLit  = LiteralType, LiteralValue .
LiteralType   = StructType | ArrayType | "[", "...", "]", ElementType |
                SliceType | MapType | TypeName .
LiteralValue  = "{", [ ElementList, [ "," ] ], "}" .
ElementList   = KeyedElement, { ",", KeyedElement } .
KeyedElement  = [ Key, ":" ], Element .
Key           = FieldName | Expression | LiteralValue .
FieldName     = identifier .
Element       = Expression | LiteralValue .

1
2

type Point3D struct { x, y, z float64 }
type Line struct { p, q Point3D }

1
2

origin := Point3D{}                            // Point3D 为零值
line := Line{origin, Point3D{y: -4, z: 12.3}}  // line.q.x 为零值

1

var pointer *Point3D = &Point3D{y: 1000}

1
2

p1 := &[]int{}    // p1 指向一个初始化过的值为 []int{} 长度为 0 的空分片
p2 := new([]int)  // p2 指向一个值为 nil 长度为 0 的未初始化过的分片

1
2
3

buffer := [10]string{}             // len(buffer) == 10
intSet := [6]int{1, 2, 3, 5}       // len(intSet) == 6
days := [...]string{"Sat", "Sun"}  // len(days) == 2

1

[]T{x1, x2, … xn}

1
2

tmp := [n]T{x1, x2, … xn}
tmp[0 : n]

1
2
3
4
5
6
7
8
9

[...]Point{{1.5, -3.5}, {0, 0}}     // 同 [...]Point{Point{1.5, -3.5}, Point{0, 0}}
[][]int{{1, 2, 3}, {4, 5}}          // 同 [][]int{[]int{1, 2, 3}, []int{4, 5}}
[][]Point{{{0, 1}, {1, 2}}}         // 同 [][]Point{[]Point{Point{0, 1}, Point{1, 2}}}
map[string]Point{"orig": {0, 0}}    // 同 map[string]Point{"orig": Point{0, 0}}
map[Point]string{{0, 0}: "orig"}    // 同 map[Point]string{Point{0, 0}: "orig"}

type PPoint *Point
[2]*Point{{1.5, -3.5}, {}}          // 同 [2]*Point{&Point{1.5, -3.5}, &Point{}}
[2]PPoint{{1.5, -3.5}, {}}          // 同 [2]PPoint{PPoint(&Point{1.5, -3.5}), PPoint(&Point{})}

1
2

if x == (T{a,b,c}[i]) { … }
if (x == T{a,b,c}[i]) { … }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 质数列表
primes := []int{2, 3, 5, 7, 9, 2147483647}

// 当 ch 为元音时 vowels[ch] 为真
vowels := [128]bool{'a': true, 'e': true, 'i': true, 'o': true, 'u': true, 'y': true}

// 数组 [10]float32{-1, 0, 0, 0, -0.1, -0.1, 0, 0, 0, -1}
filter := [10]float32{-1, 4: -0.1, -0.1, 9: -1}

// 十二平均律以 Hz 为单位的频率（A4 = 440Hz）
noteFrequency := map[string]float32{
  "C0": 16.35, "D0": 18.35, "E0": 20.60, "F0": 21.83,
  "G0": 24.50, "A0": 27.50, "B0": 30.87,
}

1
2

FunctionLit = "func", Signature, FunctionBody .
func(a, b int, z float64) bool { return a*b < int(z) }

1
2
3
4

f := func(x, y int) int { return x + y }
func(ch chan int) { ch <- ACK }(replyChan)

// 译注： (replayChan) https://stackoverflow.com/questions/16008604/why-add-after-closure-body-in-golang

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

PrimaryExpr =
  Operand |
  Conversion |
  MethodExpr |
  PrimaryExpr, Selector |
  PrimaryExpr, Index |
  PrimaryExpr, Slice |
  PrimaryExpr, TypeAssertion |
  PrimaryExpr, Arguments .

Selector       = ".", identifier .
Index          = "[", Expression, "]" .
Slice          = "[", [ Expression ], ":", [ Expression ], "]" |
                 "[", [ Expression ], ":", Expression, ":", Expression, "]" .
TypeAssertion  = ".", "(", Type, ")" .
Arguments      = "(", [ ( ExpressionList | Type, [ ",", ExpressionList ] ), [ "..." ], [ "," ] ], ")" .
x
2
(s + ".txt")
f(3.1415, true)
Point{1, 2}
m["foo"]
s[i : j + 1]
obj.color
f.p[i].x()

1

x.f

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

type T0 struct {
  x int
}

func (*T0) M0()

type T1 struct {
  y int
}

func (T1) M1()

type T2 struct {
  z int
  T1
  *T0
}

func (*T2) M2()

type Q *T2

var t T2     // 假定 t.T0 != nil
var p *T2    // 假定 p != nil 并且 (*p).T0 != nil
var q Q = p

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

t.z          // t.z
t.y          // t.T1.y
t.x          // (*t.T0).x

p.z          // (*p).z
p.y          // (*p).T1.y
p.x          // (*(*p).T0).x

q.x          // (*(*q).T0).x        (*q).x 是一个有效的字段选择器

p.M0()       // ((*p).T0).M0()      M0 期望接收器 *T0
p.M1()       // ((*p).T1).M1()      M1 期望接收器 T1
p.M2()       // p.M2()              M2 期望接收器 *T2
t.M2()       // (&t).M2()           M2 期望接收器 *T2，查看调用一节

1

q.M0()       // (*q).M0 是有效的，但不是字段选择器

1
2

MethodExpr    = ReceiverType, ".", MethodName .
ReceiverType  = Type .

1
2
3
4
5
6
7

type T struct {
  a int
}
func (tv  T) Mv(a int) int         { return 0 }  // 值接收器
func (tp *T) Mp(f float32) float32 { return 1 }  // 指针接收器

var t T

1

T.Mv

1

func(tv T, a int) int

1
2
3
4
5

t.Mv(7)
T.Mv(t, 7)
(T).Mv(t, 7)
f1 := T.Mv; f1(t, 7)
f2 := (T).Mv; f2(t, 7)

1

(*T).Mp

1

func(tp *T, f float32) float32

1

(*T).Mv

1

func(tv *T, a int) int

1
2
3
4
5
6
7
8
9

type S struct { *T }
type T int
func (t T) M() { print(t) }

t := new(T)
s := S{T: t}
f := t.M                    // 接收器 *t 被求值并存储进 f
g := s.M                    // 接收器 *(s.T) 被求值并存储进 g
*t = 42                     // 不会影响在 f 和 g 内存储的接收器

1
2
3
4
5
6
7
8
9

type T struct {
  a int
}
func (tv  T) Mv(a int) int         { return 0 }  // 值接收器
func (tp *T) Mp(f float32) float32 { return 1 }  // 指针接收器

var t T
var pt *T
func makeT() T

1

t.Mv

1

func(int) int

1
2

t.Mv(7)
f := t.Mv; f(7)

1

pt.Mp

1

func(float32) float32

1
2
3
4
5

f := t.Mv; f(7)   // 就像 t.Mv(7)
f := pt.Mp; f(7)  // 就像 pt.Mp(7)
f := pt.Mv; f(7)  // 就像 (*pt).Mv(7)
f := t.Mp; f(7)   // 就像 (&t).Mp(7)
f := makeT().Mp   // 无效的: makeT() 的结果是不可寻址的

1
2

var i interface { M(int) } = myVal
f := i.M; f(7)  // 就像 i.M(7)

1

a[x]

1
2
3

v, ok = a[x]
v, ok := a[x]
var v, ok = a[x]

1

a[low : high]

1
2

a := [5]int{1, 2, 3, 4, 5}
s := a[1:4]

1
2
3

s[0] == 2
s[1] == 3
s[2] == 4