Go语言：理解与使用数组指针作为函数参数

package main

import "fmt"

// processArrayPointer 接收一个指向大小为5的整数数组的指针
func processArrayPointer(arrPtr *[5]int) {
    // 尽管在Go中通常会避免传递nil数组指针，但在特定逻辑下可进行nil检查
    if arrPtr == nil {
        fmt.Println("错误：接收到的数组指针为nil")
        return
    }
    fmt.Println("函数内：通过指针访问数组内容：", *arrPtr)

    // 通过指针修改数组内容，会直接影响到原始数组
    (*arrPtr)[0] = 99 // 解引用指针并修改第一个元素
    fmt.Println("函数内：修改后数组内容：", *arrPtr)
}

func main() {
    // 定义一个大小为5的整数数组
    myArray := [5]int{1, 2, 3, 4, 5}
    fmt.Println("主函数：原始数组：", myArray)

    // 传递数组的指针给函数
    processArrayPointer(&myArray)
    fmt.Println("主函数：函数调用后，原始数组：", myArray) // 确认修改生效

    // 尝试传递不同大小的数组指针会导致编译错误
    // 编译错误示例：
    // anotherArray := [6]int{1, 2, 3, 4, 5, 6}
    // processArrayPointer(&anotherArray) // 编译错误: cannot use &anotherArray (type *[6]int) as type *[5]int
}

package main

import (
    "fmt"
    "io/ioutil" // 模拟文件读取
)

// processDataWithSlice 接收一个字节切片，模拟数据处理
// 实际应用中，此函数可能需要处理文件读取和缓存逻辑
func processDataWithSlice(data []byte) {
    fmt.Println("函数内：接收到的切片长度：", len(data))
    if len(data) > 0 {
        fmt.Printf("函数内：切片内容（前10字节）：%s...\n", data[:min(10, len(data))])
        // 修改切片元素，会影响原底层数组
        data[0] = 'X' // 假设是文本数据
        fmt.Println("函数内：修改切片第一个字节为 'X'")
    } else {
        fmt.Println("函数内：接收到空切片。")
    }
}

// min 辅助函数，取最小值
func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

func main() {
    // 场景1: 将数组转换为切片传递
    myArray := [5]byte{'a', 'b', 'c', 'd', 'e'}
    fmt.Println("主函数：原始数组：", string(myArray[:]))
    processDataWithSlice(myArray[:]) // 将整个数组转换为切片传递
    fmt.Println("主函数：函数调用后，原始数组：", string(myArray[:])) // 确认修改生效

    // 场景2: 直接定义切片并传递
    mySlice := []byte{'H', 'e', 'l', 'l', 'o'}
    fmt.Println("\n主函数：原始切片：", string(mySlice))
    processDataWithSlice(mySlice)
    fmt.Println("主函数：函数调用后，原始切片：", string(mySlice))

    // 场景3: 传递一个空切片
    emptySlice := []byte{}
    fmt.Println("\n主函数：原始空切片：", emptySlice)
    processDataWithSlice(emptySlice)
    fmt.Println("主函数：函数调用后，原始空切片：", emptySlice)

    // 模拟文件读取场景：
    // 全局变量用于缓存，通常是切片类型
    var globalFormData []byte

    // 模拟从磁盘读取表单数据的函数
    readFormFromDisk := func(formName string) ([]byte, error) {
        fmt.Printf("从磁盘读取表单：%s\n", formName)
        // 模拟 ioutil.ReadFile
        if formName == "global_form.txt" {
            return []byte("Global Form Data"), nil
        }
        return []byte("Local Form Data: " + formName), nil
    }

    // 处理表单的通用函数，可以处理缓存和动态加载
    handleForm := func(inputData []byte, formName string, useGlobalCache bool) ([]byte, error) {
        if len(inputData) > 0 {
            // 如果传入了数据，则直接使用传入的数据（模拟局部数组每次读取）
            fmt.Println("使用传入的局部数据。")
            return inputData, nil
        }

        if useGlobalCache {
            if len(globalFormData) == 0 {
                // 全局缓存为空，从磁盘读取并填充缓存
                fmt.Println("全局缓存为空，从磁盘读取并更新缓存。")
                data, err := readFormFromDisk(formName)
                if err != nil {
                    return nil, err
                }
                globalFormData = data // 更新全局缓存
                return data,