Go 语言规范学习（6）

Statements

Statements control execution.

Statement  = Declaration | LabeledStmt | SimpleStmt |GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |DeferStmt .SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt | Assignment | ShortVarDecl .

Terminating statements

A terminating statement interrupts the regular flow of control in a block. The following statements are terminating:

1. ​ A “return” or “goto” statement.

2. ​ A call to the built-in function panic.

3. ​ A block in which the statement list ends in a terminating statement. 【如果一个代码块的最后一条语句是终止语句，那么整个代码块也是终止的。】

4. ​ An “if” statement in which:

   • the “else” branch is present, and
   • both branches are terminating statements.

   如果 if 带有 else 分支，并且两个分支都是终止语句，则整个 if 是终止的。

5. ​ A “for” statement in which:

   • there are no “break” statements referring to the “for” statement, and
   • the loop condition is absent, and
   • the “for” statement does not use a range clause.

   如果 for 没有条件（即 for {}）、没有 range 子句，并且内部没有 break 跳出循环，那么它是一个终止语句（因为会无限循环，不会继续执行后续代码）。

6. ​ A “switch” statement in which:

   • there are no “break” statements referring to the “switch” statement,
   • there is a default case, and
   • the statement lists in each case, including the default, end in a terminating statement, or a possibly labeled “fallthrough” statement.

   如果 switch 满足：

   • 没有 break 跳出 switch，
   • 有 default 分支，
   • 每个 case（包括 default）的语句列表以终止语句或 fallthrough 结尾，

   则整个 switch 是终止的。

7. ​ A

   “select” statement in which:

   • there are no “break” statements referring to the “select” statement, and
   • the statement lists in each case, including the default if present, end in a terminating statement.

   如果 select 满足：

   • 没有 break 跳出 select，
   • 每个 case（包括 default，如果有）的语句列表以终止语句结尾，

   则整个 select 是终止的。

8. ​ A labeled statement labeling a terminating statement.

All other statements are not terminating.

A statement list ends in a terminating statement if the list is not empty and its final non-empty statement is terminating.

Empty statements

The empty statement does nothing.

EmptyStmt = .

Labeled statements

A labeled statement may be the target of a goto, break or continue statement.

LabeledStmt = Label ":" Statement .
Label       = identifier .
Error: log.Panic("error encountered")

Expression statements

With the exception of specific built-in functions, function and method calls and receive operations can appear in statement context. Such statements may be parenthesized.

ExpressionStmt = Expression .

The following built-in functions are not permitted in statement context:

append cap complex imag len make new real
unsafe.Add unsafe.Alignof unsafe.Offsetof unsafe.Sizeof unsafe.Slice unsafe.SliceData unsafe.String unsafe.StringData

h(x+y)
f.Close()
<-ch
(<-ch)
len("foo")  // illegal if len is the built-in function

Send statements

A send statement sends a value on a channel. The channel expression’s core type must be a channel, the channel direction must permit send operations, and the type of the value to be sent must be assignable to the channel’s element type.

SendStmt = Channel "<-" Expression .
Channel  = Expression .

Both the channel and the value expression are evaluated before communication begins. Communication blocks until the send can proceed. A send on an unbuffered channel can proceed if a receiver is ready. A send on a buffered channel can proceed if there is room in the buffer. A send on a closed channel proceeds by causing a run-time panic. A send on a nil channel blocks forever.

ch <- 3  // send value 3 to channel ch

IncDec statements

The “++” and “–” statements increment or decrement their operands by the untyped constant 1. As with an assignment, the operand must be addressable or a map index expression.

IncDecStmt = Expression ( "++" | "--" ) .

The following assignment statements are semantically equivalent:

IncDec statement    Assignment
x++                 x += 1
x--                 x -= 1

Assignment statements

An assignment replaces the current value stored in a variable with a new value specified by an expression. An assignment statement may assign a single value to a single variable, or multiple values to a matching number of variables.

Assignment = ExpressionList assign_op ExpressionList .assign_op  = [ add_op | mul_op ] "=" .

Each left-hand side operand must be addressable, a map index expression, or (for = assignments only) the blank identifier. Operands may be parenthesized.

