GO基础篇 (三) 、流程控制及函数

一、流程控制

Go语言提供了一些基本的流程控制结构，包括条件语句、循环语句和选择语句。以下是这些流程控制结构的简要介绍：

1. 条件语句（if-else）

if语句：

if condition {
    // 当条件为真时执行
} else {
    // 当条件为假时执行
}

示例：

package main

import "fmt"

func main() {
    x := 10

    if x > 5 {
        fmt.Println("x 大于 5")
    } else {
        fmt.Println("x 不大于 5")
    }
}

2. 循环语句

for循环：

for initialization; condition; update {
    // 循环体
}

示例：

package main

import "fmt"

func main() {
    // 基本的 for 循环
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }

    // 无限循环
    j := 0
    for {
        if j >= 5 {
            break
        }
        fmt.Println(j)
        j++
    }
}

终止循环

break ： 结束整个循环，立即停止

continue ：结束当前这次循环，继续进行下一次循环

package main

import "fmt"

func main() {

   for i := 1; i <= 10; i++ {
      if i == 5 {
         //break
         continue // 到这里就结束了当次循环，不会向下了，继续从头开始
      }
      fmt.Println(i)
   }

}

3. 选择语句（switch）

switch expression {
case value1:
    // 当 expression == value1 时执行
case value2:
    // 当 expression == value2 时执行
default:
    // 如果以上条件都不满足时执行
}

示例：

package main

import "fmt"

func main() {
    day := "Saturday"

    switch day {
    case "Monday", "Tuesday", "Wednesday", "Thursday", "Friday":
        fmt.Println("工作日")
    case "Saturday", "Sunday":
        fmt.Println("周末")
    default:
        fmt.Println("无效的日期")
    }
}

特殊的情况：需要多个条件结果的输出时，需要case穿透 。fallthrough

package main

import "fmt"

func main() {

   a := false

   // 这里的爆红不影响
   switch a {
   case false:
      fmt.Println("1") // 默认只会输出1
      fallthrough      // 在case中 一旦使用了 fallthrough，则会强制执行下一个case语句
   case true:
      fmt.Println("2")
   case false:
      fmt.Println("3")
   case true:
      fmt.Println("4")
   case false:
      fmt.Println("5")
   default:
      fmt.Println("6")
   }
}

打印的结果为 1 2

小例子:输出矩阵

package main

import "fmt"

/*
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
 */
func main() {
   // for循环的嵌套
   for i := 1; i <= 5; i++ {
      for j := 0; j < 5; j++ {
         fmt.Print("* ")
      }
      fmt.Println()
   }
}

二、函数

1.什么是函数

在Go语言中，函数（Function）是一段封装了一系列语句的代码块，具有特定功能的独立单元。函数是结构化编程的基本组成部分，它允许你将代码划分为小块，以便更好地组织和重用。

Go语言中的函数有以下基本特点：

1. 声明： 使用 func 关键字进行声明。

   func functionName(parameters) returnType {
       // 函数体
   }
   

   • functionName：函数名
   • parameters：参数列表
   • returnType：返回值类型

2. 参数： 函数可以接受零个或多个参数，这些参数是函数执行时传递给函数的值。

   func add(x, y int) int {
       return x + y
   }
   

3. 返回值： 函数可以返回一个或多个值。

   func divide(dividend, divisor float64) (float64, error) {
       if divisor == 0 {
           return 0, errors.New("division by zero")
       }
       return dividend / divisor, nil
   }
   

4. 多返回值： Go语言支持多返回值。

   func swap(x, y int) (int, int) {
       return y, x
   }
   

5. 匿名函数： 可以创建匿名函数，也称为闭包。

   add := func(x, y int) int {
       return x + y
   }
   

6. 函数作为参数： 函数可以作为另一个函数的参数。

   func operate(x, y int, operation func(int, int) int) int {
       return operation(x, y)
   }
   

7. 函数作为返回值： 函数可以作为另一个函数的返回值。

   func multiplyBy(factor int) func(int) int {
       return func(x int) int {
           return x * factor
       }
   }
   

2.可变参数

package main

import "fmt"

func main() {
   fmt.Println(getSum())
}

// 可变参数： 一个函数的参数类型确定，参数的个数不确定，可以使用可变参数
// 可变参数如果有多个参数必须放在最后一个参数

// 求和 , 参数是可变的，int
func getSum(nums ...int) int {
   sum := 0
   fmt.Println("可变参数的长度为：", len(nums))
   for i := 0; i < len(nums); i++ {
      fmt.Println("可变参数", i, ":", nums[i])
      // 取出来
      //sum = sum + nums[i]
      sum += nums[i]
   }
   return sum
}

// 了解传递了多少个数字  len()函数，获取可变参数的长度

3.递归函数

package main

import "fmt"

/*
定义：一个函数自己调用自己，就叫做递归函数
注意：递归函数需要有一个出口，逐渐向出口靠近，没有出口就会形成死循环。
*/
package main

import "fmt"

func factorial(n int) int {
    // 基本情况：阶乘 0 和 1 都为 1
    if n <= 1 {
        return 1
    }

    // 递归情况：n 的阶乘等于 n 乘以 (n-1) 的阶乘
    return n * factorial(n-1)
}

func main() {
    result := factorial(5)
    fmt.Println("5的阶乘是:", result)
}