Golang Process Control

This is a creation in Article, where the information may have evolved or changed.

The process control of the go language is divided into three major categories:

1. Hearing conditions 2. Listen to the loop control 3. Listen to the unconditional jump

Conditional judgment

The condition of the go language is determined by the IF, else if ... else statement implementation, the conditional expression value must be a Boolean type, can omit parentheses, but the curly braces cannot be omitted and the left curly brace cannot be another line, for example:

If listen 7%2 Listen = = Listen to 0 listen to listen to the FMT. Println ("7 Listen to is listen to even")} listen to else listen {Listen and listen to the FMT. Println ("7 Listen to is listen to odd")} Listen to listen to hear if listen to 8%4 listen to = = Listen to 0 Listen {Listen listen//Can not else only if statement listen listen to the FMT. PRINTLN ("8 listen to is listen to divisible hear by 4")}

In particular, the go language supports initialization statements in conditional interpretation statements, allowing the definition of local variables, but the scope of the variable is limited to that conditional logical block, such as:

If Listen num listen: = listen to 9; Listen num Listen < Listen to 0 Listen {Listen and listen to the FMT. PRINTLN (num, hear "is Listen negative")} Listen to else listen if listen to num listen to < Listen to 10 listen {Listen and listen to the FMT. PRINTLN (num, listen to "has heard 1 listen to digit")} Listen to else listen {Listen and listen to the FMT. PRINTLN (num, hear "has heard multiple listen to digits")}

The most typical application is a dictionary lookup:

If listen to V, listen OK listen: = listen to map1[key1]; listen to ok{listen to listen ...}

Optimization Recommendations:

1. For those overly complex condition judgments, it is recommended to separate out the package into functions, separating the process control from the implementation details, making your code more modular and more readable.
   

2. Some need to write a lot of if-else to implement some complex logic processing, when the code looks very verbose and lengthy, but also not easy to later maintenance, with switch...case to solve the problem well.

Switch...case

Switch, like if, is also used to select execution, and the process of execution matches each case from top to bottom, with the following basic usage:

switch listen to sexpr listen to listen to hear listen to listen to listen to hear the case listen to hear expr1: Listen to listen to listen to listen to listen to hear some listen to listen to hear listen to hear listen to listen to hear the case listen to hear the instructions: Listen, listen, listen, hear and listen to some listen to the instructions listen to the case listen to listen to hear the case hear EXPR3: Listen to listen to hear listen to listen to listen to hear the other listen to listen to hear and listen to the default: listen to listen to listen to listen to listen to listen to other listen to 

The expression in switch can be either a constant or a string, or even no expression, and if no expression matches true, as with If-else If-else, the switch usage of other programming languages is basically the same, but the break is hidden in each case. However, you can also show join break. When the case match succeeds, the processing logic of the current cases is processed, normally, when the processing is complete, it jumps out of the whole switch, but this is not absolute, you can use Fallthrough to force the program to execute the subsequent case; If no case match succeeds, the default logic is executed, such as:

Write-Free break:

{Listen to listen to listen I listen: = Listen to listen to the 2 listen to the switch listen I listen {Listen listen to listen listen listen listen hear listen hear hear listen listen hear listen listen listen to listen to hear hear hear heard listen listen to hear listening to listen listen to listen to listen to hear listening and hearing. Println ("one") listen to//break no practical meaning, just jump out of the switch listen to listen and listen listen to listen to listen to hear the case 2: Listen, listen, listen, listen, listen and listen to the FMT. Println ("both") listen and listen to listen to listen to listen to the case 3: Listen, listen, hear, hear, hear, hear, listen to the FMT. Println ("three") Listen and Hear}}

Multi-expression judgment:

{Listen and listen and listen to the switch listening time. Now (). Weekday () Listen {Listen and listen to listen to the case. Saturday, listen to time. Sunday: Listen//In the same case can write multiple expressions, they are logical or the relationship between listening and listening listen hear listen listen listen to hear the FMT. Println ("It's listening to the weekend") Listen and listen listen to the default: Listen, listen, hear, hear, hear, hear, hear, and listen to the FMT. Println ("It's listening to a weekday") Listen and Hear}}

Non-expression:

{Listen and listen to T-listen: = Listen to time. Now () Listen, listen, listen, listen, listen, listen, hear, heard, heard, listen, hear and hear.//no expression, equivalent to If-else listen to listen and listen to listen to the case listening T. Hour () Listen < Listen 12: Listen, listen, listen, hear, hear, listen, and listen to the FMT. Println ("It's listening to before listen to noon") Listen and listen listen and listen listen to the default: Listen, listen, listen, listen, listen and listen to the FMT. Println ("It's listening after listening to Noon") Listen and Hear}}

Fallthrough:

{Listen and listen to listen I listen to: = Listen to 2 listen and listen to the switch listen to I listen to listen to hear, listen, listen, hear, listen, listen, hear. 1: Listen, listen, listen, listen, hear, hear, hear, listen, and listen. Println ("one") listen, listen, listen, hear, hear, listen, and listen. 2: Listen, listen, listen, hear, hear, hear, listen, and listen to the FMT. Println ("both") Listen listen listen listen hear listen to listen to hear Fallthrough hear hear listen to hear hear hear listen to listen to listen to listen to listen to listen to listen to listen to hear hear listen to listen to hear listen listen to listen to hear to hear listening and hearing heard Println ("three") Listen and Hear}}

Loop control

For is the only looping statement in the go language, here are three common uses:

For Listen J Listen: = listen to 7; Listen J listen to <= listen to 9 listen to J + + Hear {listen//typical usage Listen Initial/condition/after listen to the FMT. Println (j)}i Listen: = Listen to the 1for listen I listen to the <= listen to listen to hear (listen to listening to listen to listen to listen to listening to hear listening to hearing//similar while (I listen to <= 3) {} listen or for listening; {} Listen and listen to the FMT. PRINTLN (i) Listen to listen I hear = listen I listen + listen to 1}for listen to listen to hear//similar while (true) {} Listen or for listening true listen {} Listen and listen to the FMT. Println ("loop") listen, listen, listen and listen ... Listen, listen, hear, break, and hear.

PS: The initialization statement is executed only once, and the initialization expression supports the function call or the definition of the local variable

In daily development, for often paired with range, For...range is used to iterate through strings, arrays, slices, dictionaries, and channels, and returns indexes and key-value data, such as:

{Listen and listen for listen I, listen to C listen: = Listen to "Go" listen, listen, hear, listen, hear, listen, listen, hear, hear, hear, listen, listen to//range listen to the FMT. Println (I, listen to C) listen to listen to listen to listen to hear nums hear: = Listen to []int{2, listen to 3, listen to 4} Listen listen listen to listen to hear listen I, listen to num listen to: = Listen to the range listen to Nums listen to listen to hear listen to listen to listen to listening to hear the//range listen to the array/ Slice Listen, listen, listen and listen to the FMT. Println (I, listen ":", listen to num) listen and listen to listen to KVS listen to: Listen to the map[string]string{"a": Listen to "Apple", listen to "B": Listen to "banana"} Listen listen listen to listen to K, listen to the V listen to: Listen to the range listen KVS listen to listen to listen to listen to listen to hear the//range listen to listen to hear and listen listen to listen to and hear the FMT. Printf ("%s Listen-and listen to%s\n", listen to K, listen to V) listen to listen to and listen to the CHS listen to listen to: listen to make (Chan listen to int,10) listen to listen to hear//range listen to the channel listen to listen to CHS listen to listen to the <-listen to the 1 listen to the CHS listen to the <- Listen to 2 listen and listen to close (CHS) Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, listen, hear, hear, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, hear, hear, hear, hear, hear, listen, and hear. = Listen to the range listen to CHS { Listen, listen, hear, hear, and listen to the FMT. Println (v) Hear and hear}}

Briefly summarized as follows:

data type	first value	second value
string	index	s[index]
array/slice	index	v[index]
map	key	value
Channel	Element

Unconditional Jump

The go language has three types of jumps, namely continue, break, Goto

Continue: only for loop internal listen, terminate this loop, immediately into the next round of the loop break: used for the For loop, listen to the Switch,select statement, terminate the entire statement block execution goto: fixed point jump, but cannot jump to other functions or inside the code block

Look at the following example:

func hear over () {Listen listen to hear over: Listen to listen to hear//label listen to listen to defined hear and hear not listen to used listen to listen to listen to println ("Call Hear Over")}func listen to main () {Listen listen to Rand. Seed (time. Now (). Unixnano ()) Listen, listen, listen, hear and hear the loop: Listen, listen, listen, listen, hear, listen to, hear and hear. INTN (100) listen and hear//get a random number within 100 listen and listen listen to listen to hear hear if listen to listen to listen to listen to listen to listen to hear hear hear hear hear hear hear hear hear hear hear hear hear hear hear hear listen to hear listen listen to listen to listen to listen to listen to listen to listen to listen to listen to listen to listen to listen Go to the next round of the cycle listen and listen listen and listen listen and hear listen and hear listen and hear hear hear listen listen listen to listen to listen to listen to hear 50{listen listen listen, listen, listen, listen, hear, listen, hear, hear, listen, listening, hearing, heard, heard and heard. Listen, listen, hear, hear, listen, hear, hear, hear, hear, hear, listen. Listen, listen, listen, hear, listen, hear, listen, listen, hear, listen, println, hear, listen, listening and listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, listening, Goto listen to loop listen jumps listen to into listen to block listen to starting} 

Goto's Customary usage:

{Listen and listen to F, listen to err: = Listen to the OS. Open ("/tmp/dat") listen and hear listen and listen to hear if listen to err listen to listen to listen to hear nil{listen and listen listen to listen to hear .... Listen, listen, listen and listen to the Goto listen and listen to the listen and hear ... Listen and listen to N1, listen to err: = Listen F. Read (B1) Listen to hear if listen to err listen to listen to listen to nil{listen hear listen listen listen to listen listen to listen to hear ... end: Listen to listen to hear listen to listen to hear ("clear listen resource hear and listen to exit") Listen and hear F.close () Exit: Listen, listen, hear and hear the return.

Learn from: Rain marks <go Learning notes >

Discussion study: 675020908

This article from "learned in the text, about the ceremony" blog, reproduced please contact the author!