Go语言中递归结构体与切片：深度解析值语义与引用陷阱

package main

import "fmt"

type Element struct {
  parent *Element
  children []Element // 注意这里是 []Element，存储的是结构体值
  tag string
}

func SubElement(parent *Element, tag string) Element {
  el := Element{}
  el.parent = parent
  el.tag = tag
  // 问题发生在这里：append会拷贝el，而不是存储其引用
  parent.children = append(parent.children, el) 
  return el // 返回的也是一个拷贝
}

func (el Element) String() string {
  s := "<" + el.tag + ">"
  for _, child := range el.children {
    s += child.String()
  }
  s += "</" + el.tag + ">"
  return s
}

func main() {
  root := Element{tag: "root"}

  a := SubElement(&root, "a") // a 是 SubElement 返回的拷贝
  b := SubElement(&a, "b")   // b 是 SubElement 返回的拷贝
  SubElement(&b, "c")

  fmt.Println(root) // 预期输出 <root><a><b><c></c></b></a></root>
                     // 实际输出 <root><a></a></root>
  fmt.Println(a)    // 预期输出 <a><b><c></c></b></a>
                     // 实际输出 <a><b></b></a>
}

package main

import "fmt"

type Element struct {
    children []Element // 仍然是 []Element
    tag      string
}

// SubElement 现在是 Element 的一个方法，操作的是接收者 *parent
func (parent *Element) SubElement(tag string) {
    // 直接创建子节点并添加到父节点的 children 切片中
    // 这里 Element{tag: tag} 是一个新创建的值，被拷贝到切片中
    parent.children = append(parent.children, Element{tag: tag})
}

func (el Element) String() string {
    s := "<" + el.tag + ">"
    for _, child := range el.children {
        s += child.String()
    }
    s += "</" + el.tag + ">"
    return s
}

func main() {
    root := Element{tag: "root"}
    root.SubElement("a") // 添加第一个一级子节点
    // 访问第一个一级子节点，并为其添加二级子节点
    root.children[0].SubElement("b") 
    // 访问第一个一级子节点的第一个二级子节点，并为其添加三级子节点
    root.children[0].children[0].SubElement("c") 

    fmt.Println(root) // 输出: <root><a><b><c></c></b></a></root>
}

package main

import "fmt"

type Element struct {
  parent *Element // 父节点指针现在是安全的，因为它指向的是 Element 的地址，而不是切片内部的地址
  children []*Element // 存储 Element 的指针
  tag string
}

func NewElement(parent *Element, tag string) *Element {
  el := &Element{
    parent: parent,
    tag:    tag,
  }
  if parent != nil {
    parent.children = append(parent.children, el) // 将新元素的指针添加到父节点的 children 切片
  }
  return el
}

func (el *Element) String() string { // String 方法也应接收指针以保持一致性
  s := "<" + el.tag + ">"
  for _, child := range el.children {
    s += child.String() // 递归调用子节点的 String 方法
  }
  s += "</" + el.tag + ">"
  return s
}

func main() {
  root := NewElement(nil, "root") // 根节点没有父节点

  a := NewElement(root, "a") // a 是指向新 Element 的指针
  b := NewElement(a, "b")    // b 是指向新 Element 的指针
  _ = NewElement(b, "c")     // c 被创建并添加到 b 的 children

  fmt.Println(root) // 输出: <root><a><b><c></c></b></a></root>
  fmt.Println(a)    // 输出: <a><b><c></c></b></a>
}