2.2 基本数据类型与复合数据类型¶

package main

import (
    "fmt"
    "math"
    "unsafe"
)

func main() {
    // 有符号整数
    var i8 int8 = 127
    var i16 int16 = 32767
    var i32 int32 = math.MaxInt32
    var i64 int64 = math.MaxInt64

    // 无符号整数
    var u8 uint8 = 255
    var u16 uint16 = 65535

    // 打印各类型的范围和内存大小
    fmt.Printf("int8 范围: %d 到 %d, 大小: %d 字节\n", 
        math.MinInt8, math.MaxInt8, unsafe.Sizeof(i8))
    fmt.Printf("int16 范围: %d 到 %d, 大小: %d 字节\n", 
        math.MinInt16, math.MaxInt16, unsafe.Sizeof(i16))
    fmt.Printf("int32 范围: %d 到 %d, 大小: %d 字节\n", 
        math.MinInt32, math.MaxInt32, unsafe.Sizeof(i32))
    fmt.Printf("int64 范围: %d 到 %d, 大小: %d 字节\n", 
        math.MinInt64, math.MaxInt64, unsafe.Sizeof(i64))

    fmt.Printf("uint8 范围: 0 到 %d, 大小: %d 字节\n", 
        math.MaxUint8, unsafe.Sizeof(u8))
    fmt.Printf("uint16 范围: 0 到 %d, 大小: %d 字节\n", 
        math.MaxUint16, unsafe.Sizeof(u16))

    // 特殊整数类型示例
    var ptr uintptr = 0x12345678
    var b byte = 65 // byte是uint8的别名
    var r rune = 'A' // rune是int32的别名，用于表示Unicode码点

    fmt.Printf("\nbyte类型值: %d (字符表示: %c)\n", b, b)
    fmt.Printf("rune类型值: %d (字符表示: %c)\n", r, r)
    fmt.Printf("uintptr类型值: 0x%x\n", ptr)
}

package main

import (
    "fmt"
    "math"
    "unsafe"
)

func main() {
    var f32 float32 = math.MaxFloat32
    var f64 float64 = math.MaxFloat64

    fmt.Printf("float32 最大值: %e, 精度: 约6位小数, 大小: %d 字节\n", 
        f32, unsafe.Sizeof(f32))
    fmt.Printf("float64 最大值: %e, 精度: 约15位小数, 大小: %d 字节\n", 
        f64, unsafe.Sizeof(f64))

    // 浮点数精度问题示例
    var a float32 = 1.0 / 3.0
    var b float64 = 1.0 / 3.0
    fmt.Printf("float32 1/3 = %.20f\n", a)
    fmt.Printf("float64 1/3 = %.20f\n", b)

    // 浮点数比较的正确方式（避免直接使用==）
    x, y := 0.1+0.2, 0.3
    fmt.Printf("0.1+0.2 = %v, 0.3 = %v\n", x, y)
    fmt.Printf("直接比较: 0.1+0.2 == 0.3 ? %t\n", x == y)

    // 使用容差比较
    epsilon := 1e-9
    equal := math.Abs(x-y) < epsilon
    fmt.Printf("容差比较: 0.1+0.2 ≈ 0.3 ? %t\n", equal)

    // 金融计算建议：使用整数（以分、厘为单位）避免精度问题
    priceInCents := 999  // 表示9.99元
    quantity := 3
    totalInCents := priceInCents * quantity  // 2997分 = 29.97元
    fmt.Printf("商品总价: %.2f 元\n", float64(totalInCents)/100)
}

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    // 复数创建方式
    var c1 complex64 = complex(1, 2) // 1+2i，使用complex函数
    var c2 complex128 = 3 + 4i       // 直接使用字面量
    c3 := complex(5.5, -6.6)         // 类型推断为complex128（默认）

    fmt.Printf("c1 = %v (类型: %T)\n", c1, c1)
    fmt.Printf("c2 = %v (类型: %T)\n", c2, c2)
    fmt.Printf("c3 = %v (类型: %T)\n", c3, c3)

    // 复数组件提取
    fmt.Printf("c2 实部: %f, 虚部: %f\n", real(c2), imag(c2))

    // 复数运算
    sum := c1 + complex64(c2)
    product := c1 * complex64(c2)
    fmt.Printf("c1 + c2 = %v\n", sum)
    fmt.Printf("c1 * c2 = %v\n", product)

    // 复数函数库使用
    fmt.Printf("c2 的模: %f\n", cmplx.Abs(c2))          // 计算模长
    fmt.Printf("c2 的共轭: %v\n", cmplx.Conj(c2))      // 计算共轭复数
    fmt.Printf("e^πi = %v\n", cmplx.Exp(cmplx.Pi*i))   // 欧拉公式
}

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

