Go语言中泛型数据结构与接口转换的深入解析

type Node struct {
    value interface{}
    next  *Node
}

type LinkedList struct {
    head   *Node
    length int
}

// Pop方法从链表头部移除并返回一个元素
func (A *LinkedList) Pop() interface{} {
    if A.head != nil {
        head_node := A.head // head_node 是 *Node 类型
        A.head = A.head.GetNext()
        A.length--
        return head_node // Pop方法返回的是 *Node 类型
    }
    return nil
}

type Player struct {
    name   string
    salary int
}

new_linked_list := NewLinkedList()
new_linked_list.Push(&Player{name: "A", salary: 999999})
// ... 更多Push操作

// 错误示范：直接断言为 *Player
// fmt.Printf("Removing %v\n", new_linked_list.Pop().(*Player).name)

fmt.Printf("Removing %v\n", new_linked_list.Pop().(*Node).value.(*Player).name)

func (A *LinkedList) TraverseL(f func(interface{})) {
    A.eachNode(func(input_node *Node) {
        f(input_node.value)
    })
}

// ... 在main函数中
new_linked_list.TraverseL(func(input_value interface{}) {
    // 使用安全类型断言
    if player, exist := input_value.(*Player); exist {
        fmt.Printf("\t%v: %v\n", player.name, player.salary)
    } else {
        // 处理非Player类型的情况，例如打印错误或跳过
        fmt.Printf("\tFound non-Player type: %T\n", input_value)
    }
})

package main

import "fmt"

// Node 结构体定义了链表中的一个节点
type Node struct {
    value interface{} // 存储任意类型的值
    next  *Node       // 指向下一个节点
}

// NewNode 创建并返回一个新的Node
func NewNode(input_value interface{}, input_next *Node) *Node {
    return &Node{value: input_value, next: input_next}
}

// GetNext 返回当前节点的下一个节点
func (A *Node) GetNext() *Node {
    if A == nil {
        return nil
    }
    return A.next
}

// LinkedList 结构体定义了链表
type LinkedList struct {
    head   *Node // 链表头部节点
    length int   // 链表长度
}

// GetLength 返回链表的当前长度
func (A *LinkedList) GetLength() int {
    return A.length
}

// NewLinkedList 创建并返回一个新的空链表
func NewLinkedList() *LinkedList {
    return new(LinkedList)
}

// Push 将一个值添加到链表头部
func (A *LinkedList) Push(input_value interface{}) {
    A.head = NewNode(input_value, A.head)
    A.length++
}

// Pop 从链表头部移除并返回一个节点（*Node类型）
func (A *LinkedList) Pop() interface{} {
    if A.head != nil {
        head_node := A.head // head_node 是 *Node 类型
        A.head = A.head.GetNext()
        A.length--
        return head_node // 返回的是 *Node
    }
    return nil
}

// eachNode 遍历链表中的每个节点并执行函数f
func (A *LinkedList) eachNode(f func(*Node)) {
    for head_node := A.head; head_node != nil; head_node = head_node.GetNext() {
        f(head_node)
    }
}

// TraverseL 遍历链表中的每个值并执行函数f
func (A *LinkedList) TraverseL(f func(interface{})) {
    A.eachNode(func(input_node *Node) {
        f(input_node.value) // 传递节点内部存储的值
    })
}

func main() {
    // 定义Player结构体
    type Player struct {
        name   string
        salary int
    }

    new_linked_list := NewLinkedList()
    // 向链表中Push Player对象
    new_linked_list.Push(&Player{name: "A", salary: 999999})
    new_linked_list.Push(&Player{name: "B", salary: 99999999})
    new_linked_list.Push(&Player{name: "C", salary: 1452})
    new_linked_list.Push(&Player{name: "D", salary: 312412})
    new_linked_list.Push(&Player{name: "E", salary: 214324})
    new_linked_list.Push(&Player{name: "EFFF", salary: 77528})

    // 第一次Pop，返回的是 *Node 类型
    fmt.Println(new_linked_list.Pop())

    fmt.Println("--- Traversing LinkedList ---")
    // 遍历链表，使用安全类型断言
    new_linked_list.TraverseL(func(input_value interface{}) {
        if player, exist := input_value.(*Player); exist { // 安全断言
            fmt.Printf("\t%v: %v\n", player.name, player.salary)
        } else {
            fmt.Printf("\tFound non-Player type in list: %T\n", input_value)
        }
    })
    fmt.Println("--- Finished Traversing ---")

    l := new_linked_list.GetLength()
    fmt.Println("--- Removing elements ---")
    for i := 0; i < l; i++ {
        // 正确的多级类型断言：
        // 1. Pop() 返回 interface{} (底层是 *Node)
        // 2. .(*Node) 断言为 *Node
        // 3. .value 访问 Node 内部的 interface{} (底层是 *Player)
        // 4. .(*Player) 断言为 *Player
        // 5. .name 访问 Player 的 name 字段
        fmt.Printf("Removing %v\n", new_linked_list.Pop().(*Node).value.(*Player).name)
    }
    fmt.Println("--- Finished Removing ---")
}

&{0xc00000c0a0 0xc00000c080} // 第一次Pop返回的 *Node 内存地址
--- Traversing LinkedList ---
    E: 214324
    D: 312412
    C: 1452
    B: 99999999
    A: 999999
--- Finished Traversing ---
--- Removing elements ---
Removing E
Removing D
Removing C
Removing B
Removing A
--- Finished Removing ---