x = 1
*p = f()
a[i] = 23
(k) = <-ch  // same as: k = <-ch

An assignment operation x op= y where op is a binary arithmetic operator is equivalent to x = x op (y) but evaluates x only once.【只求值一次】 The op= construct is a single token. In assignment operations, both the left- and right-hand expression lists must contain exactly one single-valued expression, and the left-hand expression must not be the blank identifier.

a[i] <<= 2
i &^= 1<<n

A tuple assignment assigns the individual elements of a multi-valued operation to a list of variables. There are two forms. In the first, the right hand operand is a single multi-valued expression such as a function call, a channel or map operation, or a type assertion. The number of operands on the left hand side must match the number of values. For instance, if f is a function returning two values,

x, y = f()

assigns the first value to x and the second to y.

In the second form, the number of operands on the left must equal the number of expressions on the right, each of which must be single-valued, and the nth expression on the right is assigned to the nth operand on the left:

one, two, three = '一', '二', '三'

The blank identifier provides a way to ignore right-hand side values in an assignment:

_ = x       // evaluate x but ignore it
x, _ = f()  // evaluate f() but ignore second result value

The assignment proceeds in two phases. First, the operands of index expressions and pointer indirections (including implicit pointer indirections in selectors) on the left and the expressions on the right are all evaluated in the usual order. Second, the assignments are carried out in left-to-right order.

赋值操作分为两个阶段进行：

1. 第一阶段（求值阶段）：
   • 首先，对左侧的索引表达式（index expressions）、指针解引用（pointer indirections）（包括选择器中的隐式指针解引用）以及右侧的所有表达式，按照常规顺序进行求值。
2. 第二阶段（赋值阶段）：
   • 然后，按照从左到右的顺序执行实际的赋值操作。

a, b = b, a  // exchange a and bx := []int{1, 2, 3}
i := 0
i, x[i] = 1, 2  // set i = 1, x[0] = 2i = 0
x[i], i = 2, 1  // set x[0] = 2, i = 1x[0], x[0] = 1, 2  // set x[0] = 1, then x[0] = 2 (so x[0] == 2 at end)x[1], x[3] = 4, 5  // set x[1] = 4, then panic setting x[3] = 5.type Point struct { x, y int }
var p *Point
x[2], p.x = 6, 7  // set x[2] = 6, then panic setting p.x = 7。p.x 需要解引用 p，但 p 是 nil，此时不会 panic（因为只是计算地址，尚未赋值）。i = 2
x = []int{3, 5, 7}
for i, x[i] = range x {  // set i, x[2] = 0, x[0]break
}
// after this loop, i == 0 and x is []int{3, 5, 3}

In assignments, each value must be assignable to the type of the operand to which it is assigned, with the following special cases:

1. ​ Any typed value may be assigned to the blank identifier.
2. ​ If an untyped constant is assigned to a variable of interface type or the blank identifier, the constant is first implicitly converted to its default type.
3. ​ If an untyped boolean value is assigned to a variable of interface type or the blank identifier, it is first implicitly converted to type bool.

When a value is assigned to a variable, only the data that is stored in the variable is replaced. If the value contains a reference, the assignment copies the reference but does not make a copy of the referenced data (such as the underlying array of a slice).

var s1 = []int{1, 2, 3}
var s2 = s1                    // s2 stores the slice descriptor of s1
s1 = s1[:1]                    // s1's length is 1 but it still shares its underlying array with s2
s2[0] = 42                     // setting s2[0] changes s1[0] as well
fmt.Println(s1, s2)            // prints [42] [42 2 3]var m1 = make(map[string]int)
var m2 = m1                    // m2 stores the map descriptor of m1
m1["foo"] = 42                 // setting m1["foo"] changes m2["foo"] as well
fmt.Println(m2["foo"])         // prints 42

If statements

“If” statements specify the conditional execution of two branches according to the value of a boolean expression. If the expression evaluates to true, the “if” branch is executed, otherwise, if present, the “else” branch is executed.

IfStmt = "if" [ SimpleStmt ";" ] Expression Block [ "else" ( IfStmt | Block ) ] .
if x > max {x = max
}

