Go编程语言规范#

语法        = { 产生式 } .
产生式      = 产生式名称 "=" [ 表达式 ] "." .
表达式      = 项 { "|" 项 } .
项          = 因子 { 因子 } .
因子        = 产生式名称 | 标记 [ "…" 标记 ] | 组 | 选项 | 重复 .
组          = "(" 表达式 ")" .
选项        = "[" 表达式 "]" .
重复        = "{" 表达式 "}" .

|   选择
()  分组
[]  可选(0或1次)
{}  重复(0到n次)

换行符        = /* Unicode码点U+000A */ .
unicode_char   = /* 除换行符外的任意Unicode码点 */ .
unicode_letter = /* 分类为"字母"的Unicode码点 */ .
unicode_digit  = /* 分类为"数字,十进制数字"的Unicode码点 */ .

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

identifier = letter { letter | unicode_digit } .

a
_x9
ThisVariableIsExported
αβ

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

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

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  // 无效：_必须分隔连续数字

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     // 无效：十六进制尾数需要p指数
1_.5         // 无效：_必须分隔连续数字
1._5         // 无效：_必须分隔连续数字
1.5_e1       // 无效：_必须分隔连续数字
1.5e_1       // 无效：_必须分隔连续数字
1.5e1_       // 无效：_必须分隔连续数字

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

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

\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 双引号 (仅在字符串字面量中有效的转义)

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'         // 非法：字符太多
'\k'         // 非法：k在反斜杠后未被识别
'\xa'        // 非法：十六进制数字太少
'\0'         // 非法：八进制数字太少
'\400'       // 非法：八进制值超过255
'\uDFFF'     // 非法：代理半部分
'\U00110000' // 非法：无效Unicode码点

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码点

"日本語"                                 // UTF-8输入文本
`日本語`                                 // UTF-8输入文本作为原始字面量
"\u65e5\u672c\u8a9e"                    // 显式Unicode码点
"\U000065e5\U0000672c\U00008a9e"        // 显式Unicode码点
"\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"  // 显式UTF-8字节

var x interface{}  // x为nil，静态类型为interface{}
var v *T           // v值为nil，静态类型为*T
x = 42             // x值为42，动态类型为int
x = v              // x值为(*T)(nil)，动态类型为*T

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

uint8       所有无符号8位整数集合 (0 to 255)
uint16      所有无符号16位整数集合 (0 to 65535)
uint32      所有无符号32位整数集合 (0 to 4294967295)
uint64      所有无符号64位整数集合 (0 to 18446744073709551615)

int8        所有带符号8位整数集合 (-128 to 127)
int16       所有带符号16位整数集合 (-32768 to 32767)
int32       所有带符号32位整数集合 (-2147483648 to 2147483647)
int64       所有带符号64位整数集合 (-9223372036854775808 to 9223372036854775807)

float32     所有IEEE 754 32位浮点数字集合
float64     所有IEEE 754 64位浮点数字集合

complex64   所有实部和虚部为float32的复数集合
complex128  所有实部和虚部为float64的复数集合

byte        uint8的别名
rune        int32的别名

uint     32或64位
int      与uint相同大小
uintptr  足够大的无符号整数，用于存储指针值的未解释位

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

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

// 无效数组类型
type (
T1 [10]T1                 // T1的元素类型是T1
T2 [10]struct{ f T2 }     // T2包含T2作为结构体的组件
T3 [10]T4                 // T3包含T3作为T4中结构体的组件
T4 struct{ f T3 }         // T4包含T4作为数组T3中结构体的组件
)

// 有效数组类型
type (
T5 [10]*T5                // T5包含T5作为指针的组件
T6 [10]func() T6          // T6包含T6作为函数类型的组件
T7 [10]struct{ f []T7 }   // T7包含T7作为结构体中切片的组件
)

SliceType = "[" "]" ElementType .

make([]T, length, capacity)

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

StructType    = "struct" "{" { FieldDecl ";" } "}" .
FieldDecl     = (IdentifierList Type | EmbeddedField) [ Tag ] .
EmbeddedField = [ "*" ] TypeName [ TypeArgs ] .
Tag           = string_lit .

// 空结构体。
struct {}

// 有6个字段的结构体。
struct {
x, y int
u float32
_ float32  // 填充
A *[]int
F func()
}

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

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

