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
}

​```
每個明確指定方法的名稱必須是[唯一](/cn/docs/spec#Uniqueness_of_identifiers)的且非[空白](/cn/docs/spec#Blank_identifier)。

```go
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 .

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)
f := 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[2:]  // 等價於 a[2 : len(a)]
a[:3]  // 等價於 a[0 : 3]
a[:]   // 等價於 a[0 : len(a)]

var a [10]int
s1 := a[3:7]   // s1 的底層陣列是陣列 a; &s1[2] == &a[5]
s2 := s1[1:4]  // s2 的底層陣列是 s1 的底層陣列即陣列 a; &s2[1] == &a[5]
s2[1] = 42     // s2[1] == s1[2] == a[5] == 42; 它們都引用同一底層陣列元素

var s []int
s3 := s[:0]    // s3 == nil

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