The expression may be preceded by a simple statement, which executes before the expression is evaluated.

if x := f(); x < y {return x
} else if x > z {return z
} else {return y
}

Switch statements

“Switch” statements provide multi-way execution. An expression or type is compared to the “cases” inside the “switch” to determine which branch to execute.

SwitchStmt = ExprSwitchStmt | TypeSwitchStmt .

There are two forms: expression switches and type switches. In an expression switch, the cases contain expressions that are compared against the value of the switch expression. In a type switch, the cases contain types that are compared against the type of a specially annotated switch expression. The switch expression is evaluated exactly once in a switch statement.

Expression switches

In an expression switch, the switch expression is evaluated and the case expressions, which need not be constants, are evaluated left-to-right and top-to-bottom; the first one that equals the switch expression triggers execution of the statements of the associated case; the other cases are skipped. If no case matches and there is a “default” case, its statements are executed. There can be at most one default case and it may appear anywhere in the “switch” statement. A missing switch expression is equivalent to the boolean value true.

ExprSwitchStmt = "switch" [ SimpleStmt ";" ] [ Expression ] "{" { ExprCaseClause } "}" .
ExprCaseClause = ExprSwitchCase ":" StatementList .
ExprSwitchCase = "case" ExpressionList | "default" .

If the switch expression evaluates to an untyped constant, it is first implicitly converted to its default type. The predeclared untyped value nil cannot be used as a switch expression. The switch expression type must be comparable.

If a case expression is untyped, it is first implicitly converted to the type of the switch expression. For each (possibly converted) case expression x and the value t of the switch expression, x == t must be a valid comparison.

In other words, the switch expression is treated as if it were used to declare and initialize a temporary variable t without explicit type; it is that value of t against which each case expression x is tested for equality.

In a case or default clause, the last non-empty statement may be a (possibly labeled) “fallthrough” statement to indicate that control should flow from the end of this clause to the first statement of the next clause. Otherwise control flows to the end of the “switch” statement. A “fallthrough” statement may appear as the last statement of all but the last clause of an expression switch.

在 Go 语言的 switch 语句中：

• case 或 default 子句的最后一个非空语句可以是一个（可能带标签的）fallthrough 语句，表示控制流应从当前子句末尾跳转到下一个子句的开头。
• 如果没有 fallthrough，控制流会直接退出整个 switch 语句。
• fallthrough 只能出现在表达式 switch（非类型 switch）中，且不能是最后一个子句（否则无处可跳转）。

The switch expression may be preceded by a simple statement, which executes before the expression is evaluated.

switch tag {
default: s3()
case 0, 1, 2, 3: s1()
case 4, 5, 6, 7: s2()
}switch x := f(); {  // missing switch expression means "true"
case x < 0: return -x
default: return x
}switch {
case x < y: f1()
case x < z: f2()
case x == 4: f3()
}

Implementation restriction: A compiler may disallow multiple case expressions evaluating to the same constant. For instance, the current compilers disallow duplicate integer, floating point, or string constants in case expressions.

Type switches

A type switch compares types rather than values. It is otherwise similar to an expression switch. It is marked by a special switch expression that has the form of a type assertion using the keyword type rather than an actual type:

switch x.(type) {
// cases
}

Cases then match actual types T against the dynamic type of the expression x. As with type assertions, x must be of interface type, but not a type parameter, and each non-interface type T listed in a case must implement the type of x. The types listed in the cases of a type switch must all be different.

TypeSwitchStmt  = "switch" [ SimpleStmt ";" ] TypeSwitchGuard "{" { TypeCaseClause } "}" .
TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" .
TypeCaseClause  = TypeSwitchCase ":" StatementList .
TypeSwitchCase  = "case" TypeList | "default" .

The TypeSwitchGuard may include a short variable declaration. When that form is used, the variable is declared at the end of the TypeSwitchCase in the implicit block of each clause. In clauses with a case listing exactly one type, the variable has that type; otherwise, the variable has the type of the expression in the TypeSwitchGuard.

Instead of a type, a case may use the predeclared identifier nil; that case is selected when the expression in the TypeSwitchGuard is a nil interface value. There may be at most one nil case.

