return的使用

1 break的作用：

　　使用循环语句，有时需要跳出当前循环；或者多层嵌套循环时，需要跳出到指定层数的循环。

用法直接上demo

1 获取到程序需要的数据后，跳出当前循环

 1 // 生成一个1~100之间的随机数，当随机到99的时候退出循环，并输出生成次数
 2 count := 0
 3 rand.Seed(time.Now().Unix())
 4 for {
 5     random := rand.Intn(100) + 1
 6     fmt.Println(random)
 7     count++
 8     if random == 99 {
 9         break
10     }
11 }
12 
13 fmt.Println("一共随机了", count, "次")

2 跳出到指定循环

 1 // 多层嵌套循环时，可以使用break跳出置顶层数的循环，用法如下：
 2 // label1:
 3 tag1:// label的名称可以自定义
 4 for i := 1; i <= 5; i++ {
 5     // label2:
 6     for j := 1; j <= 5; j++ {
 7         if j == 2 {
 8             // break // 默认跳出当前循环
 9             // break label2 // 跳出当前循环label2
10             // break label1 // 跳出上上级循环label1
11             break tag1
12         }
13         fmt.Println(j)
14     }
15 }

练习题

 1 // 习题1
 2 // 100以内的数求和，求出当和第一次大于20的当前数
 3 var sum int = 0
 4 for i := 1; i <= 100; i++ {
 5     sum += i
 6     if sum >= 20 {
 7         fmt.Println("当前数字为：", i)
 8         break
 9     }
10 }

 1 // 习题2
 2 // 实现登陆验证，有三次登陆错误机会，若账号“张无忌”，密码“8888”登陆则提示登陆成功，否则提示还有几次登陆机会
 3 count := 3
 4 var username string
 5 var password string
 6 for i := 1; i <= 3; i++ {
 7     count--
 8     fmt.Println("请输入用户名：")
 9     fmt.Scanln(&username)
10     fmt.Println("请输入密码：")
11     fmt.Scanln(&password)
12     if username == "张无忌" && password == "8888" {
13         fmt.Println("登陆成功")
14         break
15     } else {
16         fmt.Printf("还有 %d次登陆机会\n", count)
17     }
18 }

2 continue的作用：

　　不执行该次循环continue下面的代码，跳出当次循环，继续下次循环；也可通过标识标出到指定层数的循环

直接上demo

1 // 习题1 
2 // 实现打印1~100之内的奇数，要求用for循环+continue
3 for i := 1; i <= 100; i++ {
4     if i % 2 == 0 {
5         // 偶数
6         continue
7     }
8     fmt.Println(i)
9 }

 1 // 习题2
 2 // 从键盘输入不确认数量的整数，并判断输入整数和负数的个数，输入为0时输出数量并结束程序
 3 // ps:使用for循环，break/continue完成
 4 // 整数positive，负数nagative
 5 var positiveCount int = 0 // 正数个数
 6 var nagativeCount int = 0 // 负数个数
 7 var interge int
 8 for {
 9     fmt.Println("请输入整数：")
10     fmt.Scanln(&interge)
11     if interge > 0 {
12         // 正数
13         positiveCount++
14         continue
15     }
16     if interge < 0 {
17         // 负数
18         nagativeCount++
19         continue
20     }
21     if interge == 0 {
22         // 0，结束程序
23         // 输出数量
24         fmt.Printf("正数%v个，负数%v个\n", positiveCount, nagativeCount)
25         break
26     }
27 }

 1 // 习题3
 2 // 某人有100,000元，每经过一个路口都需要缴费，缴费规则如下：
 3 // 1.当现金>50000元时，缴费5%
 4 // 2.当现金<=50000元时，缴费1000元
 5 // 计算该用户可经过多少个路口，使用for/break方式完成
 6 var intersectionCout int = 0 // 路口数量
 7 money := 100000
 8 for1:
 9 for {
10     if money > 50000 {
11         // 缴费5%
12         money -= money*5/100
13         intersectionCout++
14         continue
15     }
16     if money <= 50000 {
17         // 缴费1000
18         // for2:
19         for {
20             if money >= 1000 {
21                 money -= 1000
22                 intersectionCout++
23                 continue
24             } else {
25                 fmt.Printf("余额%v已不足1000，已经过%v个路口\n", money, intersectionCout)
26                 break for1
27             }
28             
29         }
30     }
31 }

3 goto的作用

　　1 go语言的goto可以无条件的转移到程序中指定的行

　　2 goto语句通常和条件语句配合使用。可用来实现条件转移，跳出循环体等功能

　　3 在go语言程序设计中一般不主张使用goto语句，以免造成程序流程的混乱，使理解和调试程序产生困难

demo

 1 fmt.Println("请输入一个数字：")
 2 var num byte
 3 fmt.Scanln(&num)
 4 if num <= 1 {
 5     goto label1
 6 } else if num >= 4 && num <= 6 {
 7     goto label2
 8 } else {
 9     goto label3
10 }
11 label1:
12 fmt.Println("tag1")
13 fmt.Println("tag2")
14 fmt.Println("tag3")
15 label2:
16 fmt.Println("tag4")
17 fmt.Println("tag5")
18 fmt.Println("tag6")
19 label3:
20 fmt.Println("tag7")
21 fmt.Println("tag8")
22 fmt.Println("tag9")

4 return的作用

　　结束当前函数或程序运行，或同时返回参数

自定义包的demo

 1 package compute
 2 
 3 import "math"
 4 
 5 func DigitalCompute(n1 float64, n2 float64, operator byte) float64 {
 6     var result float64
 7     switch operator {
 8     case '+':
 9         result = n1 + n2
10     case '-':
11         result = n1 - n2
12     case '*':
13         result = n1 * n2
14     case '/':
15         result = n1 / n2
16     case '%':
17         result = math.Mod(n1, n2)
18     }
19     return result
20 }