Go 语言提供了丰富的数据类型，用来表示不同的值和对象。数据类型是编程语言的基础之一，它决定了数据存储的方式和可以执行的操作。在 Go 语言中，数据类型主要分为基本类型、复合类型和接口类型。理解这些类型对于有效地编写 Go 程序至关重要。
📖 目录
1. 基本数据类型
1.1 整型
Go 支持多种整型，分为带符号（有符号）和无符号两种。每种类型有不同的存储大小。
- int：根据平台（32位或64位）决定大小，通常为 32 位或 64 位。
- int8：8 位有符号整型，值的范围为 -128 到 127。
- int16：16 位有符号整型，值的范围为 -32,768 到 32,767。
- int32：32 位有符号整型，值的范围为 -2^31 到 2^31-1。
- int64：64 位有符号整型，值的范围为 -2^63 到 2^63-1。
- uint8：8 位无符号整型，值的范围为 0 到 255。
- uint16：16 位无符号整型，值的范围为 0 到 65,535。
- uint32：32 位无符号整型，值的范围为 0 到 4,294,967,295。
- uint64：64 位无符号整型，值的范围为 0 到 18,446,744,073,709,551,615.
示例：
package main
import "fmt"
func main() {
var x int = 42
var y int8 = 127
var z uint = 255
fmt.Println(x) // 输出: 42
fmt.Println(y) // 输出: 127
fmt.Println(z) // 输出: 255
}
1.2 浮点型
Go 支持两种浮点数类型：
- float32：32 位浮点数，精度较低。
- float64：64 位浮点数，精度较高，通常是默认浮点类型。
示例：
package main
import "fmt"
func main() {
var a float32 = 3.14
var b float64 = 2.71828
fmt.Println(a) // 输出: 3.14
fmt.Println(b) // 输出: 2.71828
}
1.3 布尔型
布尔类型只包含两个值：
- true：表示真。
- false：表示假。
示例：
package main
import "fmt"
func main() {
var isActive bool = true
var isValid bool = false
fmt.Println(isActive) // 输出: true
fmt.Println(isValid) // 输出: false
}
1.4 字符型
Go 使用 rune（即 UTF-8 编码的字符）来表示字符类型。rune 是一个别名，实际类型是 int32，它表示一个 Unicode 字符。
示例：
package main
import "fmt"
func main() {
var char rune = 'A'
fmt.Println(char) // 输出: 65（字符 'A' 的 Unicode 编码）
}
1.5 字符串
字符串类型表示一组字符序列。在 Go 中，字符串是不可变的，意味着一旦创建，它的内容不能被修改。
- 字符串是 Unicode 编码的字节序列。
- 字符串的长度是字节长度，而不是字符数（因为某些字符可能占用多个字节）。
示例：
package main
import "fmt"
func main() {
var str string = "Hello, Go!"
fmt.Println(str) // 输出: Hello, Go!
}
2. 复合数据类型
2.1 数组
数组是固定长度的序列，数组的长度必须在声明时指定，并且是不可改变的。数组的元素类型必须相同。
示例：
package main
import "fmt"
func main() {
var arr [3]int = [3]int{1, 2, 3}
fmt.Println(arr) // 输出: [1 2 3]
}
2.2 切片
切片是 Go 中最常用的集合类型，它是动态大小的，可以随时扩展。与数组不同，切片的长度可以改变，且它并不存储数据，而是指向一个底层数组。
示例：
package main
import "fmt"
func main() {
var slice []int = []int{1, 2, 3}
fmt.Println(slice) // 输出: [1 2 3]
}
2.3 映射（Map）
映射是一种键值对数据结构，类似于哈希表或字典。每个键都映射到一个值。
示例：
package main
import "fmt"
func main() {
m := map[string]int{"apple": 5, "banana": 7}
fmt.Println(m) // 输出: map[apple:5 banana:7]
}
2.4 结构体
结构体是用户自定义的复合数据类型，它可以包含不同类型的字段。结构体通常用于表示实体对象，如学生、员工等。
示例：
package main
import "fmt"
type Person struct {
Name string
Age int
}
func main() {
p := Person{Name: "John", Age: 30}
fmt.Println(p) // 输出: {John 30}
}
2.5 接口
接口定义了一个类型集合，任何实现了接口方法的类型都被认为是该接口的实现。Go 的接口是一种隐式实现，意味着不需要显式声明某个类型实现了某个接口。
示例：
package main
import "fmt"
type Speaker interface {
Speak() string
}
type Person struct {
Name string
}
func (p Person) Speak() string {
return "Hello, " + p.Name
}
func main() {
var s Speaker = Person{Name: "John"}
fmt.Println(s.Speak()) // 输出: Hello, John
}
2.6 通道（Channel）
通道用于 Go 的并发编程中，用于在 goroutine 之间传递数据。它允许不同的 goroutine 之间安全地交换数据。
示例：
package main
import "fmt"
func main() {
ch := make(chan string)
go func() {
ch <- "Hello from goroutine!"
}()
msg := <-ch
fmt.Println(msg) // 输出: Hello from goroutine!
}
3. 类型转换
Go 语言提供了强类型系统，类型之间的转换需要显式操作。通过 T(x) 的形式将值从类型 x 转换为类型 T。
示例：
package main
import "fmt"
func main() {
var x int = 42
var y float64 = float64(x) // 类型转换
fmt.Println(x) // 输出: 42
fmt.Println(y) // 输出: 42.0
}
4. 常量
常量是在程序运行时不会改变的值，常量的类型在声明时确定。常量使用 const 关键字声明。
示例：
package main
import "fmt"
const Pi = 3.14
func main() {
fmt.Println(Pi) // 输出: 3.14
}
5. 参考资料
理解 Go 语言的各种数据类型是学习 Go 的基础之一，通过掌握这些类型，你可以更有效地组织和处理数据，编写高效、清晰的 Go 程序。
发表回复