Given an expression x of type interface{}, the following type switch:

switch i := x.(type) {
case nil:printString("x is nil")                // type of i is type of x (interface{})
case int:printInt(i)                            // type of i is int
case float64:printFloat64(i)                        // type of i is float64
case func(int) float64:printFunction(i)                       // type of i is func(int) float64
case bool, string:printString("type is bool or string")  // type of i is type of x (interface{})
default:printString("don't know the type")     // type of i is type of x (interface{})
}

could be rewritten:

v := x  // x is evaluated exactly once
if v == nil {i := v                                 // type of i is type of x (interface{})printString("x is nil")
} else if i, isInt := v.(int); isInt {printInt(i)                            // type of i is int
} else if i, isFloat64 := v.(float64); isFloat64 {printFloat64(i)                        // type of i is float64
} else if i, isFunc := v.(func(int) float64); isFunc {printFunction(i)                       // type of i is func(int) float64
} else {_, isBool := v.(bool)_, isString := v.(string)if isBool || isString {i := v                         // type of i is type of x (interface{})printString("type is bool or string")} else {i := v                         // type of i is type of x (interface{})printString("don't know the type")}
}

A type parameter or a generic type may be used as a type in a case. If upon instantiation that type turns out to duplicate another entry in the switch, the first matching case is chosen.

func f[P any](x any) int {switch x.(type) {case P:return 0case string:return 1case []P:return 2case []byte:return 3default:return 4}
}var v1 = f[string]("foo")   // v1 == 0
var v2 = f[byte]([]byte{})  // v2 == 2

The type switch guard may be preceded by a simple statement, which executes before the guard is evaluated.

The “fallthrough” statement is not permitted in a type switch.

For statements

A “for” statement specifies repeated execution of a block. There are three forms: The iteration may be controlled by a single condition, a “for” clause, or a “range” clause.

ForStmt   = "for" [ Condition | ForClause | RangeClause ] Block .
Condition = Expression .

For statements with single condition

In its simplest form, a “for” statement specifies the repeated execution of a block as long as a boolean condition evaluates to true. The condition is evaluated before each iteration. If the condition is absent, it is equivalent to the boolean value true.

for a < b {a *= 2
}

For statements with for clause

A “for” statement with a ForClause is also controlled by its condition, but additionally it may specify an init and a post statement, such as an assignment, an increment or decrement statement. The init statement may be a short variable declaration, but the post statement must not.

ForClause = [ InitStmt ] ";" [ Condition ] ";" [ PostStmt ] .
InitStmt  = SimpleStmt .
PostStmt  = SimpleStmt .

for i := 0; i < 10; i++ {f(i)
}

If non-empty, the init statement is executed once before evaluating the condition for the first iteration; the post statement is executed after each execution of the block (and only if the block was executed). Any element of the ForClause may be empty but the semicolons are required unless there is only a condition. If the condition is absent, it is equivalent to the boolean value true.

for cond { S() }    is the same as    for ; cond ; { S() }
for      { S() }    is the same as    for true     { S() }

Each iteration has its own separate declared variable (or variables) [Go 1.22]. The vargoiable used by the first iteration is declared by the init statement. The variable used by each subsequent iteration is declared implicitly before executing the post statement and initialized to the value of the previous iteration’s variable at that moment.

在 Go 1.22 及更高版本中，for 循环的每次迭代都会创建独立的变量实例（而非复用同一个变量）。具体规则：

1. 首次迭代：变量由 for 的 init 语句（如 i := 0）声明。
2. 后续迭代：
   • 在每次迭代的 post 语句（如 i++）执行前，隐式声明一个新变量。
   • 新变量的初始值为 前一次迭代变量在 post 语句执行前的值。

这种设计避免了循环闭包中的常见陷阱（如 goroutine 捕获循环变量问题），并更符合直觉。

var prints []func()
for i := 0; i < 5; i++ {prints = append(prints, func() { println(i) })i++
}
for _, p := range prints {p()
}

prints

1
3
5

注意：闭包捕获的是隐式声明的变量i。

Prior to [Go 1.22], iterations share one set of variables instead of having their own separate variables. In that case, the example above prints

6
6
6

For statements with range clause

A “for” statement with a “range” clause iterates through all entries of an array, slice, string or map, values received on a channel, integer values from zero to an upper limit [Go 1.22], or values passed to an iterator function’s yield function [Go 1.23]. For each entry it assigns iteration values to corresponding iteration variables if present and then executes the block.

RangeClause = [ ExpressionList "=" | IdentifierList ":=" ] "range" Expression .

The expression on the right in the “range” clause is called the range expression, its core type must be an array, pointer to an array, slice, string, map, channel permitting receive operations, an integer, or a function with specific signature (see below). As with an assignment, if present the operands on the left must be addressable or map index expressions; they denote the iteration variables. If the range expression is a function, the maximum number of iteration variables depends on the function signature. If the range expression is a channel or integer, at most one iteration variable is permitted; otherwise there may be up to two. If the last iteration variable is the blank identifier, the range clause is equivalent to the same clause without that identifier.

The range expression x is evaluated before beginning the loop, with one exception: if at most one iteration variable is present and x or len(x) is constant, the range expression is not evaluated.

---

• 如果满足以下两个条件，则 x 不会被提前求值：

  1. 最多只有一个迭代变量（如 for i := range x 或 for range x）。
  2. x 是常量，或者 len(x) 是常量（例如固定长度的数组）。

  示例 1：不提前求值

  const arr = [3]int{1, 2, 3} // 常量数组
  for i := range arr {         // 只有一个迭代变量，且 len(arr) 是常量fmt.Println(i)           // 输出 0, 1, 2
  }
  

  • 行为：arr 是常量，len(arr) 也是常量（3），因此 arr 不会被提前求值。
  • 意义：编译器会直接展开循环，无需运行时计算 arr。

  示例 2：提前求值

  slice := []int{1, 2, 3}
  for i, v := range slice {    // 两个迭代变量fmt.Println(i, v)
  }
  

  • 行为：slice 会在循环开始前被求值（即使 slice 在循环中被修改，循环次数仍由初始长度决定）。

---

Function calls on the left are evaluated once per iteration. For each iteration, iteration values are produced as follows if the respective iteration variables are present:

Range expression                                       1st value                2nd valuearray or slice      a  [n]E, *[n]E, or []E             index    i  int          a[i]       E
string              s  string type                     index    i  int          see below  rune
map                 m  map[K]V                         key      k  K            m[k]       V
channel             c  chan E, <-chan E                element  e  E
integer value       n  integer type, or untyped int    value    i  see below
function, 0 values  f  func(func() bool)
function, 1 value   f  func(func(V) bool)              value    v  V
function, 2 values  f  func(func(K, V) bool)           key      k  K            v          V

1. For an array, pointer to array, or slice value a, the index iteration values are produced in increasing order, starting at element index 0. If at most one iteration variable is present, the range loop produces iteration values from 0 up to len(a)-1 and does not index into the array or slice itself. For a nil slice, the number of iterations is 0.
2. For a string value, the “range” clause iterates over the Unicode code points in the string starting at byte index 0. On successive iterations, the index value will be the index of the first byte of successive UTF-8-encoded code points in the string, and the second value, of type rune, will be the value of the corresponding code point. If the iteration encounters an invalid UTF-8 sequence, the second value will be 0xFFFD, the Unicode replacement character, and the next iteration will advance a single byte in the string.
3. The iteration order over maps is not specified and is not guaranteed to be the same from one iteration to the next. If a map entry that has not yet been reached is removed during iteration, the corresponding iteration value will not be produced. If a map entry is created during iteration, that entry may be produced during the iteration or may be skipped. The choice may vary for each entry created and from one iteration to the next. If the map is nil, the number of iterations is 0.
4. For channels, the iteration values produced are the successive values sent on the channel until the channel is closed. If the channel is nil, the range expression blocks forever.
5. For an integer value n, where n is of integer type or an untyped integer constant, the iteration values 0 through n-1 are produced in increasing order. If n is of integer type, the iteration values have that same type. Otherwise, the type of n is determined as if it were assigned to the iteration variable. Specifically: if the iteration variable is preexisting, the type of the iteration values is the type of the iteration variable, which must be of integer type. Otherwise, if the iteration variable is declared by the “range” clause or is absent, the type of the iteration values is the default type for n. If n <= 0, the loop does not run any iterations.
6. For a function f, the iteration proceeds by calling f with a new, synthesized yield function as its argument. If yield is called before f returns, the arguments to yield become the iteration values for executing the loop body once. After each successive loop iteration, yield returns true and may be called again to continue the loop. As long as the loop body does not terminate, the “range” clause will continue to generate iteration values this way for each yield call until f returns. If the loop body terminates (such as by a break statement), yield returns false and must not be called again.

The iteration variables may be declared by the “range” clause using a form of short variable declaration (:=). In this case their scope is the block of the “for” statement and each iteration has its own new variables [Go 1.22] (see also “for” statements with a ForClause). The variables have the types of their respective iteration values.

If the iteration variables are not explicitly declared by the “range” clause, they must be preexisting. In this case, the iteration values are assigned to the respective variables as in an assignment statement.

var testdata *struct {a *[7]int
}
for i, _ := range testdata.a {// testdata.a is never evaluated; len(testdata.a) is constant// i ranges from 0 to 6f(i)
}var a [10]string
for i, s := range a {// type of i is int// type of s is string// s == a[i]g(i, s)
}var key string
var val interface{}  // element type of m is assignable to val
m := map[string]int{"mon":0, "tue":1, "wed":2, "thu":3, "fri":4, "sat":5, "sun":6}
for key, val = range m {h(key, val)
}
// key == last map key encountered in iteration
// val == map[key]var ch chan Work = producer()
for w := range ch {doWork(w)
}// empty a channel
for range ch {}// call f(0), f(1), ... f(9)
for i := range 10 {// type of i is int (default type for untyped constant 10)f(i)
}// invalid: 256 cannot be assigned to uint8
var u uint8
for u = range 256 {
}// invalid: 1e3 is a floating-point constant
for range 1e3 {
}// fibo generates the Fibonacci sequence
fibo := func(yield func(x int) bool) {f0, f1 := 0, 1for yield(f0) {f0, f1 = f1, f0+f1}
}// print the Fibonacci numbers below 1000:
for x := range fibo {if x >= 1000 {break}fmt.Printf("%d ", x)
}
// output: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987// iteration support for a recursive tree data structure
type Tree[K cmp.Ordered, V any] struct {left, right *Tree[K, V]key         Kvalue       V
}func (t *Tree[K, V]) walk(yield func(key K, val V) bool) bool {return t == nil || t.left.walk(yield) && yield(t.key, t.value) && t.right.walk(yield)
}func (t *Tree[K, V]) Walk(yield func(key K, val V) bool) {t.walk(yield)
}// walk tree t in-order
var t Tree[string, int]
for k, v := range t.Walk {// process k, v
}

Go statements

A “go” statement starts the execution of a function call as an independent concurrent thread of control, or goroutine, within the same address space.

GoStmt = "go" Expression .

The expression must be a function or method call; it cannot be parenthesized. Calls of built-in functions are restricted as for expression statements.

The function value and parameters are evaluated as usual in the calling goroutine, but unlike with a regular call, program execution does not wait for the invoked function to complete. Instead, the function begins executing independently in a new goroutine. When the function terminates, its goroutine also terminates. If the function has any return values, they are discarded when the function completes.

go Server()
go func(ch chan<- bool) { for { sleep(10); ch <- true }} (c)

Select statements

A “select” statement chooses which of a set of possible send or receive operations will proceed. It looks similar to a “switch” statement but with the cases all referring to communication operations.

SelectStmt = "select" "{" { CommClause } "}" .
CommClause = CommCase ":" StatementList .
CommCase   = "case" ( SendStmt | RecvStmt ) | "default" .
RecvStmt   = [ ExpressionList "=" | IdentifierList ":=" ] RecvExpr .
RecvExpr   = Expression .

A case with a RecvStmt may assign the result of a RecvExpr to one or two variables, which may be declared using a short variable declaration. The RecvExpr must be a (possibly parenthesized) receive operation. There can be at most one default case and it may appear anywhere in the list of cases.

Execution of a “select” statement proceeds in several steps:

1. For all the cases in the statement, the channel operands of receive operations and the channel and right-hand-side expressions of send statements are evaluated exactly once, in source order, upon entering the “select” statement. The result is a set of channels to receive from or send to, and the corresponding values to send. Any side effects in that evaluation will occur irrespective of which (if any) communication operation is selected to proceed. Expressions on the left-hand side of a RecvStmt with a short variable declaration or assignment are not yet evaluated.
2. If one or more of the communications can proceed, a single one that can proceed is chosen via a uniform pseudo-random selection. Otherwise, if there is a default case, that case is chosen. If there is no default case, the “select” statement blocks until at least one of the communications can proceed.
3. Unless the selected case is the default case, the respective communication operation is executed.
4. If the selected case is a RecvStmt with a short variable declaration or an assignment, the left-hand side expressions are evaluated and the received value (or values) are assigned.
5. The statement list of the selected case is executed.

---

select 语句的执行分为以下几个阶段：

1. 表达式求值阶段
   在进入 select 语句时，立即对所有 case 中的通道操作数进行一次求值（按源码顺序）：
   • 接收操作（如 case x := <-ch）的通道（ch）会被求值。
   • 发送操作（如 case ch <- y）的通道（ch）和右侧表达式（y）会被求值。
   • 求值结果：生成一组可操作的通道及其对应的发送值。
   • 注意：求值过程中的副作用（如函数调用）一定会发生，无论最终选中哪个 case。
   • 例外：短变量声明或赋值语句的左侧表达式（如 case x := <-ch 中的 x）此时不会求值。
2. 选择可执行 case
   • 如果有至少一个 case 可执行（通道可发送/接收），则随机选择一个（伪均匀随机，避免饥饿）。
   • 如果没有 case 可执行：
     • 存在 default 时，执行 default。
     • 不存在 default 时，select 阻塞，直到至少一个 case 可执行。
3. 执行通信操作
   • 如果选中的不是 default，则执行对应的通道发送或接收操作。
4. 赋值阶段（仅接收操作）
   • 如果选中的 case 是带短变量声明或赋值的接收语句（如 case x := <-ch），则此时才求值左侧表达式（x）并赋值。
5. 执行选中 case 的代码块
   • 最后，执行选中 case 的语句列表（如 case <-ch: fmt.Println("received")）。

---

Since communication on nil channels can never proceed, a select with only nil channels and no default case blocks forever.

var a []int
var c, c1, c2, c3, c4 chan int
var i1, i2 int
select {
case i1 = <-c1:print("received ", i1, " from c1\n")
case c2 <- i2:print("sent ", i2, " to c2\n")
case i3, ok := (<-c3):  // same as: i3, ok := <-c3if ok {print("received ", i3, " from c3\n")} else {print("c3 is closed\n")}
case a[f()] = <-c4:// same as:// case t := <-c4//	a[f()] = t
default:print("no communication\n")
}for {  // send random sequence of bits to cselect {case c <- 0:  // note: no statement, no fallthrough, no folding of casescase c <- 1:}
}select {}  // block forever

Return statements

A “return” statement in a function F terminates the execution of F, and optionally provides one or more result values. Any functions deferred by F are executed before F returns to its caller.

ReturnStmt = "return" [ ExpressionList ] .

In a function without a result type, a “return” statement must not specify any result values.

func noResult() {return
}

There are three ways to return values from a function with a result type:

1. The return value or values may be explicitly listed in the “return” statement. Each expression must be single-valued and assignable to the corresponding element of the function’s result type.

   func simpleF() int {return 2
   }func complexF1() (re float64, im float64) {return -7.0, -4.0
   }
   

2. The expression list in the “return” statement may be a single call to a multi-valued function. The effect is as if each value returned from that function were assigned to a temporary variable with the type of the respective value, followed by a “return” statement listing these variables, at which point the rules of the previous case apply.

   func complexF2() (re float64, im float64) {return complexF1()
   }
   

3. The expression list may be empty if the function’s result type specifies names for its

   result parameters. The result parameters act as ordinary local variables and the function may assign values to them as necessary. The “return” statement returns the values of these variables.

   func complexF3() (re float64, im float64) {re = 7.0im = 4.0return
   }func (devnull) Write(p []byte) (n int, _ error) {n = len(p)return
   }
   

Regardless of how they are declared, all the result values are initialized to the zero values for their type upon entry to the function. A “return” statement that specifies results sets the result parameters before any deferred functions are executed.

Implementation restriction: A compiler may disallow an empty expression list in a “return” statement if a different entity (constant, type, or variable) with the same name as a result parameter is in scope at the place of the return.

func f(n int) (res int, err error) {if _, err := f(n-1); err != nil {return  // invalid return statement: err is shadowed}return
}

Break statements

A “break” statement terminates execution of the innermost “for”, “switch”, or “select” statement within the same function.

BreakStmt = "break" [ Label ] .

If there is a label, it must be that of an enclosing “for”, “switch”, or “select” statement, and that is the one whose execution terminates.

OuterLoop:for i = 0; i < n; i++ {for j = 0; j < m; j++ {switch a[i][j] {case nil:state = Errorbreak OuterLoopcase item:state = Foundbreak OuterLoop}}}

Continue statements

A “continue” statement begins the next iteration of the innermost enclosing “for” loop by advancing control to the end of the loop block. The “for” loop must be within the same function.

ContinueStmt = "continue" [ Label ] .

If there is a label, it must be that of an enclosing “for” statement, and that is the one whose execution advances.

RowLoop:for y, row := range rows {for x, data := range row {if data == endOfRow {continue RowLoop}row[x] = data + bias(x, y)}}

Goto statements

A “goto” statement transfers control to the statement with the corresponding label within the same function.

GotoStmt = "goto" Label .

goto Error

Executing the “goto” statement must not cause any variables to come into scope that were not already in scope at the point of the goto. For instance, this example:

	goto L  // BADv := 3
L:

is erroneous because the jump to label L skips the creation of v.

A “goto” statement outside a block cannot jump to a label inside that block. For instance, this example:

if n%2 == 1 {goto L1
}
for n > 0 {f()n--
L1:f()n--
}

is erroneous because the label L1 is inside the “for” statement’s block but the goto is not.

Fallthrough statements

A “fallthrough” statement transfers control to the first statement of the next case clause in an expression “switch” statement. It may be used only as the final non-empty statement in such a clause.

FallthroughStmt = "fallthrough" .

关键规则

1. 仅适用于表达式 switch
   • 不能用于 类型 switch（如 switch x.(type) { ... }）。
2. 必须是 case 子句的最后一条非空语句
   • 如果 case 中有其他语句，fallthrough 必须放在末尾。
3. 不能用于最后一个 case 或 default
   • 因为后面没有可跳转的 case。

Defer statements

A “defer” statement invokes a function whose execution is deferred to the moment the surrounding function returns, either because the surrounding function executed a return statement, reached the end of its function body, or because the corresponding goroutine is panicking.

DeferStmt = "defer" Expression .

The expression must be a function or method call; it cannot be parenthesized. Calls of built-in functions are restricted as for expression statements.

Each time a “defer” statement executes, the function value and parameters to the call are evaluated as usual and saved anew but the actual function is not invoked. Instead, deferred functions are invoked immediately before the surrounding function returns, in the reverse order they were deferred.

That is, if the surrounding function returns through an explicit return statement, deferred functions are executed after any result parameters are set by that return statement but before the function returns to its caller. If a deferred function value evaluates to nil, execution panics when the function is invoked, not when the “defer” statement is executed.

For instance, if the deferred function is a function literal and the surrounding function has named result parameters that are in scope within the literal, the deferred function may access and modify the result parameters before they are returned. If the deferred function has any return values, they are discarded when the function completes. (See also the section on handling panics.)

lock(l)
defer unlock(l)  // unlocking happens before surrounding function returns// prints 3 2 1 0 before surrounding function returns
for i := 0; i <= 3; i++ {defer fmt.Print(i)
}// f returns 42
func f() (result int) {defer func() {// result is accessed after it was set to 6 by the return statementresult *= 7}()return 6
}