Process control, all in one place

[[415477]]

Watching the Olympics recently has gotten my blood boiling. The Chinese Olympic athletes are simply amazing, not only in their performance, but also in their temperament, spirit, and energy. They are great in all aspects.

What moved me the most in this Olympics was seeing some older athletes achieve great results: Lü Xiaojun was 37, Ma Long was 32, Su Bingtian was 32, and Gong Lijiao won her first Olympic gold medal at the age of 32. Even athletes who are so limited by age can constantly break through themselves, let alone us? Are we still worried online every day that programmers will be optimized at the age of 35?

So don’t use age as an excuse for yourself. Don’t think that you can’t do this or that because you’re too old. Just do it.

if-else

Features:

• Conditional statements do not need to be enclosed in parentheses ();
• The curly braces {} must be present, and the left curly brace { must be on the same line as if or else;
• After the if statement and before the conditional statement, you can add variable initialization statements, separated by ;.

 package main 
 
 import "fmt"   
 
 func main() {
 if 7%2 == 0 {
        fmt.Println( "7 is even" )
 } else {
        fmt.Println( "7 is odd" ) // 7 is odd
 } 
 
 if 8%4 == 0 {
        fmt.Println( "8 is divisible by 4" ) // 8 is divisible by 4
 } 
 
 if num := 9; num < 0 {
        fmt.Println(num, "is negative" )
 } else if num < 10 {
        fmt.Println(num, "has 1 digit" ) // 9 has 1 digit
 } else {
        fmt.Println(num, "has multiple digits" )
 }
 }

switch

Features:

• The left curly brace { must be on the same line as the switch;
• Conditional expressions are not restricted to constants or integers;
• You can add variable initialization statements after switch, using ; to separate;
• The conditional expression can be omitted. In this case, the entire switch structure is equivalent to the logical function of multiple if-else statements.
• Multiple result options can appear in a single case;
• Adding the fallthrough keyword to a case will continue execution to the next case without judging the conditional statement of the case;
• Switch supports default statements. When all cases are not satisfied, the default statement is executed.

 package main 
 
 import (
 "fmt"  
 "time"  
 ) 
 
 func main() {
 i := 2
    fmt.Print( "write " , i, " as " )
 switch i {
 case 1:
 fmt.Println( "one" )
 case 2:
        fmt.Println( "two" ) // write 2 as two
 fallthrough
 case 3:
        fmt.Println( "three" ) // three
 case 4, 5, 6:
        fmt.Println( "four, five, six" )
 } 
 
 switch num := 9; num {
 case 1:
 fmt.Println( "one" )
 default :
        fmt.Println( "nine" ) // nine
 } 
 
    switch time .Now().Weekday() {
 case   time .Saturday, time .Sunday:
        fmt.Println( "it's the weekend" )
 default :
        fmt.Println( "it's a weekday" ) // it's a weekday
 } 
 
 t := time .Now()
 switch {
 case t.Hour () < 12 :
        fmt.Println( "it's before noon" )
 default :
        fmt.Println( "it's after noon" ) // it's after noon
 }
 }

for

Features:

• The conditional expression does not need to be enclosed in parentheses ();
• The curly braces {} must be present, and the left curly brace { must be on the same line as for;
• Supports continue and break.

 package main 
 
 import (
 "fmt"  
 ) 
 
 func main() {
 i := 1
 // Only condition
 for i <= 3 {
 fmt.Println(i)
 i = i + 1
 } 
 
 // There are variable initialization and conditions
 for j := 7; j <= 9; j++ {
 fmt.Println(j)
 } 
 
 // Infinite loop
 for {
 fmt.Println( "loop" )
 break
 } 
 
 // Traverse the array
    a := [...] int {10, 20, 30, 40}
 for i := range a {
 fmt.Println(i)
 }
 for i, v := range a {
 fmt.Println(i, v)
 } 
 
 // Traverse the slice
    s := []string{ "a" , "b" , "c" }
 for i := range s {
 fmt.Println(i)
 }
 for i, v := range s {
 fmt.Println(i, v)
 } 
 
 // Traverse the dictionary
    m := map[string] int { "a" : 10, "b" : 20, "c" : 30}
 for k := range m {
 fmt.Println(k)
 }
 for k, v := range m {
 fmt.Println(k, v)
 }
 }

goto, break, continue

Features of goto:

• Can only jump within a function and needs to be used with a label;
• Internal variable declaration statements cannot be skipped;
• You can only jump to the same-level scope or the upper-level scope, but not to the inner scope.

 package main 
 
 import (
 "fmt"  
 ) 
 
 func main() {
 // Break out of the loop
 for i := 0; ; i++ {
 if i == 2 {
 goto L1
 }
 fmt.Println(i)
 }
 L1:
 fmt.Println( "Done" ) 
 
 // Skip variable declaration, not allowed
 // goto L2
 // j := 1
 // L2:
 }

break Features:

• Used alone to break out of the execution of the for, switch, or select statement in which the break is currently located;
• Used together with a label to jump out of the execution of the for, switch, or select statement identified by the label. It can be used to jump out of multiple loops, but the label and break must be in the same function.

 package main 
 
 import (
 "fmt"  
 ) 
 
 func main() {
 // break jumps to the label and then skips the for loop
 L3:
 for i := 0; ; i++ {
 for j := 0; ; j++ {
 if i >= 2 {
 break L3
 }
 if j > 4 {
 break
 }
 fmt.Println(i, j)
 }
 }
 }

continue Features:

• Used alone to jump out of the current iteration of the for loop in which continue is located;
• Used together with a label to jump out of the current iteration of the for statement identified by the label, but the label and continue must be in the same function.

 package main 
 
 import (
 "fmt"  
 ) 
 
 func main() {
 // continue jumps to the label and then executes i++
 L4:
 for i := 0; ; i++ {
 for j := 0; j < 6; j++ {
 if i > 4 {
 break L4
 }
 if i >= 2 {
 continue L4
 }
 if j > 4 {
 continue  
 }
 fmt.Println(i, j)
 }
 }
 }

Summarize

This article mainly introduces process control statements, namely conditional statements, selection statements, loop statements and jump statements.

• Conditional statements: corresponding to the keywords if, else and else if;
• Selection statement: corresponding to the keywords switch, case, fallthrough and default;
• Loop statement: corresponds to the keywords for and range;
• Jump statement: corresponds to the keyword goto.

In addition, there are break and continue, which can be used with loop statements and jump statements.

Jump statements are very useful in some scenarios, but they can easily cause some inexplicable problems, so use them with caution.

The mind map and source code in the article have been uploaded to GitHub, and students in need can download them by themselves.

Address: https://github.com/yongxinz/gopher/tree/main/sc

This article is reprinted from the WeChat public account "AlwaysBeta", which can be followed through the following QR code. To reprint this article, please contact the AlwaysBeta public account.