本文深入探讨了 Go 语言的内置类型系统，从布尔类型到复杂的字符串类型，旨在为开发者提供全面而详尽的指导，通过丰富的代码示例和应用场景，揭示了如何在实际项目中高效地运用这些类型。

在编程中，类型（type）可以被看作是值（value）的模板，而值则可以被看作是类型的实例。在这篇文章里，我们专注于介绍Go语言的内置（或称为预声明的）基本类型和它们字面量的表示形式。这里并不涉及组合类型。

一、布尔类型

定义

在 Go 语言中，布尔类型用关键字 bool 表示，它有两个预定义的常量值：true 和 false。

var myBool bool = true

基础用法

声明与初始化

布尔变量可以在声明时初始化，也可以稍后进行赋值。

// 声明并初始化
var isReady bool = true

// 声明后赋值
var isEnabled bool
isEnabled = false

逻辑运算

布尔类型主要用于逻辑运算：AND (&&), OR (||), 和 NOT (!)。

// AND 操作
result := true && false  // 输出：false

// OR 操作
result = true || false  // 输出：true

// NOT 操作
result = !true  // 输出：false

进阶用法

条件语句

布尔类型经常用于 if, else if 和 else 结构中。

if isReady {
    fmt.Println("System is ready.")
} else {
    fmt.Println("System is not ready.")
}

循环结构

布尔表达式也可用于控制循环结构如 for。

for isReady {
    // 执行代码
}

函数返回值

布尔类型也经常用作函数的返回类型，以指示函数是否成功执行或验证。

func isAuthenticated() bool {
    // 认证逻辑
    return true
}

常见错误与陷阱

1. 零值：布尔类型的零值为 false，需注意未初始化的布尔变量默认为 false。
2. 类型转换：Go 语言不允许布尔类型与其他类型（如整数）进行隐式转换。

二、整数类型

定义

在 Go 语言中，整数类型主要分为两大类：带符号（Signed）和无符号（Unsigned）的整数，同时还有一个特殊的整数类型 rune 和 byte。

• 带符号整数: int8, int16, int32, int64, int
• 无符号整数: uint8, uint16, uint32, uint64, uint
• 特殊整数: rune (等同于 int32), byte (等同于 uint8)

基础用法

声明与初始化

// 声明并初始化带符号整数
var a int8 = -128
var b int32 = 2147483647

// 声明并初始化无符号整数
var c uint8 = 255
var d uint32 = 4294967295

运算符

常用的整数运算符包括：加（+）、减（-）、乘（*）、除（/）和模（%）。

// 整数运算
x := 10
y := 20
result := x + y // 结果为 30

位运算

整数还支持位运算：AND (&), OR (|), XOR (^), 以及位左移 (<<) 和位右移 (>>)。

// 位运算
var m uint8 = 1 << 3 // 结果为 8

进阶用法

数据溢出

需要注意的是，整数类型有范围限制，超过范围会导致数据溢出。

var maxInt8 int8 = 127
maxInt8 = maxInt8 + 1  // 溢出，结果为 -128

类型转换

在不同类型之间转换时，需显示使用类型转换。

var integer16 int16 = 32767
var integer32 int32

integer32 = int32(integer16)  // 类型转换

类型推断

在使用 := 进行变量声明和初始化时，Go 语言会自动推断类型。

autoInt := 42  // 类型推断为 int

特殊整数类型

rune

rune 类型常用于表示一个 Unicode 字符。

var character rune = 'A'

byte

byte 类型通常用于处理 ASCII 字符或者二进制数据。

var b byte = 'a'

常见问题和陷阱

1. 类型不匹配：不同整数类型之间不能直接进行运算。
2. 数据溢出：进行算术运算时需注意数据溢出问题。

三、浮点数类型

定义

在 Go 语言中，浮点数类型主要有两种：

• float32: 32 位浮点数，精度约为 7 位小数。
• float64: 64 位浮点数，精度约为 15 位小数。

基础用法

声明与初始化

// 声明并初始化 float32 和 float64
var a float32 = 3.14
var b float64 = 3.141592653589793

常用运算

常用的运算符包括：加（+）、减（-）、乘（*）、除（/）。

x := 1.1
y := 2.2
result := x + y  // 结果为 3.3