func main() {
    s := "Hello, 世界"

    // 字符串的字符数与字节数
    fmt.Printf("字符串: %s\n", s)
    fmt.Printf("字符数: %d\n", len([]rune(s))) // 8个字符
    fmt.Printf("字节数: %d\n", len(s))         // 12个字节（英文1字节，中文3字节）

    // 查看UTF-8编码的字节表示
    fmt.Printf("UTF-8 字节: ")
    for i := 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
    fmt.Println()

    // 通过unsafe包查看字符串内部结构
    strHeader := (*reflect.StringHeader)(unsafe.Pointer(&s))
    fmt.Printf("字符串数据指针: %#x, 长度: %d\n", 
        strHeader.Data, strHeader.Len)

    // 验证字符串的不可变性
    fmt.Println("\n尝试修改字符串:")
    // s[0] = 'h' // 编译错误：cannot assign to s[0] (strings are immutable)

    // 要修改字符串需先转换为字节切片
    bytes := []byte(s)
    bytes[0] = 'h' // 现在可以修改了
    modified := string(bytes)
    fmt.Printf("原字符串: %s\n", s)      // 保持不变
    fmt.Printf("修改后字符串: %s\n", modified)
}

package main

import (
    "fmt"
    "strings"
    "unicode/utf8"
)

func main() {
    s1 := "Hello"
    s2 := "World"

    // 字符串连接
    result := s1 + " " + s2
    fmt.Println("连接结果:", result)

    // 高效字符串拼接（大量操作时使用）
    var builder strings.Builder
    builder.WriteString(s1)
    builder.WriteString(" ")
    builder.WriteString(s2)
    efficientResult := builder.String()
    fmt.Println("高效拼接结果:", efficientResult)

    // 字符串切片（注意：按字节操作）
    fmt.Println("前5字节:", result[:5])

    // 正确处理UTF-8多字节字符
    chinese := "你好世界"
    fmt.Println("\n中文字符串:", chinese)
    fmt.Println("字节长度:", len(chinese))          // 12字节（每个汉字3字节）
    fmt.Println("字符长度:", utf8.RuneCountInString(chinese))

    // 按字符遍历（使用for range）
    fmt.Print("按字符遍历: ")
    for _, r := range chinese {
        fmt.Printf("%c ", r)
    }
    fmt.Println()

    // 常用字符串处理函数
    fmt.Println("\n字符串包含检查:", strings.Contains(result, "Hello"))
    fmt.Println("字符串前缀检查:", strings.HasPrefix(result, "He"))
    fmt.Println("字符串后缀检查:", strings.HasSuffix(result, "ld"))
    fmt.Println("转大写:", strings.ToUpper(result))
    fmt.Println("转小写:", strings.ToLower(result))
    fmt.Println("替换操作:", strings.ReplaceAll(result, "l", "L"))
    fmt.Println("分割操作:", strings.Split(result, " "))
    fmt.Println("修剪操作:", strings.Trim("  Hello  ", " "))
}

package main

import (
    "fmt"
    "strings"
    "strconv"
)

func main() {
    // 布尔值声明与初始化
    var isActive bool = true
    var isFinished bool = false
    var defaultBool bool // 零值为false

    fmt.Printf("isActive: %t, isFinished: %t\n", isActive, isFinished)
    fmt.Printf("布尔零值: %t\n", defaultBool)

    // 逻辑运算
    a, b := true, false
    fmt.Printf("\na && b: %t (逻辑与)\n", a && b)
    fmt.Printf("a || b: %t (逻辑或)\n", a || b)
    fmt.Printf("!a: %t (逻辑非)\n", !a)

    // 短路特性演示
    fmt.Println("\n短路特性测试:")
    fmt.Println("true && unknown:", true && unknown())  // 不会执行unknown()
    fmt.Println("false && unknown:", false && unknown()) // 会执行unknown()

    // 实际应用场景：数据验证
    email := "test@example.com"
    isValid := checkEmailValidity(email)
    fmt.Printf("\n邮箱 %q 是否有效: %t\n", email, isValid)

    // 布尔值与字符串的转换
    boolStr := strconv.FormatBool(true)
    fmt.Println("布尔转字符串:", boolStr, "(类型:", fmt.Sprintf("%T", boolStr), ")")

    parsedBool, err := strconv.ParseBool("true")
    if err == nil {
        fmt.Println("字符串转布尔:", parsedBool, "(类型:", fmt.Sprintf("%T", parsedBool), ")")
    }

    // 注意：Go不允许布尔值与其他类型的转换
    // var num int = 1
    // var b bool = bool(num)  // 编译错误：cannot convert num (type int) to type bool
}

