学习笔记

/**
 * 数组
 */
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
}

// 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
}

var tree = ArrayToTrees(data, 0) 

/**
 * 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
}