进阶用法

精度问题

由于计算机内部表示浮点数的限制，会有精度问题。

// 精度问题
var c float32 = 0.1
var d float32 = 0.2
var e float32 = 0.3

if c+d == e {
    fmt.Println("Equal")
} else {
    fmt.Println("Not Equal")  // 输出 "Not Equal"
}

数学函数

Go 语言的 math 包提供了丰富的数学函数。

import "math"

// 开方
result := math.Sqrt(16.0)  // 结果为 4.0

类型转换与推断

// 类型转换
var f float32 = 1.1
var g float64
g = float64(f)  // 类型转换

// 类型推断
autoFloat := 3.14  // Go 语言会自动推断为 float64 类型

特殊情况

表示无穷大和 NaN

// 无穷大
var inf float64 = math.Inf(1)

// NaN (Not a Number)
var nan float64 = math.NaN()

与整数的转换

注意：转换时可能会有精度损失。

var h float64 = 3.9
var i int = int(h)  // 结果为 3

常见问题和陷阱

1. 精度问题：进行浮点数运算时，需要注意精度问题。
2. 类型转换：在整数和浮点数之间转换时，要注意精度损失。

四、字符串类型

定义

在 Go 语言中，字符串类型被定义为一串不可变的字节序列，通常用于存储文本数据。

// 声明一个字符串类型的变量
var str string

基础用法

声明和初始化

// 声明并初始化一个字符串
var hello string = "Hello, world!"

或者使用短变量声明：

hello := "Hello, world!"

常用操作

字符串拼接：

str1 := "Hello"
str2 := "World"
result := str1 + ", " + str2  // 结果："Hello, World"

获取字符串长度：

length := len("Hello, World!")  // 结果：13

进阶用法

字符串与字节切片

在 Go 中，可以方便地在字符串和字节切片之间进行转换。

// 字符串转字节切片
byteSlice := []byte("Hello")

// 字节切片转字符串
str := string(byteSlice)

字符串截取

// 截取字符串中的部分字符
subStr := "Hello, World!"[7:12]  // 结果："World"

字符串遍历

// 遍历字符串中的每一个字符
for i, r := range "Hello" {
    fmt.Printf("%d: %c\n", i, r)
}

输出：

0: H
1: e
2: l
3: l
4: o

特殊用法

多行字符串

使用反引号（ ` ）可以声明一个多行字符串。

multiLineStr := `This is
a multi-line
string.`

转义字符

Go 字符串支持多种转义字符，如 \n（换行）、\t（制表符）等。

// 使用转义字符
escapedStr := "This is a line.\nThis is another line."

常见问题和陷阱

1. 不可变性：Go 字符串是不可变的，任何尝试改变字符串内容的操作都会创建一个新的字符串。
2. Unicode 和 UTF-8：Go 字符串默认使用 UTF-8 编码，这意味着一个字符串可能包含多种不同长度的字符。

五、其他特性

在前几章节中，我们详细地探究了 Go 语言的各种内置类型：从布尔型到整数、浮点数和字符串。这些基础类型构成了 Go 语言的基础结构，对于编写高性能和可维护代码非常重要。

类型系统的简洁与高效

Go 语言的类型系统相对简单，但并不意味着它不强大或灵活。恰恰相反，Go 语言提供了一套非常高效和易于理解的类型机制。

var isActive bool  // 布尔类型
var price int32    // 整数类型
var pi float32     // 浮点数类型
var name string    // 字符串类型

为什么不可变性很重要

在 Go 中，字符串是不可变的，这有助于多线程编程。不可变性确保了在并发访问时，数据状态始终是可预测的。

// 字符串不可变性示例
str := "immutable"
// str[0] = 'I'  // 编译错误

性能与优化

Go 提供了大量内建函数和标准库，以优化各种类型的操作。

import "math"

// 浮点数优化
result := math.Floor(3.75)  // 输出：3.0

其他

1. 类型别名与自定义类型: Go 允许你创建类型别名和自定义类型，这对于编写领域特定代码非常有用。
2. 严格类型检查: Go 的编译器会进行严格的类型检查，这大大减少了运行时错误。
3. 减少转换: Go 的类型推断和接口机制，减少了不必要的类型转换。