// 用于演示短路特性的函数
func unknown() bool {
    fmt.Println("执行了unknown()函数")
    return true
}

// 邮箱验证函数（简化版）
func checkEmailValidity(email string) bool {
    return strings.Contains(email, "@") && 
           strings.Contains(email, ".") &&
           strings.Index(email, "@") < strings.LastIndex(email, ".")
}

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // 数组的多种声明和初始化方式
    var arr1 [5]int               // 声明长度为5的int数组，元素默认值为0
    arr2 := [3]string{"a", "b", "c"} // 声明并初始化
    arr3 := [...]int{1, 2, 3, 4, 5}  // 编译器自动推断长度为5
    arr4 := [5]int{2: 10, 4: 20}     // 指定索引位置初始化

    fmt.Printf("arr1: %v, 长度: %d\n", arr1, len(arr1))
    fmt.Printf("arr2: %v, 长度: %d\n", arr2, len(arr2))
    fmt.Printf("arr3: %v, 长度: %d\n", arr3, len(arr3))
    fmt.Printf("arr4: %v, 长度: %d\n", arr4, len(arr4))

    // 数组是值类型（赋值会复制整个数组）
    copyArr := arr3
    copyArr[0] = 100
    fmt.Printf("\n原数组arr3: %v\n", arr3)    // [1 2 3 4 5]（未被修改）
    fmt.Printf("复制数组copyArr: %v\n", copyArr) // [100 2 3 4 5]

    // 数组元素在内存中连续存储
    fmt.Println("\n数组元素地址（展示连续性）:")
    for i := 0; i < len(arr3); i++ {
        fmt.Printf("arr3[%d] = %d, 地址: %p\n", i, arr3[i], &arr3[i])
    }

    // 数组长度是类型的一部分
    var intArr3 [3]int
    var intArr5 [5]int
    // intArr3 = intArr5  // 编译错误：cannot assign [5]int to [3]int

    // 多维数组
    matrix := [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }
    fmt.Printf("\n二维数组: %v\n", matrix)
    fmt.Printf("访问元素matrix[1][2]: %d\n", matrix[1][2])

    // 数组大小计算
    fmt.Printf("\narr3数组占用内存: %d 字节\n", unsafe.Sizeof(arr3))
}

package main

import "fmt"

func main() {
    // 切片的创建方式
    slice1 := []int{1, 2, 3, 4, 5}                // 直接初始化
    slice2 := make([]string, 3, 5)                // 使用make创建，长度3，容量5
    slice3 := make([]float64, 4)                  // 省略容量，容量等于长度
    var slice4 []bool                             // 零值切片（nil）

    fmt.Printf("slice1: %v, 长度: %d, 容量: %d\n", slice1, len(slice1), cap(slice1))
    fmt.Printf("slice2: %v, 长度: %d, 容量: %d\n", slice2, len(slice2), cap(slice2))
    fmt.Printf("slice3: %v, 长度: %d, 容量: %d\n", slice3, len(slice3), cap(slice3))
    fmt.Printf("slice4: %v, 长度: %d, 容量: %d, 是否为nil: %t\n", 
        slice4, len(slice4), cap(slice4), slice4 == nil)

    // 基于数组创建切片
    arr := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    slice5 := arr[2:5]  // 包含arr[2], arr[3], arr[4]
    slice6 := arr[5:]   // 从arr[5]到末尾
    slice7 := arr[:3]   // 从开头到arr[2]

    fmt.Printf("\n原数组arr: %v\n", arr)
    fmt.Printf("slice5: %v, 长度: %d, 容量: %d\n", slice5, len(slice5), cap(slice5))
    fmt.Printf("slice6: %v, 长度: %d, 容量: %d\n", slice6, len(slice6), cap(slice6))

    // 切片共享底层数组（修改会相互影响）
    slice5[0] = 200
    fmt.Printf("修改slice5后，原数组arr: %v\n", arr)
    fmt.Printf("修改slice5后，slice6: %v\n", slice6)

    // 切片追加操作
    slice8 := []int{10, 20}
    fmt.Printf("\n初始slice8: %v, 容量: %d\n", slice8, cap(slice8))

    slice8 = append(slice8, 30)
    fmt.Printf("追加1个元素后: %v, 容量: %d\n", slice8, cap(slice8))

    slice8 = append(slice8, 40, 50, 60)
    fmt.Printf("追加3个元素后: %v, 容量: %d\n", slice8, cap(slice8))

    // 切片拷贝
    source := []int{1, 2, 3}
    destination := make([]int, len(source))
    copyCount := copy(destination, source)
    fmt.Printf("\n拷贝结果: source=%v, destination=%v, 拷贝个数=%d\n", 
        source, destination, copyCount)
}

