“This is the ninth day of my participation in the August More Text Challenge. For more details, see August More Text Challenge

Conditional judgment if

  • Judgment is often needed in program development. Depending on the situation, the program executes in different branches. This is where you can use if

  • If stands for “if” in a program, if the condition is true, it’s executed, otherwise it’s not executed

  • In the compiler, parentheses can be written around the expression, but are usually omitted

// Use the if expression {} aloneCopy the code
  • In the if syntax, all expressions end up as bool, and true means true

If alone

  • If alone only affects its own block of code
func main(a) {
	score := 65

	if score >= 60 {
		fmt.Println("Pass")}}Copy the code
  • You can declare a variable in an if expression, and the scope of the variable can only be used in an if
func main(a) {
	if score:=60; score>=60{
		fmt.Println("Passed.")}}Copy the code
  • Multiple individual IF’s have no effect on each other
func main(a) {
	score := 65

	if score >= 60 {
		fmt.Println("Pass")}if score < 60 {
		fmt.Println("Fail")}}Copy the code

Program debugging

  • Program debugging, commonly known as :debug, through a specific means, a statement a statement to observe the process of program execution
  • Debug is often used in error calls. When the result is not what you expect and the code is large,debug can find out which line is in trouble
  • Program debugging step
    • A red circle appears when you click before a line in the program
    • Right click and select Debug ‘file name’
    • Click the button or use the shortcut key to select: down to execute (F6), into the call (F5), up to jump out (F7) observe the program

if … The else structure

  • If can be used alone or in combination with else, if it is mutually exclusive… The else structure
  • if.. Else structure if the if is true then else
func main(a) {
	i := 59
	if i >= 60 {
		fmt.Println("Pass")}else{
	fmt.Println("Fail")}}Copy the code

If multiple nesting

  • If each structure can be nested within each other
  • In theory, if can be nested in many layers
  • Examples of two layers of nested code
func main(a) {
	score := 77
	if score >= 60 {
		if score >= 60 && score < 70 {
			fmt.Println("Pass")}if score >= 70 && score < 80 {
			fmt.Println("Medium")}if score >= 80 && score < 90 {
			fmt.Println("Good")}if score >= 90 && score <= 100 {
			fmt.Println("Good")}}else {
		fmt.Println("Fail")}}Copy the code

if … else if …. The else structure

  • This structure is used when multiple conditions need to be determined
  • This structure is a whole. As soon as one of the conditions is true none of the rest of the judgment, immediately end
  • We can’t have else
  • Rewrite the nested code as follows
func main(a) {
	score := 77
	if score >= 90 {
		fmt.Println("Good")}else if score >= 80 {
		fmt.Println("Good")}else if score >= 70 {
		fmt.Println("Medium")}else if score >= 60 {
		fmt.Println("Pass")}else {
		fmt.Println("Fail")}}Copy the code

Switch condition judgment

Switch Structure Introduction

  • Switch is also a conditional statement
  • Support for multiple writing, and if.. else if … The else structure is similar in function, but the details need more attention
  • Basic Switch syntax
Switch [define variable;] [variable] {case conditions/concrete values: / / code case conditions/concrete values: default: / / code / / code}Copy the code
  • Switch By default, only one case branch is executed from the top down
  • The upper and lower positions of default are not affected. Default is executed only when all cases are invalid

Switch Usage (1)

  • The switch structure can be used when a variable has a fixed number of values
func main(a) {
	num := 16
	switch num {
	case 2:
		fmt.Println("Two base")
	case 8:
		fmt.Println("8 hexadecimal")
	case 10:
		fmt.Println("Decimal")
	case 16:
		fmt.Println("Hex")
	default:
		fmt.Println("Incorrect content")
	}
	fmt.Println("End of procedure")}Copy the code
  • The switch also supports defining variables in a conditional position with the valid range of the current switch
func main(a) {
	switch num := 16; num {
	case 2:
		fmt.Println("Two base")
	case 8:
		fmt.Println("8 hexadecimal")
	case 10:
		fmt.Println("Decimal")
	case 16:
		fmt.Println("Hex")
	default:
		fmt.Println("Incorrect content")
	}
	fmt.Println("End of procedure")}Copy the code

Switch Usage (2)

  • When the condition is a range rather than a fixed value
func main(a) {
	score := 71
	switch {
	case score >= 90:
		fmt.Println("Good")
	case score >= 80:
		fmt.Println("Good")
	case score >= 70:
		fmt.Println("Medium")
	case score >= 60:
		fmt.Println("Pass")
	default:
		fmt.Println("Fail")
	}
	fmt.Println("End of procedure")}Copy the code

Switch Usage (3)

  • Case conditions support multiple values, each separated by commas
func main(a) {
	month := 5
	switch month {
	case 1.3.5.7.8.10.12:
		fmt.Println("31 days")
	case 2:
		fmt.Println("28 or 29 days.")
	default:
		fmt.Println("30 days")
	}
	fmt.Println("End of procedure")}Copy the code

Penetration and break

  • A switch structure can only execute one case at most. Using fallthrough allows the next case/default to continue execution
func main(a) {
	switch num := 1; num {
	case 1:
		fmt.Println("1")
		fallthrough
	case 2:
		fmt.Println("2")
	case 3:
		fmt.Println("3")
		fallthrough
	case 4:
		fmt.Println("4")
	default:
		fmt.Println("Not 1, 2, 3, 4")
	}
	fmt.Println("End of procedure")}Copy the code
  • Break can be used in switches and loops to indicate an immediate end, regardless of how much code remains behind the current structure
func main(a) {
	switch num := 1; num {
	case 1:
		fmt.Println("1")
		break
		fmt.Println("None of the code after break is executed.")
		fallthrough
	case 2:
		fmt.Println("2")
	case 3:
		fmt.Println("3")
		fallthrough
	case 4:
		fmt.Println("4")
	default:
		fmt.Println("Not 1, 2, 3, 4")
	}
	fmt.Println("End of procedure")}Copy the code