关于go:tree转数组jsgo版本

tree 转数组，两种形式

递归
循环（留神，循环不能应用迭代器办法，只能应用 for 循环）

js 版本

 
/**
 * 数组
 */
let arr = [{name: "李四", id: 2, pid: 0},//  []
    {name: "王五", id: 3, pid: 0}, // []
    {name: "赵六", id: 4, pid: 3}, // []
    {name: "吗六", id: 9, pid: 3}, // []
    {name: "张三", id: 7, pid: 9}, // []
    {name: "张五", id: 10, pid: 4}, // []]
 
/**
 * 数组转 tree，递归模式
 * @param arr
 * @param pid
 * @returns {*[]}
 * @constructor
 */
function ArrayToTree(arr, pid = 0) {
    // 判断 arr 是否是数组
    if (!Array.isArray(arr) || !arr.length) return []
    let newArr = []
    arr.forEach(v => {// 判断 pid 是否雷同  雷同就插入进去，切递归一下 children，有值就持续递归，没值就返回 []
        if (v.pid == pid) {
            newArr.push({...v, children: ArrayToTree(arr, v.id)
            })
        }
    })
    // 返回值
    return newArr
}
 
let tree = ArrayToTree(arr)
 
/**
 * tree 转数组，循环模式，每次减少循环的变量
 *【留神：】只能应用 for 循环，不能应用 es6 的迭代器
 * @param tree
 * @returns {{length}|*}
 * @constructor
 */
function TreeToArrayFor(tree) {if (!Array.isArray(tree) || !tree.length) throw new Error("请传入数组")
    for (let i = 0; i < tree.length; i++) {if (tree[i].children) {
            // 每次 children 有值，就把值合并到原始数据 tree 下来，减少原始 tree，for 循环 的长度也会减少 顺次解决...
            tree = tree.concat(tree[i].children)
        }
    }
    return tree
}
 
 
/**
 * tree 转数组，递归模式
 * @param tree
 * @returns {*[]}
 * @constructor
 */
function TreeToArray(tree) {// 判断 tree 是否有值，无返回 []
    if (!Array.isArray(tree) || !tree.length) return []
    let res = []
    tree.forEach(v => {
        // tree 的每个元素都 放入到 res 外面
        res.push(v)
        if (v.children) {
            // 有 children 就把 children 数据递归 返回  顺次放到 res 外面
            res.push(...TreeToArray(v.children))
        }
    })
    return res
}

go 版本

package main
 
import "fmt"
 
// List 构造体
type List struct {
    Name     string `json:"name"`
    Id       int    `json:"id"`
    Pid      int    `json:"pid"`
    Children []List `json:"children"`}
 
// 数据
var data = []List{{Name: "李四", Id: 2, Pid: 0},  //  []
    {Name: "王五", Id: 3, Pid: 0},  // []
    {Name: "赵六", Id: 4, Pid: 3},  // []
    {Name: "吗六", Id: 9, Pid: 3},  // []
    {Name: "张三", Id: 7, Pid: 9},  // []
    {Name: "张五", Id: 10, Pid: 4}, // []}
 
/**
 * 递归模式，数组转 tree
 * @param arr 指标数组
 * @param pid 第一级 指标 id
 * @returns {*[]} tree
 * @constructor
 */
 
func ArrayToTrees(arr []List, pid int) []List {var newArr []List
    for _, v := range arr {// 判断 pid 是否雷同  雷同就插入进去，切递归一下 children，有值就持续递归，没值就返回 []
        if v.Pid == pid {v.Children = ArrayToTrees(arr, v.Id)
            newArr = append(newArr, v)
        }
    }
    return newArr
}
 
/**
 * tree 转数组，递归模式
 * @param tree
 * @returns {*[]}
 * @constructor
 */
 
func ArrayToTree(tree []List) []List {var res []List
    for _, list := range tree {
        // tree 的每个元素都 放入到 res 外面
        res = append(res, list)
        if list.Children != nil {
            // 有 children 就把 children 数据递归 返回  顺次放到 res 外面
            res = append(res, ArrayToTree(list.Children)...)
        }
    }
    return res
}
 
/**
 * tree 转数组，循环模式，每次减少循环的变量
 *【留神：】只能应用 for 循环，不能应用 es6 的迭代器
 * @param tree
 * @returns {{length}|*}
 * @constructor
 */
 
func TreeToArrayFor(tree []List) []List {for i := 0; i < len(tree); i++ {if tree[i].Children != nil {
            // 每次 children 有值，就把值合并到原始数据 tree 下来，减少原始 tree，for 循环 的长度也会减少 顺次解决...
            tree = append(tree, tree[i].Children...)
        }
    }
    return tree
}
 
func main() {var tree = ArrayToTrees(data, 0)
    var newTree = ArrayToTree(tree)
    fmt.Println(1111, newTree, len(newTree))
}