标签：否则 work 依次 数据类型 后退 ima rda img inpu
#### Go 程序流程控制
***渡风渡尘缘,修行亦修心***
在程序中主要有三大程序程控语句.
1. 顺序控制
2. 分支控制
3. 循环控制
##### 顺序控制
程序从上到下逐行执行,中间没有任何判断和跳转
package main
import "fmt"
func main(){
var a = 1
var b = 2
fmt.Println(a)
fmt.Println(b)
var c = 3
var d = 4
fmt.Println(c)
fmt.Println(d)
}
---
##### 分支控制
分支控制就是让程序有选择的执行,有以下几种形式
1. 单分支
2. 双分支
3. 多分支
######单分支
if 条件表达式{
代码块
}
当条件表达式为true时,会执行{} 中的代码,{} 必须有;
package main
import "fmt"
func main(){
var num = 10
var guess int
fmt.Print("please guess the number: ")
fmt.Scanln(&guess)
if guess > num {
fmt.Println("be smaller")
}
// 也支持在if 中直接定义一个变量使用
if a := 11;a >num {
fmt.Println("a > 10")
}
}
单分支流程图如下:
###### 双分支
if 条件表达式{
代码块1
} else {
代码块2
}
当条件表达式成立时,执行代码块1,否则执行代码块2,{} 必须有;
package main
import "fmt"
func main(){
var num = 10
var guess int
fmt.Print("please guess the number: ")
fmt.Scanln(&guess)
if guess > num {
fmt.Println("be smaller")
} else {
fmt.Println("be bigger")
}
}
双分支流程图如下:
###### 多分支
if 条件表达式1 {
代码块1
} else if 条件表达式2 {
代码块2
} .... {
......
} else {
代码块3
}
多分支判断流程如下:
(1). 先判断条件表达1是否成立, 如果为真, 就执行代码块1;
(2). 如果条件表达式1不成立,判断条件表达2是否成立,如果为真,执行代码块2;
(3). 依次类推;
(4). 如果所有的条件表达式都不成立,则执行else 语句块;
(5). else 不是必须的;
(6). 多分支只能有一个执行入口;
package main
import "fmt"
func main(){
var score int
fmt.Print("please enter a grade: ")
fmt.Scanln(&score)
if score < 60 {
fmt.Println("差")
} else if score >=60 && score < 80 {
fmt.Println("良好")
} else if score >=80 && score < 100 {
fmt.Println("优秀")
}
}
多分支流程如下:
###### 嵌套分支
在一个分支结构中又完整嵌套了另一个完整的分支结构,里面的分支称为内层分支,外面的分支称为外层分支;
if 条件表达式{
if 条件表达式{
}else {
}
}
嵌套分支建议控制在3 层以内;
package main
import "fmt"
func main(){
var score int
fmt.Print("please enter a grade: ")
fmt.Scanln(&score)
if score >= 60 {
if score >= 80 {
fmt.Println("优秀")
} else {
fmt.Println("良好")
}
} else {
fmt.Println("差")
}
}
###### switch 分支控制
switch 语句用于根据不同条件执行不同动作,每个case 分支都是唯一的,从上到下匹配;
匹配项后面不需要加break ;
switch 表达式{
case 表达式1,表达式2:
语句块1
case 表达式3,表达式4:
语句块2
.... // 可以有多个case 语句
default:
语句块
}
package main
import "fmt"
func main(){
var week int
fmt.Print("please input a number[0-6]:")
fmt.Scanln(&week)
switch week {
case 1:
fmt.Println("Monday")
case 2:
fmt.Println("Tuesday")
case 3:
fmt.Println("Wednesday")
case 4:
fmt.Println("Thursday")
case 5:
fmt.Println("Friday")
case 6:
fmt.Println("saturday")
case 0:
fmt.Println("Sunday")
//case 8.1: // 错误, 类型不一致
//case 6: // 错误, 常量值重复
}
}
switch 分支如下:
1. switch 执行的流程是先执行表达式,得到值,然后和case 表达式进行比较,如果相等,执行case 对应的语句块,然后退出switch 控制;
2. 如果switch 的表达式的值 没有和任何的case 表达式匹配上,则执行default 语句块,执行后退出switch 控制;
3. case 后的表达式可以有多个,使用逗号分隔;
4. case 语句块不需要写break, 默认执行完case 后退出switch 控制;
5. case/switch 后是一个表达式, 可以是常量值,变量,一个有返回值的函数;
6. case 后的表达式的值的数据类型, 必须和switch 的表达式的数据类型一致;
7. case 后面的表达式如果是常量的值,则不能重复;
8. default 不是必须的;
9. switch 后也可以不带表达式,类似if - else 分支使用;
10. 穿透-fallthrough , 如果在case 语句后增加fallthrough, 则会继续执行下一个case;
11. switch 也可以用来判断某个interface 变量中实际指向的变量类型;
package main
import "fmt"
func main(){
var week int
fmt.Print("please input a number[0-6]:")
fmt.Scanln(&week)
switch {
case week == 1:
fmt.Println("Monday")
case week ==2 :
fmt.Println("Tuesday")
case week == 3 :
fmt.Println("Wednesday")
case week == 4:
fmt.Println("Thursday")
}
// 也可以判断
switch {
case week > 5:
fmt.Println("it is weekend")
case week <= 5:
fmt.Println("it is work day")
fallthrough
default:
fmt.Println("it is work day")
}
}
package main
import "fmt"
func main(){
var i interface{}
var a = "ss"
i = a
switch i.(type) {
case int:
fmt.Println("a type is int")
case float64:
fmt.Println("a type is float64")
default:
fmt.Println("unknow type")
}
}
标签：否则 work 依次 数据类型 后退 ima rda img inpu
原文地址：https://www.cnblogs.com/Mail-maomao/p/11376200.html