struct {
x, y float64 ""  // 空标签字符串像不存在的标签
name string  "任何字符串都允许作为标签"
_    [4]byte "这不是结构体字段"
}

// 对应TimeStamp协议缓冲区的结构体。
// 标签字符串定义协议缓冲区字段号；
// 它们遵循reflect包概述的约定。
struct {
microsec  uint64 `protobuf:"1"`
serverIP6 uint64 `protobuf:"2"`
}

// 无效结构体类型
type (
T1 struct{ T1 }            // T1包含T1的字段
T2 struct{ f [10]T2 }      // T2包含T2作为数组的组件
T3 struct{ T4 }            // T3包含T3作为T4中数组的组件
T4 struct{ f [10]T3 }      // T4包含T4作为T3在数组中的组件
)

// 有效结构体类型
type (
T5 struct{ f *T5 }         // T5包含T5作为指针的组件
T6 struct{ f func() T6 }   // T6包含T6作为函数类型的组件
T7 struct{ f [10][]T7 }    // T7包含T7作为数组中切片的组件
)

PointerType = "*" BaseType .
BaseType    = Type .

*Point
*[4]int

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

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)

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

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

interface {
String() string
String() string  // 非法：String不唯一
_(x int)         // 非法：方法必须有非空白名称
}

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

interface{}

type Locker interface {
Lock()
Unlock()
}

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

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的方法
}

type ReadCloser interface {
Reader   // includes methods of Reader in ReadCloser's method set
Close()  // illegal: signatures of Reader.Close and Close are different
}

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

// 表示所有潜在类型为int的类型的接口。
interface {
~int
}

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

// 表示空类型集的接口：没有类型同时是int和string。
interface {
int
string
}

type MyInt int

interface {
~[]byte  // []byte的潜在类型是它本身
~MyInt   // 非法：MyInt的潜在类型不是MyInt
~error   // 非法：error是接口
}

// Float接口表示所有浮点类型
// (包括任何其潜在类型是float32或float64的命名类型)。
type Float interface {
~float32 | ~float64
}

interface {
P                // 非法：P是类型参数
int | ~P         // 非法：P是类型参数
~int | MyInt     // 非法：~int和MyInt的类型集不相交(~int包括MyInt)
float32 | Float  // 类型集重叠但Float是接口
}

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

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

type Floatish struct {
f Float                 // 非法
}

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

// 非法：Bad1不能使用Bad2嵌入自己
type Bad1 interface {
Bad2
}
type Bad2 interface {
Bad1
}

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

// 非法：Bad4不能包含以Bad4为元素类型的数组
type Bad4 interface {
[10]Bad4
}

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

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

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

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

chan T          // 可用于发送和接收类型T的值
chan<- float64  // 只能用于发送float64
<-chan int      // 只能用于接收ints

chan<- chan int    // 与chan<- (chan int)相同
chan<- <-chan int  // 与chan<- (<-chan int)相同
<-chan <-chan int  // 与<-chan (<-chan int)相同
chan (<-chan int)

make(chan int, 100)

type (
A1 = string
A2 = A1
)

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

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

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

x                   T           x可由T类型的值表示，因为

'a'                 byte        97在字节值集合中
97                  rune        rune是int32的别名，且97在32位整数集合中
"foo"               string      "foo"在字符串值集合中
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不在布尔值集合中
'a'                 string      'a'是rune，它不在字符串值集合中
1024                byte        1024不在无符号8位整数集合中
-1                  uint16      -1不在无符号16位整数集合中
1.1                 int         1.1不是整数值
42i                 float32     (0 + 42i)不在float32值集合中
1e1000              float64     1e1000在舍入后溢出到IEEE +Inf

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

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

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 clear close complex copy delete imag len
make max min new panic print println real recover

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

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

const (
Sunday = iota
Monday
Tuesday
Wednesday
Thursday
Friday
Partyday
numberOfDays  // 此常量未导出
)

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, unused)
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

const (
bit0, mask0 = 1 << iota, 1<<iota - 1  // bit0 == 1, mask0 == 0  (iota == 0)
bit1, mask1                           // bit1 == 2, mask1 == 1  (iota == 1)
_, _                                  //                        (iota == 2, unused)
bit3, mask3                           // bit3 == 8, mask3 == 7  (iota == 3)
)

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

AliasDecl = identifier [ TypeParameters ] "=" Type .

