Go基础:理解For, If Else, Switch, Functions, Range, 闭包, 递归

了解 Go 中的控制流程构造，了解函数和其应用，包括闭包和递归。

full lessons here👇:
https://programmerscareer.com/zh-cn/golang-basic-skill/

由AI生成，可能有错误，仅供参考

主题：For、If Else、Switch

控制流是所有编程语言的重要方面。它确定了代码执行的顺序。在 Golang 中，这些主要是 if-else、for 和 switch。

For 循环：

for 循环是 Go 语言中唯一的循环结构。下面是一个基本的 for 循环：

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

这个 for 循环打印从 0 到 9 的数字。

If-Else 构造：

if 语句允许您的程序条件地执行代码。您可以将多个 if 语句组合使用 else if 或 else。

num := 10
if num%2 == 0 {
    fmt.Println(num, "是偶数")
} else {
    fmt.Println(num, "是奇数")
}

这个 if-else 构造打印出一个数字是否为偶数或奇数。

Switch Case 构造：

switch 语句是一种更短的方式来写一系列 if-else 语句。它运行第一个值与条件表达式相等的 case。下面是一个示例：

fruit := "Apple"
switch fruit {
case "Apple":
    fmt.Println("这是一个苹果")
case "Banana":
    fmt.Println("这是一个香蕉")
default:
    fmt.Println("这不是苹果也不是香蕉")
}

这个 switch case 构造根据 fruit 变量的值打印出一条语句。

主题：函数

现在让我们来探索 Go 语言中的函数！

函数声明：

Go 语言中的函数使用 func 关键字定义。下面是函数声明的通用语法：

func functionName(parameterName parameterType) returnType {
    // 函数体
}

例如，下面是一个简单的函数，它将两个整数作为参数，并返回它们的和：

func addNumbers(num1 int, num2 int) int {
    return num1 + num2
}

函数参数：

我们的 addNumbers 函数拥有两个参数 num1 和 num2，它们都是整型。在 Go 语言中，函数参数在括号中提供，紧随函数名。

返回类型：

我们的 addNumbers 函数也返回一个整型值。函数的返回类型在函数参数和函数体之间指定。使用 return 语句在函数体中指定要返回的结果。

主题：使用 range 在 Go 中

Go 语言中的 range 关键字用于 for 循环来遍历数组、切片、字符串或映射的项目。

range 在数组中：

下面是一个使用 range 与数组的示例：

numbers := [6]int{10, 20, 30, 40, 50, 60}
for i, num := range numbers {
    fmt.Printf("The element at index %d is %d\n", i, num)
}

在这个示例中，range 返回两个值：索引和该索引对应的值。

range 在切片中：

range 对切片工作方式与数组相同。如果您使用的是切片，而不是数组，这个代码仍然有效。

range 在映射中：

当用于映射时，range 返回键和值。下面是一个示例：

m := make(map[string]int)
m["key1"] = 10
m["key2"] = 20
for k, v := range m {
    fmt.Printf("The value at key %s is %d\n", k, v)
}

range 提供了一种简单和直观的方式来遍历数组、切片和映射在 Go 语言中。

Topic: Go 中的闭包

闭包是一种特殊的匿名函数。匿名函数可以通过捕捉周围作用域中的变量来形成闭包。

定义闭包：

在 Go 中，闭包是在需要它们的地方定义的，并且可以将它们赋值给一个变量或立即调用。下面是一个简单的示例：

func main() {
    sum := func(a, b int) int {
        return a + b
    }
    result := sum(3, 4)
    fmt.Println(result) // Prints: 7
}

在这个示例中，我们定义了一个匿名函数，它将两个整数作为参数，并返回它们的和。我们立即将这个函数赋值给变量 sum，使得 sum 成为一个闭包。

理解闭包：

闭包可以访问其周围作用域中的变量。在下面是一个简单的闭包，它保持状态：

func counter() func() int {
    var count int
    return func() int {
        count++
        return count
    }
}
func main() {
    count := counter()
    fmt.Println(count()) // Prints: 1
    fmt.Println(count()) // Prints: 2
    fmt.Println(count()) // Prints: 3
}

在这个示例中，counter 函数返回另一个函数，这个函数形成了对 count 变量的闭包。每次调用这个返回函数时，它将增加 count 并返回其值。这 count 变量会跨越多个对 count() 函数的调用，但不能在外部访问。

Topic: Go 中的更多闭包

让我们更深入地探讨 Go 中的闭包概念。需要注意的是，Go 支持闭包，这意味着函数可以拥有一个“包含”环境，持有自己的变量。

考虑以下示例：

package main
import "fmt"
func intSeq() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}
func main() {
    nextInt := intSeq()
    fmt.Println(nextInt())
    fmt.Println(nextInt())
    fmt.Println(nextInt())
    newInts := intSeq()
    fmt.Println(newInts())
}

在这个示例中，我们调用 intSeq()，将结果赋值给 nextInt。这个 nextInt 函数值捕捉了自己的 i 值，这个值将在每次调用 nextInt 时被更新。

为了确认状态是唯一的，可以创建和测试一个新的函数。

输出结果将是：

1
2
3
1

这个闭包的特性允许我们使用它们来实现更多有趣的事情，例如 nextInt := intSeq()。根据您所做的事情，使用闭包与封装数据可以使您的程序具有良好的结构。

Topic: Go 中的递归

递归是指函数调用自己直接或间接地。对应的函数称为递归函数。

理解递归：

让我们来看一个简单的递归函数示例：

package main
import "fmt"
func recurse(count int) {
    if count <= 0 {
        fmt.Println("All done!")
        return
    }
    fmt.Println(count)
    recurse(count - 1)
}
func main() {
    recurse(5)
}

在这个函数中，recurse 函数打印，然后调用自己与递减的计数器直到计数器变为 0。每个嵌套调用都有自己的 count 变量，它们不会互相干扰。

乘积递归函数：

乘积函数是一个经典的递归示例：

func factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * factorial(n-1)
}
func main() {
    fmt.Println(factorial(5)) // Prints: 120
}

在这个 factorial 函数中，它调用自己，乘以 n 和前一个函数的结果直到它降低到 0，然后开始解开，返回计算值。

请注意，在使用递归时需要确保基准情况是可达的。

English post: https://programmerscareer.com/go-basic-03/
作者：Wesley Wei – Twitter Wesley Wei – Medium
注意：本文为作者原创，转载请注明出处。

Medium

LinkedIn

Wechat(微信公众号)

X