数组与对象的转换

1.数组转对象

   const arr = [{
        label: '男',
        value: 0
      },
      {
        label: '女',
        value: 1
      }
    ]

    function f(arr) {
      return arr.reduce((sum, item) => {
        sum[item['value']] = item['label']
        return sum
      }, {})
      // reduce
    }
    const obj = f(arr) // obj ===> {0: '男', 1:'女'}
    console.log(obj)

2.对象转数组

 const obj = {
      0: '男',
      1: '女'
    }

    function f(obj) {
      let arr = []
      for (let key in obj) {
        arr.push({
          label: obj[key],
          value: key
        })
      }
      return arr
    }
    const arr = f(obj) // arr ===>  [{label: '男', value: 0},{label: '女', value: 1}]
    console.log(arr)

3.数组转树（从网页借鉴的）

方法一
   let arr = [{
        menuId: 1,
        name: '系统1',
        parentMenu: null
      },
      {
        menuId: 2,
        name: '系统1_0',
        parentMenu: 1
      },
      {
        menuId: 3,
        name: '系统1_1',
        parentMenu: 1
      }
    ]

    function turnToTreeOfOneRoot(arr) {
      if (!Array.isArray(arr)) {
        throw new Error('is not array')
      } else {
        return arr.reduce((cur, item) => {
          if (item.parentMenu == null) {
            cur = {
              children: [],
              ...item
            }
          } else if (item.parentMenu == cur.menuId) {
            cur.children.push(item)
          }

          return cur
        }, {})
      }
    }
    let newarr = turnToTreeOfOneRoot(arr)
    console.log(newarr)

   方法二
    var arr1 = [{
        menuId: 1,
        name: '系统管理1',
        parentMenu: null
      },
      {
        menuId: 2,
        name: '系统管理1_0',
        parentMenu: 1
      },
      {
        menuId: 3,
        name: '系统管理1_1',
        parentMenu: 1
      },
      {
        menuId: 4,
        name: '系统管理2_0',
        parentMenu: 2
      }
    ]

    function turnToTreeOfOneRootPlus(arr) {
      var obj = {}
      arr.forEach(item => {
        if (item.parentMenu == null) {
          obj = item
        }
      })

      return arr.reduce((h, m) => {
        // 如果不是根节点
        if (m.parentMenu) {
          foo(h, m)
        }

        // 在obj里面为cur找到归宿
        function foo(obj, cur) {
          if (obj.menuId === cur.parentMenu) {
            if (!obj.children) {
              obj.children = []
            }
            obj.children.push(cur)
          } else if (obj.children) {
            obj.children.forEach(item => {
              foo(item, cur)
            })
          }
        }

        return h
      }, obj)
    }

    let newarr = turnToTreeOfOneRootPlus(arr1)
    console.log(newarr)


//方法三
funcion fn(arr){
let newarr=[]
let map={}
 // 建立一个映射关系：通过id快速找到对应的元素
arr.forEach(item=>{
  item.children=[]
  map[item.id]=item
})
 // 对于每一个元素来说，先找它的上级
    //    如果能找到，说明它有上级，则要把它添加到上级的children中去
    //    如果找不到，说明它没有上级，直接添加到 newarr
arr.forEach(item=>{
 const parent = map[item.pid]
  if (parent) {
  // 如果存在上级则表示item不是最顶层的数据
      parent.children.push(item)
    } else {
      // 如果不存在上级 则是顶层数据,直接添加
      treeList.push(item)
    }
  })
 // 返回出去
  return newarr
}