Golang 基础赋能（二）

go 语⾔循环语句

在 go 语⾔中不⽀持 while 语句，它只有 for 循环，表达式如下 
  1. 1.for init; condition; post {
  2.     }
  3. ex:
  4. for i := 0; i <= 10; i++ {
  5. sum += i
  6. }
  7. 2.for condition {
  8. }
  9. ex:
  10. for ; sum <= 10; {
  11. sum += sum
  12. }
  13. ps：表达式中的init和post都是可以省略的，；也可以省略
  15. 如何表达⽆限循环
  16. for true {
  17. sum += sum
  18. }

循环控制语句

如何在循环体内控制整个循环，在 go 中提供了 3 个控制语句 
  1. 1.break语句 -- ⽤于中断当前for循环或跳出switch语句
  2. ex：
  3. for i := 0; i < 5; i++ {
  4.     if i == 3 {
  5.         break // 当 i 等于 3 时跳出循环
  6.     }
  7.     fmt.Println(i)
  8. }
  10. 2.continue语句 -- ⽤于跳过当前循环，进⼊到下⼀次循环中
  11. ex：
  12. for a < 5 {
  13.     if a == 3 {
  14.     /* 跳过此次循环 */
  15.         a = a + 1;
  16.         continue;
  17.     }
  18.     fmt.Printf("a 的值为 : %d\n", a);
  19.     a++;
  20. }
  22. 3.goto语句 -- 跳到指定⾏
  23. ex：
  24. var a int = 1
  25. /* 循环 */
  26. for a < 5 {
  27.     if a == 3 {
  28.         /* 跳过迭代 */
  29.         a = a + 1
  30.         goto Test
  31.     }
  32.     fmt.Printf("a的值为 : %d\n", a)
  33.     a++
  34. }
  36. Test:
  37.     fmt.Println(a)

函数

如同其他的语⾔有函数⼀样， go ⾃然也拥有函数的概念，接下来我们看⼀下在 golang 中式如何定义函数的 
  1. 1.函数定义
  2. 表达式如下：
  3. func function_name(参数1,参数2 类型) [返回类型] {
  4.     函数内容
  5. }
  7. ex：
  8. func max(num1, num2 int) int {
  9.     /* 声明局部变量 */
  10.     var result int
  11.     if (num1 > num2) {
  12.         result = num1
  13.     } else {
  14.         result = num2
  15.     }
  16.     return result
  17. }
  19. 与python这些动态语⾔不同， go是静态语⾔，因此需要在传参数的时候标记参数的类型，并且如果该函数中有返回
  20. 值，同时还需要表示出返回值的类型
  22. 2.函数调⽤
  23. func main() {
  24.     /* 定义局部变量 */
  25.     var a int = 100
  26.     var b int = 200
  28.     /* 调⽤函数并返回最⼤值 */
  29.     ret := max(a, b)
  31.     fmt.Printf( "最⼤值是 : %d\n", ret )
  32. }
  34. /* 函数返回两个数的最⼤值 */
  35. func max(num1, num2 int) int {
  36.     /* 定义局部变量 */
  37.     var result int
  39.     if (num1 > num2) {
  40.         result = num1
  41.     } else {
  42.         result = num2
  43.     }
  44.     return result
  45. }

变量作⽤域

go 语⾔与中其他语⾔⼀样，提供了内置的错误异常机制，并针对错误异常机制，提供了处理错误的⽅式 
  1. go语⾔中的异常可以划分到类型中，他和int、 string等类型是⼀个级别的，所以我们可以经常看到在golang的那些
  2. 程序中，会返回⼀个error类型的返回值，这就是go语⾔中的异常
  4. 1.如何创建⼀个异常
  5. //go语⾔作为⼀个流⾏语⾔，⾃然具有让⽤户⾃定义异常的⽅式，具体⽅式如下所示
  6. errors.New("test")
  8. 2.异常处理
  9. ex：
  10. （1）写⼀个函数，并返回⼀个异常
  11. func Sqrt(f float64) (float64, error) {
  12.     if f < 0 {
  13.     //返回⼀个异常
  14.     return 0, errors.New("test")
  15.     }
  16. }
  17. （2）接受异常，并进⾏处理
  18. result, err:= Sqrt(-1)
  20. //判断异常是否为空，如果异常为空，返回的值⼀般是nil
  21. if err != nil {
  22.     fmt.Println(err)
  23. }
  25. 如上所示，其实在golang中的异常处理⾮常简单，因为它可以简单理解成⼀个对象，因此如何处理完全是在⽤户⾃⼰
  26. 的⼿中，你调⽤⼀个函数，该函数返回异常之后，⽤户可以选择在这个异常之后进⾏各种处理