深入掌握 Go 语言中的数值类型与循环技巧

原创于 2024-09-05 14:05:49 发布 · 861 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#golang #开发语言 #后端 #go1.19 #go

《Go语言编程全解--理论与实践》专栏收录该内容

25 篇文章

订阅专栏

数值数据类型

Go 语言原生支持整数、浮点数以及复数。以下部分将详细介绍 Go 支持的各种数值类型。

整数

Go 提供了四种不同大小的有符号和无符号整数类型，分别为 int8、int16、int32 和 int64，以及 uint8、uint16、uint32 和 uint64。每种类型名称中的数字表示该类型使用的位数。

此外，还有 int 和 uint 类型，它们是你当前平台上最有效的有符号和无符号整数。因此，如果不确定该用哪种整数类型时，通常可以选择 int 和 uint，但需要注意它们的大小随架构的不同而变化。

有符号和无符号整数的区别在于：如果一个整数是 8 位且没有符号，那么它的取值范围是从二进制的 00000000（0）到二进制的 11111111（255）。如果它带符号，那么取值范围是 -127 到 127。这是因为有符号整数使用第八位来表示符号，因此只有七位可以用于存储数值。其他大小的有符号和无符号整数遵循相同的规则。

浮点数

Go 支持两种浮点数类型：float32 和 float64。float32 提供大约六位小数的精度，而 float64 则提供 15 位精度。

复数

与浮点数类似，Go 提供了两种复数类型：complex64 和 complex128。complex64 使用两个 float32，一个用于表示复数的实部，另一个用于表示虚部；而 complex128 使用两个 float64。复数的形式为 a + bi，其中 a 和 b 是实数，i 是方程 x² = -1 的解。

以下代码展示了这些数值类型的使用：

package main
import (
    "fmt"
)

func main() {
    c1 := 12 + 1i
    c2 := complex(5, 7)
    fmt.Printf("c1 类型: %T\n", c1)
    fmt.Printf("c2 类型: %T\n", c2)
    var c3 complex64 = complex64(c1 + c2)
    fmt.Println("c3:", c3)
    fmt.Printf("c3 类型: %T\n", c3)
    cZero := c3 - c3
    fmt.Println("cZero:", cZero)
}

在这个代码中，我们进行了一些复数运算。创建复数的方式有两种：直接像 c1 和 c2 那样，或通过现有复数的运算间接创建，例如 c3 和 cZero。

代码的第二部分如下：

x := 12
k := 5
fmt.Println(x)
fmt.Printf("x 的类型: %T\n", x)
div := x / k
fmt.Println("div", div)

这里，我们处理有符号整数。需要注意的是，当你将两个整数相除时，Go 会执行整数除法并返回商，而不会返回小数部分。例如，将 11 除以 2 会返回 5，而不是 5.5。

代码的最后一部分如下：

var m, n float64
m = 1.223
fmt.Println("m, n:", m, n)
y := 4 / 2.3
fmt.Println("y:", y)
divFloat := float64(x) / float64(k)
fmt.Println("divFloat", divFloat)
fmt.Printf("divFloat 类型: %T\n", divFloat)

在这一部分，我们处理浮点数。通过 float64() 可以告诉 Go 在进行整数相除时创建一个浮点数。如果你尝试直接进行整数与浮点数的运算（例如 float64(x) / k），则会出现类型不匹配的错误。

运行上述代码会产生以下输出：

c1 类型: complex128
c2 类型: complex128
c3: (17+8i)
c3 类型: complex64
cZero: (0+0i)
12
x 的类型: int
div 2
m, n: 1.223 0
y: 1.7391304347826086
divFloat 2.4
divFloat 类型: float64

当你将浮点数转换为整数时，Go 会舍弃小数部分，导致数据丢失。

Go 循环

Go 支持循环结构来处理多种数据类型。以下介绍 Go 中的 for 循环。

`for` 循环

for 循环允许你根据条件或数据的大小迭代执行代码。最常见的用法是遍历数组、切片或 map 的所有元素。Go 不支持 while 关键字，但 for 循环可以替代 while 循环的功能。

最简单的 for 循环形式如下：

for i := 0; i < 100; i++ {
}

通常，for 循环包含三个部分：初始化、条件判断和循环后操作。这些部分都是可选的。在上面的例子中，i 从 0 开始递增到 99，当 i 到达 100 时，循环停止。

如果在循环结束后 i 是局部变量，它将会被垃圾回收。如果 i 在循环外定义，则它的值会保留，且在循环结束时为 100。

可以使用 break 关键字提前退出循环，也可以用 continue 跳过当前迭代并继续下一次循环。

`while` 循环

虽然 Go 没有 while 关键字，但可以使用 for 循环来模拟 while 循环。例如：

for {
    // 无限循环，直到 break
}

你需要手动使用 break 关键字来退出循环。

还可以使用类似 do...while 的结构：

for ok := true; ok; ok = 条件 {
    // 执行代码
}

当 ok 为 false 时，循环终止。

`range` 关键字

Go 还提供了 range 关键字，用于遍历数组、切片或 map。使用 range 时，不需要知道数组的长度。以下是一个简单的例子：

anArray := [5]int{0, 1, -1, 2, -2}
for i, value := range anArray {
    fmt.Println("索引:", i, "值:", value)
}

这个 range 循环会返回两个值：索引和对应的元素值。

多个循环示例

以下是一些 for 循环的示例代码：

package main
import (
    "fmt"
)

func main() {
    for i := 0; i < 100; i++ {
        if i%20 == 0 {
            continue
        }
        if i == 95 {
            break
        }
        fmt.Print(i, " ")
    }
    fmt.Println()
    
    i := 10
    for {
        if i < 0 {
            break
        }
        fmt.Print(i, " ")
        i--
    }
    fmt.Println()

    i = 0
    anExpression := true
    for ok := true; ok; ok = anExpression {
        if i > 10 {
            anExpression = false
        }
        fmt.Print(i, " ")
        i++
    }
    fmt.Println()

    anArray := [5]int{0, 1, -1, 2, -2}
    for i, value := range anArray {
        fmt.Println("索引:", i, "值:", value)
    }
}

运行这段代码会产生以下输出：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 21 22 23 24 25 26 27 28 29
...
10 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9 10 11
索引: 0 值: 0
索引: 1 值: 1
索引: 2 值: -1
索引: 3 值: 2
索引: 4 值: -2

这个例子展示了 for 循环的基本使用，以及如何使用 continue、break 和 range 关键字进行更灵活的循环控制。