package main

import (
    "fmt"
    "unsafe"
)

// 定义一个结构体类型
type Person struct {
    Name string
    Age  int
    Male bool
}

// 嵌套结构体
type Address struct {
    City    string
    Street  string
    ZipCode string
}

type Employee struct {
    Person   // 匿名字段（嵌入）
    ID       int
    Address  // 嵌入结构体
    Salary   float64
}

// 空结构体（不占用内存）
type EmptyStruct struct{}

func main() {
    // 结构体初始化
    p1 := Person{"Alice", 30, true}
    p2 := Person{Name: "Bob", Age: 25} // 部分字段初始化
    var p3 Person                      // 零值初始化
    p3.Name = "Charlie"
    p3.Age = 35

    fmt.Printf("p1: %v\n", p1)
    fmt.Printf("p2: %v\n", p2)
    fmt.Printf("p3: %v\n", p3)

    // 访问结构体字段
    fmt.Printf("\np1的名字: %s, 年龄: %d\n", p1.Name, p1.Age)

    // 嵌套结构体使用
    e := Employee{
        Person: Person{
            Name: "David",
            Age:  40,
            Male: true,
        },
        ID:     1001,
        Salary: 5000.0,
        Address: Address{
            City:    "Beijing",
            Street:  "Main St",
            ZipCode: "100000",
        },
    }

    fmt.Printf("\nEmployee e: %v\n", e)
    fmt.Printf("员工姓名: %s, 所在城市: %s\n", e.Name, e.City) // 直接访问嵌入字段

    // 结构体的内存布局
    fmt.Println("\n结构体字段地址（展示内存布局）:")
    fmt.Printf("p1.Name 地址: %p\n", &p1.Name)
    fmt.Printf("p1.Age   地址: %p\n", &p1.Age)
    fmt.Printf("p1.Male  地址: %p\n", &p1.Male)

    // 结构体大小（受内存对齐影响）
    fmt.Printf("\nPerson结构体大小: %d 字节\n", unsafe.Sizeof(p1))

    // 空结构体特性
    var es EmptyStruct
    var es2 EmptyStruct
    fmt.Printf("空结构体大小: %d 字节\n", unsafe.Sizeof(es))
    fmt.Printf("两个空结构体的地址是否相同: %v\n", &es == &es2)
}

package main

import "fmt"

func main() {
    // 映射的创建方式
    map1 := map[string]int{
        "apple":  5,
        "banana": 3,
        "orange": 7,
    }
    map2 := make(map[int]string)          // 使用make创建，默认容量
    map3 := make(map[string]float64, 10)  // 指定初始容量
    var map4 map[string]bool              // 零值映射（nil）

    fmt.Printf("map1: %v, 长度: %d\n", map1, len(map1))
    fmt.Printf("map2: %v, 长度: %d\n", map2, len(map2))
    fmt.Printf("map4是否为nil: %t\n", map4 == nil)

    // 映射的基本操作
    fmt.Println("\n映射基本操作:")

    // 添加/修改元素
    map2[1] = "one"
    map2[2] = "two"
    map1["grape"] = 4  // 添加新元素
    map1["apple"] = 6  // 修改已有元素
    fmt.Printf("添加元素后map2: %v\n", map2)
    fmt.Printf("修改元素后map1: %v\n", map1)

    // 获取元素
    appleCount := map1["apple"]
    fmt.Printf("苹果数量: %d\n", appleCount)

    // 检查键是否存在
    orangeCount, exists := map1["orange"]
    if exists {
        fmt.Printf("橙子存在，数量: %d\n", orangeCount)
    } else {
        fmt.Println("橙子不存在")
    }

    // 删除元素
    delete(map1, "banana")
    fmt.Printf("删除香蕉后map1: %v\n", map1)

    // 映射是引用类型（赋值不会复制数据）
    map1Copy := map1
    map1Copy["orange"] = 10
    fmt.Printf("\n修改复制的map后，原map1: %v\n", map1)

    // 映射的遍历
    fmt.Println("\n遍历map1:")
    for fruit, count := range map1 {
        fmt.Printf("%s: %d\n", fruit, count)
    }

    // 注意：映射的遍历顺序是不确定的
    // 若需要有序遍历，需先获取键列表并排序
}