type (
nodeList = []*Node  // nodeList和[]*Node是相同类型
Polar    = polar    // Polar和polar表示相同类型
)

type set[P comparable] = map[P]bool

type A[P any] = P    // 非法：P是类型参数

TypeDef = identifier [ TypeParameters ] Type .

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

// Mutex是一个具有Lock和Unlock两种方法的数据类型。
type Mutex struct         { /* Mutex字段 */ }
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

type TimeZone int

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

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

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

type T[P any] P    // 非法：P是类型参数

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

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

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

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

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

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

type T1[P T1[P]] …                    // 非法：T1引用自身
type T2[P interface{ T2[int] }] …     // 非法：T2引用自身
type T3[P interface{ m(T3[int])}] …   // 非法：T3引用自身
type T4[P T5[P]] …                    // 非法：T4引用T5且
type T5[P T4[P]] …                    //          T5引用T4

type T6[P int] struct{ f *T6[P] }     // 合法：对T6的引用不在类型参数列表中

TypeConstraint = TypeElem .

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

int                          // 实现 comparable (int 是严格可比较的)
[]byte                       // 不实现 comparable (切片不可比较)
interface{}                  // 不实现 comparable (见上文)
interface{ ~int | ~string }  // 仅类型参数: 实现 comparable (int, string 类型是严格可比较的)
interface{ comparable }      // 仅类型参数: 实现 comparable (comparable 实现自身)
interface{ ~int | ~[]byte }  // 仅类型参数: 不实现 comparable (切片不可比较)
interface{ ~struct{ any } }  // 仅类型参数: 不实现 comparable (字段 any 不是严格可比较的)

类型参数           类型约束                        // 约束满足

int                interface{ ~int }              // 满足: int 实现 interface{ ~int }
string             comparable                     // 满足: string 实现 comparable (string 是严格可比较的)
[]byte             comparable                     // 不满足: 切片不可比较
any                interface{ comparable; int }   // 不满足: any 不实现 interface{ int }
any                comparable                     // 满足: any 是可比较的并实现基本接口 any
struct{f any}      comparable                     // 满足: struct{f any} 是可比较的并实现基本接口 any
any                interface{ comparable; m() }   // 不满足: any 不实现基本接口 interface{ m() }
interface{ m() }   interface{ comparable; m() }   // 满足: interface{ m() } 是可比较的并实现基本接口 interface{ m() }

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"

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            // 非法

ShortVarDecl = IdentifierList ":=" ExpressionList .

"var" IdentifierList "=" ExpressionList .

i, j := 0, 10
f := func() int { return 7 }
ch := make(chan int)
r, w, _ := os.Pipe()  // os.Pipe() 返回一对已连接的文件和一个错误（如果有）
_, y, _ := coord(p)   // coord() 返回三个值；只关心 y 坐标

field1, offset := nextField(str, 0)
field2, offset := nextField(str, offset)  // 重新声明 offset
x, y, x := 1, 2, 3                        // 非法: x 在 := 左侧重复

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

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

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

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

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

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
}

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

type GPoint[P any] = Point
type HPoint        = *GPoint[int]
type IPair         = Pair[int, int]

func (*GPoint[P]) Draw(P)   { … }  // 非法: 别名不能是泛型的
func (HPoint) Draw(P)       { … }  // 非法: 别名不能表示已实例化的类型 GPoint[int]
func (*IPair) Second() int  { … }  // 非法: 别名不能表示已实例化的类型 Pair[int, int]

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

QualifiedIdent = PackageName "." identifier .

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

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

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

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

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

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

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

[]T{x1, x2, … xn}

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

[...]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{})}

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

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

// vowels[ch] 在 ch 是元音时为 true
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}

// 等音阶频率（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,
}

FunctionLit = "func" Signature FunctionBody .

func(a, b int, z float64) bool { return a*b < int(z) }

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

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

x.f

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

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 接收者，参见调用部分

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

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

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

T.Mv

func(tv T, a int) int

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

(*T).Mp

func(tp *T, f float32) float32

(*T).Mv

func(tv *T, a int) int

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 中存储的接收者

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

t.Mv

func(int) int

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

pt.Mp

func(float32) float32

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() 的结果不可寻址

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

a[x]

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

a[low : high]

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

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

a[low : high : max]

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

t[0] == 2
t[1] == 3

x.(T)

