Fork me on GitHub

Golang之旅29-流程控制

Posted on | In |
Words count in article: 2.5k | Reading time ≈ 12

Go知识点总结2-流程控制

流程控制

分支控制
  • 单分支
  • 双分支
  • 多分支
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package main
import "fmt"

func main(){
  
  //1. 单分支
	var age int
  fmt.Println("请输入年龄：")
  fmt.Scanln(&age)
  
  if age > 18{
    fmt.Println("你的年龄大于18")
  }
  
  // if age := 20; age > 18{
  //	fmt.Println("你的年龄大于18")
	//}
  
  // 2. 双分支
  var age1 int
  fmt.Println("请输入年龄：")
  fmt.Scanln(&age1)
  
  if age1 > 18 {
    fmt.Println("你的年龄大于18")
  } else {
    fmt.Println("你的年龄小于18")
  }
  
  // 案例
  i := 4
  j := 1
  if i > 4 {
    if j > 2 {
      fmt.Println(i+j)
    }
    fmt.Println("hello golang")   // 输出hello golang
  }else {
    fmt.Println(i)   //  上面的分支已经执行了，else分支不会执行
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 练习题

package main
import "fmt"

func main(){
  var i int32 = 20
  var j int32 = 25
  if i + j > 50{
    fmt.Println("hello world")
  }
  
  var x float64 = 15.0
  var y float64 = 13.0
  if x > 10 && y < 20{
    fmt.Println(x + y)
  }
  
  // 判断闰年：1. 能够被4整除，但是不能被100整除；2.能够被400整除
  var year int32 = 2020
  if (year % 4 ==0 && year % 100 !=0) || year % 400 == 0{
    fmt.Println("闰年～")
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// 多分支

package main
import （
	"fmt"
	"math"
）

func main(){
  var score int32
  fmt.Println("请输入成绩：")
  fmt.Scanln(&score)
  
  if score == 100{
    fmt.Println("宝马")
  }else if 80 < score && score <= 99{
    fmt.Println("Iphone7")
  } else if 60 <= score && score <= 80{
    fmt.Println("Ipad")
  } else{
    fmt.Println("Nothing")
  }
  
  
  // 求二次函数的结果，判断判别式
  a := 3.0
  b := 100.0
  c := 6.0
  
  m := b*b - 4*a*c
  
  if m > 0{
    x1 := (-b + math.Sqrt(m)) / (2*a)
    x2 := (-b - math.Sqrt(m)) / (2*a)
    fmt.Println(x1, x2)
  }else if m == 0{
    x1 := (-b + math.Sqrt(m)) / (2*a) 
    fmt.Println(x1)
  }else {
    fmt.Println("Nothing")
  } 
  
  // 判断男方标准
  var height int32
  var money float32
  var handsome bool
  
  fmt.Println("请输入身高：")
  fmt.Scanln(&height)
  fmt.Println("请输入财富：")
  fmt.Scanln(&money)
  fmt.Println("是否帅")
  fmt.Scanln(&handsome)
  
  if height > 180  && money > 1 && handsome {
    fmt.Println("今天就嫁给他！")
  }else if height > 180  || money > 1 || handsome{
    fmt.Println("过段时间嫁给他！")
  }else {
    fmt.Println("gun")
  }
}
嵌套分支

在一个分支结构中又嵌套了一个完整的分支结构，里面的叫做内层分支结构，外层的叫做外层分支。嵌套分支最多3层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main
import "fmt"

func main(){
	var second float64
	fmt.Println("请输入时间秒数：")
	fmt.Scanln(&second)  
  
  if second <= 8{
    // 进入决赛
    var sex string
    fmt.Println("请输入性别：")
		fmt.Scanln(&sex)  
    
    if sex == "男":{
      fmt.Println("进入决赛的男子组")
    }else {
      fmt.Println("进入决赛的女子组")
    }
  } else{
    fmt.Println("out")
  } 
}

switch

  • case后面可以是个表达式：变量、常量、有返回值的函数
  • case和switch的表达式必须相同
  • case后面可以有多个表达式
  • case后面表达式中的常量不能重复，但是变量可以重复
  • case后面不需要break，default不是必须
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package main
import "fmt"

func main(){
  var key byte
  fmt.Println("请输入一个字符：a b c d")
  fmt.Scanf("%c", &key)
  
  switch key {
    case 'a':
    		fmt.Println("周一")
    case 'b':
    		fmt.Println("周二")
    case 'c':
    		fmt.Println("周三")
    case 'd':
    		fmt.Println("周四")
  	default:
    		fmt.Println("输入有误")
  }
  
  // switch后面不接表达式
  var score int = 90
  switch {
    case score > 90:
    		fmt.Println("优秀")
    case score >= 70:
    		fmt.Println("良好")
    case score > 60:
    		fmt.Println("及格")
    default:
    		fmt.Println("不及格")
  }
  
  var month byte
  fmt.Println("请输入月份")
  fmt.Scanln(&month)
  switch month{
    case 3,4,5:
    		fmt.Println("spring")
    case 6,7,8:
    		fmt.Println("summer")
    case 9,10,11:
    		fmt.Println("autumn")
    case 12,1,2:
    		fmt.Println("winter")
    default:
    		fmt.Println("输入有误")
  }
  
  // fallthrogh：只能穿透一层
  var num int = 10
  switch num{
    case 10:
    		fmt.Println("ok1")  // ok1
    		fallthrough // 穿透一层。
    case 20:
    		fmt.Println("ok2")   // ok2
    case 30:
    		fmt.Println("ok3")
    default 
    		fmt.Println("没有匹配到")
  }
}

for

  • for基本遍历方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main
import "fmt"

func main(){
  // 写法1：常规写法
  for i := 1;i <= 10;i++{
    fmt.Println("hello golang")
  }
  
  // 写法2
  i := 1  // 循环变量的初始化
  for i <= 10{  // 循环条件
    fmt.Println("hello golang")
    i++ // 循环变量迭代
  }
  
  // 写法3
  k := 1
  for ;;{
    if k <= 10:{
      fmt.Println("ok", k)
    } else {
      break   // 跳出循环
    }
    k++
  }
}

  • 字符串的for-range：

  • 如果字符串中有中文，传统的方式是按照字节遍历，utf-8中一个字节占据3个字节；解决办法：将字符转成[]rune类型的切片。

  • for-range方式使用的是字符方式遍历

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package main
    import "fmt"

    func main(){
      var str string = "hello, world!北京"
      str1 := []rune(str)   // 强制转换成切片
      for i := 0; i < len(str1); i++{
        fmt.Println("%c\n",str1[i])
      }

      // for-range循环
      for  index, value := range str {
        fmt.Println("index=%d value=%c \n", index, value )
      }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main
import "fmt"

// 1-100 之间9的倍数的个数及所有数的总和
func main(){
  count := 0
  sum := 0
  for i:= 1;i <= 100; i++{
    if i % 9 == 0{
      sum += i
      count++
    }
  }
  fmt.Println(count,sum)
  
  
  // 按照格式输出
  var n int = 6
  for i := 0;i <= n;i++{
    fmt.Println("%v + %v = %v \n", i, n-i, n)
  }
}

while

go语言中没有while语法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 输出10句`hello world`

package main
import "fmt"

func main(){
  // 方式1
  var i int = 1
  for {
    if i > 10{  // 大于10跳出循环
      break
    }
    fmt.Println("hello world")
    i++
  }
  fmt.Println(i)  // 结束的时候i是1
  
  
  // 方式2：使用do...while形式来实现
  var j int = 1
  for {
    ftm.Println("hello world", j)
    j++  // 循环迭代
    if j > 10{
      break
    }
  }
}

多重循环控制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 3个班，每个班5个同学，求出每个班的平均分和所有班的平均分

package main
import "fmt"

func main(){
  
  var totalSum float64 = 0.0
  var passCount int = 0
  // 2. 再对3个班级进行循环
  for j :=1;j <= 3; j++{  
    // 1. 先求出一个班级的平均分
    sum := 0.0
    for i :=1;i <= 5;i++{
      var score float64
      fmt.Printf("请输入第%d个学生的成绩 \n", i)
      fmt.Scanln(&score)
      // 统计总分
      sum += score
      // 统计及格人数
      if score >= 60{
        passCount++ 
      		}
    	}
    	fmt.Printf("第%d个班的平均分是%v \n", j, sum / 5)
    // 3. 各个班级的总成绩进行累加
    totalSum += sum
    } 
  fmt.Printf("各个班级的总成绩%v   所有班级的平均分是%v\n", totalSum, totalSum / (5*3))
  fmt.Printf
}

金字塔案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package main
import "fmt"

// 1. 打印矩形
/*
   ***
   ***
   ***
*/

// 2. 打印半个金字塔
/*
   *
   **
   ***
*/

// 3. 打印金字塔
/*
    *    1层1个     规律：2 * 层数 - 1  空格2:总层数-当前层数i 
   ***   2个3个
  *****  3层5个
*/

// 4. 将层数做成变量：

// 5. 打印空金字塔
// 规律：只有开头和结束是*，其余部分是空的
// 特殊情况：最后一层都是*
/*
     *
    * *
   *   *
*/

func main(){
  var totalLevel int = 9
  
  for i:=1; i <= totalLevel;i++{  // i表示层数
    // 打印空格
    for k := 1;k <= totalLevel - i;k++{
      fmt.Print(" ")
    }
    
    for j :=1;j <= 2 * i - 1;j++{  // j表示每层打印多少个*
      // 打印空金字塔
      if j == 1 || j == 2 * i-1 || i == totalLevel {
      		fmt.Print("*")
      } else{
        fmt.Print(" ")
      }
      
    }
    fmt.Println()   // 换行操作 
  }
}

KzSS7d.png

九九乘法表

1
2
3
4
5
6
7
8
9
10
11
package main
import "fmt"

func main(){
  for i:=1;i<=9;i++{
    for j := 1; j <= i;j++{
      fmt.Printf("%v * %v = %v\t", j,i,j*i)   // 制表符
    }
    fmt.Println()   // 打印空行
  }
}

break

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main
import "fmt"

// 随机生成0-100的一个数，直到生成99这个数，总共用了多少次

func main(){
  var count int = 0 
  for {
      // time.Now().UnixNano() :生成一个从1970-01-01 00:00:00到现在的秒数 
    rand.Seed(time.Now().UnixNano())
    // 生成0-100的随机数
    n := rand.Intn(100) + 1 
    count ++
    if n == 99 {
      break   // n为99直接终止当前循环
    }
  }
  fmt.Println(count)
}
  • 通过标签label指定跳到哪一层
  • break语句只能跳出离它最近的for循环
1
2
3
4
5
6
7
8
9
10
func main(){
  for i := 0; i<4; i++{
    for j := 0; j<10; j++{
      if j == 2{
        break
      }
      fmt.Println(j)  // j=0,j=1  循环4次
    }
  }
}

KzwmSH.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 标签使用
package main
import "fmt"

func main(){
  label2:
  for i := 0; i<4; i++{
    // lable1
    for j := 0; j<10; j++{
      if j == 2{
        // break lable1 // 结果同上面
        break label2   // 设置标签，直接跳出整个循环
      }
      fmt.Println(j)  // j=0,j=1  仅仅一次
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main
import "fmt"

func main(){
  // 0-100 求和，求出当和大于20时候的当前数
  sum := 0
  for i := 1;i <= 100;i++{
    sum += i
    if sum > 20{
      fmt.Println("当前数是",i)
      break
    }
  }
  
  // 3次登陆机会，密码和账号正确则成功；否则提示还有几次机会
  var name string
  var pwd string
  var loginChance = 3
  for i := 1;i<=3;i++{
    fmt.Println("输入用户名")
    fmt.Scanln(&name)
    fmt.Println("输入密码")
    fmt.Scanln(&pwd)
    
    if name == "张无忌" && pwd == "888"{
      fmt.Println("恭喜登陆成功")
      break
    }else {
      loginChance-- 
      fmt.Println("还有%v次机会，请珍惜\n",loginChance)
    }
    if loginChance == 0{
      fmt.Println("机会用完了，没有登陆成功")
    }
  }
}

continue

结束本次循环，继续执行下次循环；也可以通过指明标签来指定跳转到某个循环中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main
import "main"

func main(){
  for i:=0;i<4;i++{
    for j := 0;j<10;j++{
      if j == 2{
        continue    // 跳出j=2
      }
      fmt.Println("j=",j)
    }
  }
}

/*
j=1
j=3
...
j=9
输出4次上面的结果，每次没有j=2  
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main
import "fmt"

// 标签使用

/*
i=0,j=1
i=1,j=1
*/
here:
func main(){
  for i:=0;i<2;i++{
    for j:=1;j<4;j++{
      if j==2{
        continue here
      }
      fmt.Println("i=",i,"j="j)
    }
  }
}

goto

  • goto语句可以无条件的转移到程序中指定的行
  • 通常和条件语句配合使用，用来实现条件转移
  • 不主张使用goto语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main
import "main"

func main(){
  var n int = 30
  fmt.Println("ok1")
  if n > 20{
    goto label1    // 直接跳过下面两句话
  }
  fmt.Println("ok2")
  fmt.Println("ok3")
  label1:  // 直接到这里的
  fmt.Println("ok4")
  fmt.Println("ok5")
  fmt.Println("ok6")
  fmt.Println("ok7")
}

return

return使用在方法或者函数中，遇到它，则跳出整个函数或方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main
import "main"

func main(){
  var n int = 30
  fmt.Println("ok1")
  if n > 20{
    return   // 直接跳过下面所有的语句
  }
  fmt.Println("ok2")
  fmt.Println("ok3")
  fmt.Println("ok4")
  fmt.Println("ok5")
  fmt.Println("ok6")
  fmt.Println("ok7")
}

本文标题:Golang之旅29-流程控制

发布时间:2019年11月05日 - 15:11

原始链接:http://www.renpeter.cn/2019/11/05/Golang%E4%B9%8B%E6%97%8529-%E6%B5%81%E7%A8%8B%E6%8E%A7%E5%88%B6.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

Coffee or Tea