Go语言中切片元素修改的正确姿势：理解range循环的行为

// 错误示例：n 被赋值为索引，而非 node 结构体
for n := range g.nodes {
    // 此时 n 是一个 int 类型的值（索引），而不是 node 结构体
    // 尝试访问 n.value 或 n.neigbours 将导致编译错误：
    // "n.value undefined (type int has no field or method value)"
    n.value = 2
    n.neigbours = nil
    return // 注意：这里的 return 语句会导致循环只执行一次
}

package main

import (
    "fmt"
    //"math/rand" // 暂时注释，非当前问题核心
)

type node struct {
    value     int
    neigbours []int
}

type edge struct {
    source int
    sink   int
}

type graph struct {
    nodesnr, edgesnr int
    nodes            []node
    edges            chan edge
}

func main() {
    randomGraph()
}

func input(tname string) (number int) {
    fmt.Println("input a number of " + tname)
    fmt.Scan(&number)
    return
}

func randomGraph() (g graph) {
    g = graph{nodesnr: input("nodes"), edgesnr: input("edges")}
    g.addNodes()
    for i := 0; i < g.nodesnr; i++ {
        fmt.Printf("Node %d value: %d, neighbours: %v\n", i, g.nodes[i].value, g.nodes[i].neigbours)
    }
    //g.addEdges() // 暂时注释
    return
}

func (g *graph) addNodes() {
    g.nodes = make([]node, g.nodesnr)
    // 正确的迭代方式：通过索引修改切片中的元素
    for i := range g.nodes {
        g.nodes[i].value = i + 1 // 可以根据需要设置不同的值，这里以 i+1 为例
        g.nodes[i].neigbours = []int{} // 初始化为空切片
    }
}

// 以下是其他辅助函数，与当前问题核心无关，但为完整代码提供
func (g *graph) addEdges() {
    g.edges = make(chan edge)
    for i := 0; i < g.edgesnr; i++ {
        //g.newEdge()
        // 注意：这里的 return 语句会使循环只执行一次，可能不是预期行为
        // 通常在循环中不应直接 return，除非有特定逻辑
        return
    }
}

/*
func (g* graph) newEdge(){
e := new(edge)
e.source, e.sink = rand.Intn(g.nodesnr), rand.Intn(g.nodesnr)
g.edges <-e*
//g.addEdge()
}
*/

func (g *graph) edgeCheck(ep *edge) string {
    if ep.source == ep.sink {
        return "self"
    }
    //if(g.neigbourCheck(g.nodes[ep.source].neigbours, ep.sink) OR    g.neigbourCheck(g.nodes[ep.sink].neigbours, ep.source){
    //  return "present"

    return "empty"
}

func (g *graph) neigbourCheck(neigbours []node, node int) bool {
    // 注意：这里的 neigbours 参数类型是 []node，但内部比较的是 node (int) == neigbour (node)
    // 这会导致类型不匹配。如果 neigbours 存储的是邻居节点的索引，那么参数类型应为 []int
    for _, neigbour := range neigbours { // 遍历的是 node 结构体
        // if node == neigbour { // 错误：int == node
        // 应该比较 node ID 和 neigbour.value
        if node == neigbour.value { // 假设 node.value 是节点ID
            return true
        }
    }
    return false
}

func (g *graph) addEdge() {
    e := <-g.edges
    switch etype := g.edgeCheck(&e); etype {
    case "present":
        fallthrough
    case "self":
        fmt.Println("self")
        //go g.newEdge()
    case "empty":
        //g.nodes[e.source] = append(g.nodes[e.source], e.sink), // 错误语法
        //g.nodes[e.source].neigbours = append(g.nodes[e.source].neigbours, e.sink) // 正确的追加方式
        //g.nodes[e.sink].neigbours = append(g.nodes[e.sink].neigbours, e.source)   // 正确的追加方式
        fmt.Println("empty")
    default:
        fmt.Println("something went wrong")
    }
}