Go语言中如何传递返回特定类型但期望interface{}的函数

package main

import (
    "fmt"
    "os"
    "strings"
)

// MyType 示例结构体
type MyType struct {
    Field1 string
    Field2 string
}

// readFile 函数期望一个返回 interface{} 的 transform 函数
func readFile(filename string, transform func(string) interface{}) (list []interface{}, err error) {
    rawBytes, readErr := os.ReadFile(filename)
    if readErr != nil {
        return nil, fmt.Errorf("读取文件失败: %w", readErr)
    }

    lines := strings.Split(string(rawBytes), "\n")
    for _, line := range lines {
        trimmedLine := strings.TrimSpace(line)
        if len(trimmedLine) == 0 { // 跳过空行
            continue
        }
        t := transform(trimmedLine)
        list = append(list, t)
    }
    return list, nil
}

// 原始尝试的 transform 函数 (返回 *MyType)
// func transform(line string) *MyType {
//     fields := strings.Split(line, "\t")
//     if len(fields) < 2 {
//         return nil // 或者返回错误
//     }
//     return &MyType{Field1: fields[0], Field2: fields[1]}
// }

// 调用 readFile("path/to/file.txt", transform) 会报错:
// cannot use transform (type func(string) *MyType) as type func(string) interface {} in function argument

package main

import (
    "fmt"
    "os"
    "strings"
)

// MyType 示例结构体
type MyType struct {
    Field1 string
    Field2 string
}

// readFile 函数 (同上)
func readFile(filename string, transform func(string) interface{}) (list []interface{}, err error) {
    rawBytes, readErr := os.ReadFile(filename)
    if readErr != nil {
        return nil, fmt.Errorf("读取文件失败: %w", readErr)
    }

    lines := strings.Split(string(rawBytes), "\n")
    for _, line := range lines {
        trimmedLine := strings.TrimSpace(line)
        if len(trimmedLine) == 0 {
            continue
        }
        t := transform(trimmedLine)
        list = append(list, t)
    }
    return list, nil
}

// 解决方案一: transform 函数明确返回 interface{}
func transformToInterface(line string) interface{} {
    fields := strings.Split(line, "\t")
    if len(fields) < 2 {
        // 实际应用中应返回错误或更合理的默认值
        return nil
    }
    return &MyType{Field1: fields[0], Field2: fields[1]} // 返回 *MyType，但类型被提升为 interface{}
}

func main() {
    // 创建一个虚拟文件用于测试
    testData := "value1a\tvalue1b\nvalue2a\tvalue2b\n"
    err := os.WriteFile("testfile.txt", []byte(testData), 0644)
    if err != nil {
        fmt.Printf("创建测试文件失败: %v\n", err)
        return
    }
    defer os.Remove("testfile.txt") // 清理测试文件

    // 调用 readFile
    objects, err := readFile("testfile.txt", transformToInterface)
    if err != nil {
        fmt.Printf("处理文件失败: %v\n", err)
        return
    }

    fmt.Println("使用解决方案一处理结果:")
    for i, obj := range objects {
        // 需要进行类型断言才能访问 MyType 的字段
        if myObj, ok := obj.(*MyType); ok {
            fmt.Printf("Line %d: Field1=%s, Field2=%s\n", i+1, myObj.Field1, myObj.Field2)
        } else {
            fmt.Printf("Line %d: 无法断言为 *MyType\n", i+1)
        }
    }
}

package main

import (
    "fmt"
    "os"
    "strings"
)

// MyType 示例结构体
type MyType struct {
    Field1 string
    Field2 string
}

// 解决方案二: 泛型 readFile 函数
// [T any] 表示 T 可以是任何类型
func readFileGeneric[T any](filename string, transform func(string) T) (list []T, err error) {
    rawBytes, readErr := os.ReadFile(filename)
    if readErr != nil {
        return nil, fmt.Errorf("读取文件失败: %w", readErr)
    }

    lines := strings.Split(string(rawBytes), "\n")
    for _, line := range lines {
        trimmedLine := strings.TrimSpace(line)
        if len(trimmedLine) == 0 {
            continue
        }
        t := transform(trimmedLine)
        list = append(list, t)
    }
    return list, nil
}

// 泛型版本下，transform 函数可以返回具体类型 *MyType
func transformToMyType(line string) *MyType {
    fields := strings.Split(line, "\t")
    if len(fields) < 2 {
        // 实际应用中应返回错误或更合理的默认值
        return nil
    }
    return &MyType{Field1: fields[0], Field2: fields[1]}
}

func main() {
    // 创建一个虚拟文件用于测试
    testData := "value1a\tvalue1b\nvalue2a\tvalue2b\n"
    err := os.WriteFile("testfile.txt", []byte(testData), 0644)
    if err != nil {
        fmt.Printf("创建测试文件失败: %v\n", err)
        return
    }
    defer os.Remove("testfile.txt") // 清理测试文件

    // 调用泛型 readFile
    // 编译器会自动推断 T 为 *MyType
    objects, err := readFileGeneric("testfile.txt", transformToMyType)
    if err != nil {
        fmt.Printf("处理文件失败: %v\n", err)
        return
    }

    fmt.Println("\n使用解决方案二 (泛型) 处理结果:")
    for i, myObj := range objects {
        // 直接访问 *MyType 的字段，无需类型断言
        if myObj != nil { // 检查是否为 nil，因为 transformToMyType 可能返回 nil
            fmt.Printf("Line %d: Field1=%s, Field2=%s\n", i+1, myObj.Field1, myObj.Field2)
        } else {
            fmt.Printf("Line %d: 对象为 nil\n", i+1)
        }
    }
}