三：go流程控制

流程控制

程序控制流程一共三种：选择结构，顺序结构，循环结构

顺序结构：自上而下的逐行执行

选择结构：选择条件满足的代码执行

if

swich

select

循环结构：

for

if语句

条件语句，通过测试调节判断是否ture来决定是否指定语句，并在条件false的情况在执行另外的语句

 

if条件语句

package main

import "fmt"

func main() {
   var a int = 15
   if a > 20 {
      fmt.Println("a>20")
   }
   if a > 10 {
      fmt.Println("a>10")
   }
    //输出结果：a>10
}

if else语句

package main

import "fmt"

func main() {
    //定义一个分数为90
   var score int
   fmt.Println("请输入一个数：")
   fmt.Scan(&score)
   //设置score>=90 优秀
   //   score>=60 良好
   //   score <60 不及格
   if score >= 90 {
      fmt.Println("优秀")
   } else if score >= 60 {
      fmt.Println("良好")
   } else {
      fmt.Println("不及格")
   }
}

if嵌套语句

package main

import "fmt"

// if嵌套
func main() {
	//	验证密码
	var x, y, pwd int
	pwd = 20221112
	fmt.Print("请输入密码:")
	fmt.Scanln(&x)

	if x == pwd {
		fmt.Print("请再次输出密码:")
		fmt.Scanln(&y)
		if y == pwd {
			fmt.Println("密码验证成功")
		}
	} else {
		fmt.Println("密码验证失败")
	}
}

swich语句

基于不同条件匹配不通动作，每一个case分支都是唯一的，从上至下逐一测试，知道匹配为止

自上而下匹配，直到找到匹配项，匹配项后面不需要在加break。switch 默认情况下case最后自带 break语句

package main

import "fmt"

var score int = 66

func main() {
	switch score {
	case 90:
		println("A")
	case 80:
		println("B")

	case 70, 60, 50:
		println("C")
	default:  //条件不满足时，执行default语句
		fmt.Println("D")

	}
}

示例二

package main

import "fmt"

func main() {
	var score int
	fmt.Printf("请输入成绩")
	fmt.Scanln(&score)

	switch {
	case score >= 90:
		fmt.Println("您的成绩为优秀")
	case score >= 60 && score < 90:
		fmt.Println("您的成绩为良好")
	case score < 60 && score > 0:
		fmt.Println("您的成绩为不及格")
		//	当所有条件不满足时，执行default语句
	default:
		fmt.Println("查询不到您的成绩")

	}

}

fallthrough贯穿，直通

如果我们需要执行后面的case，可以使用fallthrough穿透case使用fallthrough会强制执行后面的case语句，fallthrough不会判断下一套表达式是否为ture或false

package main

import "fmt"

func main() {

	var a bool = false
	switch a {

	case false:
		fmt.Println("case的条件是false")
		fallthrough
	case true:
		println("case的条件是ture")

	}

}

我们使用暴力穿透影响我们程序，我么可以使用break跳出

package main

import "fmt"

func main() {
	var a bool = false
	switch a {
	case false:
		fmt.Println("1,case条件为false")
		fallthrough
	case true:
		if a == false {
			break //终止穿透
		}
		fmt.Println("2,case条件为true")

	}
	//输出结果：1,case条件为false
}

for循环

for是一个循环结构，可以执行指定次数的循环

package main

import (
	"fmt"
)

func main() {

	sum := 0
	//for的起始条件，for的范围，for自增还是自减
	for i := 1; i <= 10; i++ {
		sum = sum + i

		fmt.Println(i)
	}
	fmt.Println(sum)

}

练习1

package main

import "fmt"

/* 打印一个方阵
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
 */
func main() {
	for j := 0; j < 5; j++ {
		for i := 0; i < 5; i++ {
			fmt.Print("* ")
		}
		fmt.Println()
	}
}

练习2

package main

import "fmt"

func main() {
	//打印9列
	for j := 1; j <= 9; j++ {

		//打印9行 i <= j逐级递减
		for i := 1; i <= j; i++ {
			//Printf字符编排  一个%d对应一个值
			fmt.Printf("%d*%d=%d ", i, j, i*j)
		}
		//输出完每一行换行
		fmt.Println()
	}

}

break 结束当前整个循环

package main

import "fmt"

func main() {

	for i := 1; i <= 9; i++ {

		if i == 5 {
			break
		}
		fmt.Println(i)
	}

}

continue结束当次循环

package main

import "fmt"

func main() {
	//continue 结束当次循环
	fmt.Println("=======================")
	for i := 0; i < 9; i++ {
		if i == 5 {  //如果等于5直接跳过，从6开始执行，直接循环结束
			continue
		}
		fmt.Println(i)
	}
}

遍历string

package main

import "fmt"

func main() {
	str := "hello,xuexiangban"
	fmt.Println(str)

	//输出字符串的长度 len
	fmt.Println("字符串的长度：", len(str))

	// 获取指定的字节 但这里输出的是ascii值 h-104
	fmt.Println(str[0])
	fmt.Printf("获取指定的字节：%c", str[0])

	// 遍历字符串
	for i := 0; i < len(str); i++ {
		fmt.Printf("%c/n", str[i])
	}
	fmt.Println()

	// for range循环，遍历数组，切片

	for i, i2 := range str {
		fmt.Print(i)
		fmt.Printf("%c", i2)
	}
}