Go if
External
Internal
Overview
The if
statement specifies the conditional execution of one, two or more branches according to the value of boolean expressions. Optionally, the boolean expression may be preceded by an initialization statement, which is executed before the expression is evaluated.
The statements to be executed must aways be encoded in braces. Mandatory braces encourage writing simple if
statements on multiple lines.
Simple if
if <expression> {
<statements>
}
if x > 5 {
println(x)
}
Note that because the lexer automatically inserts a semicolon after each token that may represent the end of statement, if it is followed by newline, we always must provide the opening brace on the same line as the expression.
if/else
if <condition> {
<statements>
} else {
<statements>
}
if x > 5 {
println(x)
} else {
println("something else")
}
If the if
statement does not flow into the next statement, because the body ends in break
, continue
or most commonly return
, the unnecessary else
is omitted. This is a common situation when the code must guard agains a sequence of error conditions. The code reads well if the successful flow of control runs down the page eliminating error cases as they arise. Since error cases then to end in return
statements, the resulting code needs no else
statements:
f, err := os.Open(name)
if err != nil {
return err
}
d, err := f.Stat()
if err != nil {
f.Close()
return err
}
codeUsing(f, d)
if/else if/else
if <condition> {
<statements>
} else if <condition> {
<statements>
} else {
<statements>
}
if x < 5 {
println(x)
} else if x == 5 {
println("is 5")
} else {
println("something else")
}
if with Initialization Statement
if
accepts an initialization statement before the expression, which is commonly used to set up local variables that are then used in the expression and are also accessible in the entire if
statement scope, which includes the subsequent if
, else if
and else
blocks:
if <initialization-statement>; <expression> {
<statements>
} else if <expression> {
// variables declared by the initialization statements are visible here
<statements>
} else <expression> {
// variables declared by the initialization statements are visible here
<statements>
}
if a := compute(); a > 0 {
fmt.Println("positive " + a)
} else {
fmt.Println("negative " + a)
}
The local variables declared in the initialization statement are only accessible in the expression and the subsequent if blocks.
This syntax supports the Go error handling idiom that relies on functions returning errors as result value:
var result ...
var err error
if result, err = someFunc(); err != nil {
// handle error
return
}
// handle success
...
The alternative is:
if result, err := someFunc(); err {
// handle error
...
} else {
// handle success, result is available in this block
...
}