.GO File Format – Statements

Empty statements

The empty statement does nothing: EmptyStmt = .

Expression statements

Function and method calls and receive operations can stand as statements. These built-in functions cannot: append cap complex imag len make new real unsafe.Add unsafe.Alignof unsafe.Offsetof unsafe.Sizeof unsafe.Slice unsafe.SliceData unsafe.String unsafe.StringData. The gc compiler also rejects min and max here.

Send statements

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

Sends a value on a channel: ch <- 3. Both operands are evaluated first. Sending blocks until the send can proceed. See Concurrency.

IncDec statements

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

x++ is x += 1 and x-- is x -= 1. The operand must be addressable or a map index expression. These are statements, not expressions, so they cannot be used inside an expression.

Assignment statements

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

Each left-hand operand must be addressable, a map index expression or, for = only, the blank identifier. x op= y means x = x op (y) but evaluates x only once. A tuple assignment assigns the values of a multi-valued operation, or matching lists of single-valued expressions, to a list of variables.

Assignment has two phases. First the operands of index expressions and pointer indirections on the left, and the expressions on the right, are evaluated in the usual order. Second, the assignments are done left to right (spec: Assignment statements).

a, b = b, a  // exchange a and b

x := []int{1, 2, 3}
i := 0
i, x[i] = 1, 2  // set i = 1, x[0] = 2

i = 0
x[i], i = 2, 1  // set x[0] = 2, i = 1

x[0], x[0] = 1, 2  // set x[0] = 1, then x[0] = 2
x[1], x[3] = 4, 5  // set x[1] = 4, then panic setting x[3] = 5

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

Each value must be assignable to its target. An untyped constant assigned to an interface variable or the blank identifier is first converted to its default type. Assignment copies the value only; a slice or map value still shares its underlying data.

Expression switches

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

• Case expressions need not be constants and are evaluated top to bottom, left to right. The first one equal to the switch expression runs its clause; the others are skipped.
• A missing switch expression is true.
• At most one default, in any position.
• An untyped constant switch expression takes its default type first. The predeclared untyped nil cannot be the switch expression. The expression’s type must be comparable.
• Control does not fall through by default. A fallthrough statement as the final non-empty statement of a clause transfers to the next clause’s first statement. It cannot appear in the last clause.
• A compiler may reject duplicate constants in case expressions; current compilers reject duplicate integer, floating-point and string constants.

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

Type switches

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

• The guard x.(type) uses the keyword type; x must be of interface type and not a type parameter. Each non-interface type listed must implement the type of x. Listed types must all be different.
• With a short declaration in the guard, the variable is declared at the end of each clause’s TypeSwitchCase in that clause’s implicit block. In a clause listing exactly one type, the variable has that type; otherwise it has the type of the expression in the guard.
• A case nil matches a nil interface value. At most one is allowed.
• A type parameter or generic type may be used as a case type. If an instantiation duplicates another entry, the first matching case is chosen.
• fallthrough is not permitted in a type switch.

switch i := x.(type) {
case nil:
	printString("x is nil")                // type of i is type of x
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
default:
	printString("don't know the type")     // type of i is type of x
}

Single condition and for clause

for a < b {
	a *= 2
}

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

for {
	// forever, until break or return
}

The init statement may be a short variable declaration; the post statement must not be. Any part of the clause may be empty, but the semicolons are needed unless there is only a condition. An absent condition means true.

Per-iteration variables (Go 1.22). Each iteration of a three-clause loop has its own copy of the variables declared by the init statement. The variable for each later iteration is declared just before the post statement runs and is initialised to the value of the previous iteration’s variable. Before Go 1.22 all iterations shared one set of variables, which is what a closure would see.

var prints []func()
for i := 0; i < 5; i++ {
	prints = append(prints, func() { println(i) })
	i++
}
for _, p := range prints {
	p()
}
// Go 1.22 and later prints 1, 3, 5.
// Before Go 1.22 the same program prints 6, 6, 6.

Range clause

A range clause iterates over the elements of its range expression. The expression is evaluated once before the loop, unless there is at most one iteration variable and x or len(x) is constant. Function calls on the left are evaluated once per iteration.

• A channel or integer range allows at most one iteration variable; a function allows as many as its signature gives; others up to two.
• If the last iteration variable is blank, the clause is the same as without it. Since Go 1.4 a range may have no variables at all: for range ch { }.
• Variables declared with := are new in each iteration (Go 1.22). Without := they must already exist and are assigned to as in an assignment statement.

for i := range 10 {
	f(i) // i is an int, 0 to 9
}

var u uint8
for u = range 256 {  // invalid: 256 cannot be assigned to uint8
}

for range 1e3 {      // invalid: 1e3 is a floating-point constant
}

// fibo generates the Fibonacci sequence.
fibo := func(yield func(x int) bool) {
	f0, f1 := 0, 1
	for 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)
}