Go语言中理解与解决interface conversion恐慌

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 创建一个新的LinkedList
func NewLinkedList() *LinkedList {
    return new(LinkedList)
}

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

// Pop 从链表头部弹出一个节点
func (A *LinkedList) Pop() interface{} { // 注意这里返回的是 interface{}
    if A.head != nil {
        head_node := A.head
        A.head = A.head.GetNext()
        A.length--
        return head_node // 实际上返回的是 *Node 类型
    }
    return nil
}

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

// TraverseL 遍历链表中的每个值
func (A *LinkedList) TraverseL(f func(interface{})) {
    A.eachNode(func(input_node *Node) {
        f(input_node.value) // 这里传递的是 Node.value (interface{})
    })
}

func main() {
    type Player struct {
        name   string
        salary int
    }

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

// 错误示例：直接将Pop()的返回值断言为 *Player
l := new_linked_list.GetLength()
for i := 0; i < l; i++ {
    fmt.Printf("Removing %v\n", new_linked_list.Pop().(*Player).name) // 错误发生在这里
}

func main() {
    type Player struct {
        name   string
        salary int
    }

    new_linked_list := NewLinkedList()
    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})

    // 示例1: 弹出第一个元素并打印其Node表示
    fmt.Println(new_linked_list.Pop()) // 打印的是 *Node 的内存地址和下一个Node的地址

    // 示例2: 遍历链表中的Player值
    fmt.Println("遍历链表中的Player数据:")
    new_linked_list.TraverseL(func(input_value interface{}) {
        // 使用 "comma-ok" 语法安全地进行类型断言
        if player, exist := input_value.(*Player); exist {
            fmt.Printf("\t%v: %v\n", player.name, player.salary)
        } else {
            fmt.Printf("\t未知类型的值: %v\n", input_value)
        }
    })

    // 示例3: 弹出所有元素并打印被移除Player的名称
    fmt.Println("移除链表中的Player数据:")
    l := new_linked_list.GetLength() // 获取当前链表长度
    for i := 0; i < l; i++ {
        // 正确的类型断言链：
        // 1. Pop() 返回 *Node (被包装在 interface{} 中)
        // 2. 将其断言为 *Node
        // 3. 访问 *Node 的 value 字段 (interface{})
        // 4. 将 value 字段断言为 *Player
        // 5. 访问 *Player 的 name 字段
        poppedNode := new_linked_list.Pop() // poppedNode 的静态类型是 interface{}，动态类型是 *Node
        if poppedNode == nil {
            fmt.Println("链表为空，无法弹出更多元素。")
            break
        }

        // 安全地进行第一层断言
        if node, ok := poppedNode.(*Node); ok {
            // 安全地进行第二层断言
            if player, ok := node.value.(*Player); ok {
                fmt.Printf("Removing %v\n", player.name)
            } else {
                fmt.Printf("Node的value不是*Player类型，而是%T\n", node.value)
            }
        } else {
            fmt.Printf("Pop()返回的不是*Node类型，而是%T\n", poppedNode)
        }
    }
}

&{0xc0000100d0 0xc0000100c0} // 第一次Pop()弹出的Node的地址
遍历链表中的Player数据:
    E: 214324
    D: 312412
    C: 1452
    B: 99999999
    A: 999999
移除链表中的Player数据:
Removing E
Removing D
Removing C
Removing B
Removing A