1. 基本数据类型

1.1 整型

Go语言支持不同大小的有符号和无符号整数类型，具体如下：

  • 有符号整型：int8, int16, int32, int64
    • 范围示例：int8（-128 ~ 127），int16（-32768 ~ 32767）
  • 无符号整型：uint8, uint16, uint32, uint64
    • 范围示例：uint8（0 ~ 255），uint16（0 ~ 65535）
  • 平台相关类型：
    • int 和 uint：大小取决于系统架构（32位或64位）。
    • uintptr：无符号整型，用于存储指针。

示例：

var a int8 = 127
var b uint16 = 65535
var c int = 100
var d uintptr = 0x123456
fmt.Println(a, b, c, d)

1.2 浮点型

  • float32：32位浮点数，精度约为6位小数。
  • float64：64位浮点数，精度约为15位小数（默认使用）。

示例：

var pi float64 = 3.1415926535
var x float32 = 1.23
fmt.Println(pi, x)

1.3 复数类型

  • complex64：实部和虚部为float32。
  • complex128：实部和虚部为float64（默认使用）。

示例：

var z complex128 = 3 + 4i
fmt.Println(z) // 输出 (3+4i)

1.4 布尔类型

  • bool：值只能是 true 或 false，用于逻辑判断。
  • 特点：不能与整型隐式转换。

示例：

var isTrue bool = true
fmt.Println(isTrue)

1.5 字符串类型

  • string：基于UTF-8编码的不可变字符序列。
  • 操作：
    • 索引访问字节（非字符）：s[0]。
    • 拼接：+ 或 fmt.Sprintf。
    • 长度：len(s)（返回字节数），utf8.RuneCountInString(s)（返回字符数）。

示例：

s := "Hello, 世界"
fmt.Println(len(s))                      // 输出 13（字节数）
fmt.Println(utf8.RuneCountInString(s))   // 输出 9（字符数）
fmt.Println(s[0:5])                      // 输出 "Hello"
fmt.Println(s + "!")                     // 输出 "Hello, 世界!"

1.6 特殊类型

  • byte：uint8 的别名，表示单个字节。
  • rune：int32 的别名，表示Unicode码点（支持中文字符）。

示例：

var b byte = 'A'
var r rune = '你'
fmt.Println(b, r) // 输出 65 20320

2. 复合数据类型

2.1 数组

  • 定义：固定大小的同类型元素序列。
  • 声明：var arr [n]T 或 arr := [n]T{...}。
  • 特点：值类型，内存连续。

示例：

var numbers [3]int = [3]int{1, 2, 3}
names := [2]string{"Alice", "Bob"}
fmt.Println(numbers, names)

2.2 结构体

  • 定义：自定义复合类型，聚合多个字段。
  • 声明：type StructName struct { ... }。
  • 特点：支持匿名字段和嵌套结构体。

示例：

type Person struct {
    Name string
    Age  int
}

p := Person{Name: "Alice", Age: 30}
fmt.Println(p.Name, p.Age)

2.3 函数类型

  • 定义：函数可以作为一等公民赋值、传递。
  • 声明：func add(a, b int) int { ... }。

示例：

func add(a, b int) int {
    return a + b
}

result := add(3, 5)
fmt.Println(result) // 输出 8

3. 引用数据类型

3.1 切片

  • 定义：动态数组，基于数组的引用类型。
  • 声明：var s []T 或 s := make([]T, len, cap)。
  • 特点：
    • 动态扩容（通常翻倍增长）。
    • 切片操作返回新切片，共享底层数组。

示例：

s := []int{1, 2, 3}
s = append(s, 4)
fmt.Println(s) // 输出 [1, 2, 3, 4]

s2 := make([]int, 2, 5)
fmt.Println(len(s2), cap(s2)) // 输出 2 5

3.2 映射（Map）

  • 定义：键值对集合，无序且键唯一。
  • 声明：var m map[K]V 或 m := map[K]V{...}。
  • 操作：添加/修改、查询、删除。

示例：

ages := map[string]int{
    "Alice": 30,
    "Bob":   28,
}
ages["Charlie"] = 25 // 添加
val, exists := ages["Alice"] // 查询
delete(ages, "Bob") // 删除
fmt.Println(val, exists, ages)

3.3 通道（Channel）

  • 定义：用于goroutine间通信。
  • 声明：ch := make(chan T)。
  • 操作：ch <- v（发送），v := <-ch（接收）。

示例：

ch := make(chan int)
go func() {
    ch <- 42
}()
fmt.Println(<-ch) // 输出 42

4. 接口类型

4.1 接口（Interface）

  • 定义：一组方法签名的集合，描述行为。
  • 特点：隐式实现（无需显式声明实现接口）。

示例：

type Speaker interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

var s Speaker = Dog{}
fmt.Println(s.Speak()) // 输出 "Woof!"

5. 指针类型

  • 定义：存储变量的内存地址。
  • 操作：
    • & 取地址。
    • * 解引用。

示例：

a := 10
p := &a
*p = 20
fmt.Println(a) // 输出 20

6. 自定义类型

6.1 类型定义

  • 定义：通过 type 创建新类型，与原类型不同。
type MyInt int
var x MyInt = 10

6.2 类型别名

  • 定义：通过 type T = U 创建别名，本质与原类型相同。
type MyInt = int
var x MyInt = 10

7. 其他类型

7.1 错误类型

  • error：内置接口，用于表示错误。
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

Go语言的数据类型涵盖了从基本类型到复杂结构的全面支持，满足系统编程和应用开发的需求。通过合理使用这些类型，可以高效地构建健壮的程序。