var x interface{} = 7          // x 具有动态类型 int 和值 7
i := x.(int)                   // i 具有类型 int 和值 7

type I interface { m() }

func f(y I) {
s := y.(string)        // 非法: string 未实现 I（缺少方法 m）
r := y.(io.Reader)     // r 具有类型 io.Reader 且 y 的动态类型必须同时实现 I 和 io.Reader
…
}

v, ok = x.(T)
v, ok := x.(T)
var v, ok = x.(T)
var v, ok interface{} = x.(T) // v 和 ok 的动态类型分别是 T 和 bool

f(a1, a2, … an)

math.Atan2(x, y)  // 函数调用
var pt *Point
pt.Scale(3.5)     // 使用接收者 pt 的方法调用

func Split(s string, pos int) (string, string) {
return s[0:pos], s[pos:]
}

func Join(s, t string) string {
return s + t
}

if Join(Split(value, len(value)/2)) != value {
log.Panic("test fails")
}

var p Point
p.Sale(3.5)

func Greeting(prefix string, who ...string)
Greeting("nobody")
Greeting("hello:", "Joe", "Anna", "Eileen")

s := []string{"James", "Jasmine"}
Greeting("goodbye:", s...)

类型参数列表        类型实参        替换后

[P any]            int            int 满足 any
[S ~[]E, E any]    []int, int     []int 满足 ~[]int, int 满足 any
[P io.Writer]      string         非法: string 不满足 io.Writer
[P comparable]     any            any 满足 (但不实现) comparable

// sum 返回参数的和（字符串则为连接）
func sum[T ~int | ~float64 | ~string](x... T) T { … }

x := sum                       // 非法: x 的类型未知
intSum := sum[int]             // intSum 类型为 func(x... int) int
a := intSum(2, 3)              // a 值为 5，类型为 int
b := sum[float64](2.0, 3)      // b 值为 5.0，类型为 float64
c := sum(b, -1)                // c 值为 4.0，类型为 float64

type sumFunc func(x... string) string
var f sumFunc = sum            // 同 var f sumFunc = sum[string]
f = sum                        // 同 f = sum[string]

func apply[S ~[]E, E any](s S, f func(E) E) S { … }

f0 := apply[]                  // 非法: 类型实参列表不能为空
f1 := apply[[]int]             // S 的类型实参显式提供，E 的类型实参推断
f2 := apply[[]string, string]  // 两个类型实参均显式提供

var bytes []byte
r := apply(bytes, func(byte) byte { … })  // 两个类型实参从函数参数推断

// dedup 返回参数切片的副本，删除任何重复条目
func dedup[S ~[]E, E comparable](S) S { … }

type Slice []int
var s Slice
s = dedup(s)   // 同 s = dedup[Slice, int](s)

Slice ≡A S      (1)
S     ≡C ~[]E   (2)

S ➞ Slice
E ➞ int

Pk ➞ Ak

[10]struct{ elem P, list []P } ≡A [10]struct{ elem string; list []string }

Expression = UnaryExpr | Expression binary_op Expression .
UnaryExpr  = PrimaryExpr | unary_op UnaryExpr .

binary_op  = "||" | "&&" | rel_op | add_op | mul_op .
rel_op     = "==" | "!=" | "<" | "<=" | ">" | ">=" .
add_op     = "+" | "-" | "|" | "^" .
mul_op     = "*" | "/" | "%" | "<<" | ">>" | "&" | "&^" .

unary_op   = "+" | "-" | "!" | "^" | "*" | "&" | "<-" .

var a [1024]byte
var s uint = 33

// 以下示例的结果基于 64 位整数。
var i = 1<<s                   // 1 具有类型 int
var j int32 = 1<<s             // 1 具有类型 int32; j == 0
var k = uint64(1<<s)           // 1 具有类型 uint64; k == 1<<33
var m int = 1.0<<s             // 1.0 具有类型 int; m == 1<<33
var n = 1.0<<s == j            // 1.0 具有类型 int32; n == true
var o = 1<<s == 2<<s           // 1 和 2 具有类型 int; o == false
var p = 1<<s == 1<<33          // 1 具有类型 int; p == true
var u = 1.0<<s                 // 非法: 1.0 具有类型 float64，不能移位
var u1 = 1.0<<s != 0           // 非法: 1.0 具有类型 float64，不能移位
var u2 = 1<<s != 1.0           // 非法: 1 具有类型 float64，不能移位
var v1 float32 = 1<<s          // 非法: 1 具有类型 float32，不能移位
var v2 = string(1<<s)          // 非法: 1 转换为字符串，不能移位
var w int64 = 1.0<<33          // 1.0<<33 是常量移位表达式; w == 1<<33
var x = a[1.0<<s]              // panic: 1.0 具有类型 int，但 1<<33 溢出数组边界
var b = make([]byte, 1.0<<s)   // 1.0 具有类型 int; len(b) == 1<<33

