js 中数组级联组合

//一级数组对象，根据key值组合多级
//[{code1:'',code2''}]=>{code1:{code2:{code1:'',code2''}}}
//[{code1:'',code2''}]=>[{code:'',children:[{code1:'',code2''}]}]
//arrData:数组数据，arrCode:分级字段数组可多级

function CascadeArr(arrData,arrCode) {
  let arrResult = [];
  let arrCodeObj = {};
  // console.log(JSON.parse(JSON.stringify(arrData)))
  // console.log(JSON.parse(JSON.stringify(arrCode)))
  for(let i = 0;i < arrData.length;i++){
    let item = arrData[i];
    for(let j = 0;j < arrCode.length;j++){
      getCodeCascade(arrCodeObj,0,j,arrCode.length-1);
    }
    //obj传入的每一级对象，
    // idx:分级数组code每一级都要从第一级开始循环添加，
    // idxlen:分级数组code下标（当前级别递归循环次数）,
    // alllen:分级数组code长度（一共多少级）,
    function getCodeCascade(obj, idx, idxlen,alllen) {
      if(idx < idxlen){
        if(!obj.hasOwnProperty(item[arrCode[idx]])){
          obj[item[arrCode[idx]]] = {};
        }
        getCodeCascade(obj[item[arrCode[idx]]],idx+1,idxlen,alllen);
      }else{
        if(idx === idxlen&&idx === alllen){
          if(!obj.hasOwnProperty(item[arrCode[idx]])){
            obj[item[arrCode[idx]]] = [];
          }

          obj[item[arrCode[idx]]].push(item);
        }else{
          if(!obj.hasOwnProperty(item[arrCode[idx]])){
            obj[item[arrCode[idx]]] = {};
          }
        }
      }
    }
  }
  // console.log(JSON.parse(JSON.stringify(arrCodeObj)))
  let arrCellWidth = [];//设置列宽所用数据element ui table 用来设置列宽
  //通过层级对象数据，获取层级数组
  let getCascadeArr = (objOrigin,level,parent) => {
    for(let k in objOrigin){
      let objItem = objOrigin[k];
      let obj = {
        id:this.$getGuid(),
        level:`${parseFloat(level)+1}`,
        children:[],
      };
      obj[arrCode[level]] = k;

      if(!Array.isArray(objItem)){
        if(parent){
          parent.children.push(obj);
        }
        getCascadeArr(objItem,parseFloat(level)+1,obj);
      }else{
        if(parent){
          let lastLevel = {
            id:this.$getGuid(),
            level:`${parseFloat(level)+1}`,
            children:[],
          };

          for(let l = 0;l < objItem.length;l++){
            let lastItem = objItem[l];
            if(!lastLevel.hasOwnProperty(arrCode[level])){
              lastLevel[arrCode[level]] = lastItem[arrCode[level]];
            }
            let findIdx = lastLevel.children.findIndex(val=>{
              return val[arrCode[level]] === lastItem[arrCode[level]];
            });
            if(findIdx === -1){
              lastItem = {
                id:this.$getGuid(),
                level:`${parseFloat(level)+2}`,
                ...objItem[l],
              };
              lastLevel.children.push(lastItem);
            }
          }
          // console.log(JSON.parse(JSON.stringify(lastLevel)))
          // console.log(JSON.parse(JSON.stringify(parent.children)))
          parent.children.push(lastLevel);
          arrCellWidth = arrCellWidth.concat(objItem);
        }else{
　　　　　　if(arrCode.length===1){
　　　　　　　　obj['children'] = objItem;
　　　　　　}　　　　　
　　　　 }
      }
      arrCellWidth.push(obj);
      if(level === 0){
        arrResult.push(obj);
      }
    }
  };
  getCascadeArr(arrCodeObj,0);

  // console.log(JSON.parse(JSON.stringify(arrResult)))
  return {CascadeObj:arrCodeObj,CascadeArr:arrResult,arrCellWidth:arrCellWidth};
}

 

更新问题，数组级联根据对象来，顺序会有点变化（对象key排序问题）

function CascadeArr(arrData, arrCode) {
  // console.log(JSON.parse(JSON.stringify(arrData)));
  // console.log(JSON.parse(JSON.stringify(arrCode)));
  let CascadeArr = [];//返回级联数组
  let CascadeObj = {};//返回级联对象
  
  //级联对象
  //obj传入的每一级对象，
  // idx:分级数组code每一级都要从第一级开始循环添加，
  // idxlen:分级数组code下标（当前级别递归循环次数）,
  // alllen:分级数组code长度（一共多少级）,
  let getCodeCascade = (item, obj, idx, idxlen, alllen) => {
    if (idx < idxlen) {
      if (!obj.hasOwnProperty(item[arrCode[idx]])) {
        obj[item[arrCode[idx]]] = {};
      }
      getCodeCascade(item, obj[item[arrCode[idx]]], idx + 1, idxlen, alllen);
    } else {
      if (idx === idxlen && idx === alllen) {
        if (!obj.hasOwnProperty(item[arrCode[idx]])) {
          obj[item[arrCode[idx]]] = [];
        }

        obj[item[arrCode[idx]]].push(item);
      } else {
        if (!obj.hasOwnProperty(item[arrCode[idx]])) {
          obj[item[arrCode[idx]]] = {};
        }
      }
    }
  };

  //级联数组
  let addCascadeArrChildren = (item, codeIdx, parent) => {
    let obj = {
      level: codeIdx + 1,
      [arrCode[codeIdx]]: item[arrCode[codeIdx]],
      children: [],
    };
    let hasItemIdx = parent.findIndex((val, idx) => {
      return val[arrCode[codeIdx]] === obj[arrCode[codeIdx]];
    });
    if (hasItemIdx === -1) {
      obj.children = [JSON.parse(JSON.stringify(item))];
      parent.push(obj);
    } else {
      // parent[hasItemIdx].children.push(JSON.parse(JSON.stringify(item)));
      if(!parent[hasItemIdx].children){
        parent[hasItemIdx].children = [JSON.parse(JSON.stringify(parent[hasItemIdx]))]
      }
      if(codeIdx === arrCode.length - 1){
        parent[hasItemIdx].children.push(JSON.parse(JSON.stringify(item)));
      }else{
        addCascadeArrChildren(item, codeIdx + 1, parent[hasItemIdx].children);
      }
    }
  };

  for (let i = 0; i < arrData.length; i++) {
    let item = arrData[i];

    for (let j = 0; j < arrCode.length; j++) {
      getCodeCascade(item, CascadeObj, 0, j, arrCode.length - 1);
    }

    addCascadeArrChildren(item, 0, CascadeArr);
  }

  // console.log(JSON.parse(JSON.stringify(CascadeObj)));
  // console.log(JSON.parse(JSON.stringify(CascadeArr)));

  return { CascadeObj: CascadeObj, CascadeArr: CascadeArr };
}

 

翻译

搜索

复制