// 以下示例的结果基于 32 位整数，
// 这意味着移位将溢出。
var mm int = 1.0<<s            // 1.0 具有类型 int; mm == 0
var oo = 1<<s == 2<<s          // 1 和 2 具有类型 int; oo == true
var pp = 1<<s == 1<<33         // 非法: 1 具有类型 int，但 1<<33 溢出 int
var xx = a[1.0<<s]             // 1.0 具有类型 int; xx == a[0]
var bb = make([]byte, 1.0<<s)  // 1.0 具有类型 int; len(bb) == 0

优先级    运算符
    5             *  /  %  <<  >>  &  &^
    4             +  -  |  ^
    3             ==  !=  <  <=  >  >=
    2             &&
    1             ||

+x                         // x
42 + a - b                 // (42 + a) - b
23 + 3*x[i]                // 23 + (3 * x[i])
x <= f()                   // x <= f()
^a >> b                    // (^a) >> b
f() || g()                 // f() || g()
x == y+1 && <-chanInt > 0  // (x == (y+1)) && ((<-chanInt) > 0)

+    和                     整数、浮点数、复数、字符串
-    差                     整数、浮点数、复数
*    积                     整数、浮点数、复数
/    商                     整数、浮点数、复数
%    余数                   整数

&    位与                   整数
|    位或                   整数
^    位异或                 整数
&^   位清除（与非）         整数

<<   左移                   整数 << 整数 >= 0
>>   右移                   整数 >> 整数 >= 0

func dotProduct[F ~float32|~float64](v1, v2 []F) F {
var s F
for i, x := range v1 {
y := v2[i]
s += x * y
}
return s
}

x = q*y + r  且  |r| < |y|

 x     y     x / y     x % y
 5     3       1         2
-5     3      -1        -2
 5    -3      -1         2
-5    -3       1        -2

                         x, q
int8                     -128
int16                  -32768
int32             -2147483648
int64    -9223372036854775808

 x     x / 4     x % 4     x >> 2     x & 3
 11      2         3         2          3
-11     -2        -3        -3          1

+x                          是 0 + x
-x    取负                  是 0 - x
^x    位补码                是 m ^ x，其中 m = "全位设为 1"（无符号 x）
                                      且 m = -1（有符号 x）

// 允许 FMA 计算 r，因为 x*y 未显式舍入：
r  = x*y + z
r  = z;   r += x*y
t  = x*y; r = t + z
*p = x*y; r = *p + z
r  = x*y + float64(z)

// 禁止 FMA 计算 r，因为它会省略 x*y 的舍入：
r  = float64(x*y) + z
r  = z; r += float64(x*y)
t  = float64(x*y); r = t + z

s := "hi" + string(c)
s += " and good bye"

==    等于
!=    不等于
<     小于
<=    小于或等于
>     大于
>=    大于或等于

const c = 3 < 4            // c 是无类型布尔常量 true

type MyBool bool
var x, y int
var (
// 比较结果是布尔值。
// 适用通常赋值规则。
b3        = x == y // b3 具有类型 bool
b4 bool   = x == y // b4 具有类型 bool
b5 MyBool = x == y // b5 具有类型 MyBool
)

&&    条件与    p && q  是  "如果 p 则 q 否则 false"
||    条件或    p || q  是  "如果 p 则 true 否则 q"
!     非        !p      是  "非 p"

&x
&a[f(2)]
&Point{2, 3}
*p
*pf(x)

var x *int = nil
*x   // 导致运行时恐慌
&*x  // 导致运行时恐慌

v1 := <-ch
v2 = <-ch
f(<-ch)
<-strobe  // 等待时钟脉冲并丢弃接收的值

x, ok = <-ch
x, ok := <-ch
var x, ok = <-ch
var x, ok T = <-ch