常用数据处理方式：数组或对象去重、把对象数组根据不同的id分组、递归遍历、对象数组取某个属性的最大值或最小值等

一、循环对象数组根据标识不同分组（我这里的标识是ParentAttributesID）

<script>
    export default({
        data(){
           selected[
	           {"AttributesTitle":"大陆国行","AttributesID":42,"Price":0,"ParentAttributesID":12,"type":0},
	           {"AttributesTitle":"香港行货","AttributesID":43,"Price":0,"ParentAttributesID":12,"type":0},
	           {"AttributesTitle":"16G","AttributesID":50,"Price":0,"ParentAttributesID":48,"type":0},
	           {"AttributesTitle":"A级","AttributesID":1,"Price":0,"ParentAttributesID":"-1","type":1}
            ],
	        skuLists:[]
        }
   })
</script>
 var map = {},dest = [];
 for(var i = 0; i < $that.selected.length; i++){                
       var ai = $that.selected[i]; 
       if(!map[ai.ParentAttributesID]){
          dest.push({
             ParentAttributesID: ai.ParentAttributesID,
             data: [ai]
          });
          map[ai.ParentAttributesID] = ai;
       }else{
          for(var j = 0; j < dest.length; j++){
             var dj = dest[j];
             if(dj.ParentAttributesID == ai.ParentAttributesID){
                dj.data.push(ai);
                break;
             }
          }
       }
    }
   for(var i = 0;i<dest.length;i++){
        $that.skuLists.push(dest[i].data)
    }

效果图如下

二、对数组去重（这里AttributesID是唯一标识）

 //去重
 let hash = {}; 
 $that.selected =  $that.selected.reduce((preVal, curVal) => {
      hash[curVal.AttributesID] ? '' : hash[curVal.AttributesID] = true && preVal.push(curVal); 
      return preVal 
   }, [])

三、利用递归传递不同的数组自由组合

 let attributList = [
      [{
            "ID": 1,
            "Title": "国行"
        }, {
            "ID": 2,
            "Title": "水货"
        }],
        [{
            "ID": 3,
            "Title": "64G"
        }, {
            "ID": 4,
            "Title": "128G"
            }],
        [{
            "ID": 5,
            "Title": "金色"
        }, {
            "ID": 6,
            "Title": "白色"
            }, {
            "ID": 7,
            "Title": "黑色"
            }],
        [{
            "ID": 555,
            "Title": "A级"
        }, {
            "ID": 666,
            "Title": "B级"
            }, {
            "ID": 777,
            "Title": "C级"
            }]
    ];
function creatSKU() {
    return Array.prototype.reduce.call(arguments,function(a, b) {
        var ret = [];
        a.forEach(function(a) {
            b.forEach(function(b) {
                ret.push(a.concat([b]));
            });
        });
        return ret;
    }, [[]]);
}
 
var skuList =creatSKU(...attributList )

效果如下

四、递归遍历

//封装方法
function buildTree(data){
      //构建tree的根节点 即超级管理员
       var tree = new Object();
       parseTree(data, tree);
       var list  = new Array();
       list.push(tree);
       return list;
  }
 function parseTree(data, tree) {
      tree.label = data.RoleName;
      tree.id = data.ID;
      //构建子节点
      var subTree = data.listManagerRole;
      if(!subTree || subTree.length === 0) {
          return tree;
      } else {
        var children = new Array();
        for(var i = 0, len = subTree.length;i < len; i++) {
           var child = new Object();
           child = parseTree(subTree[i], child)
           children.push(child)
        }
          tree.children = children;
          return tree;
       }
  }

五、常见的排序算法（冒泡排序、快速排序）

（1）冒泡排序

function bubble(arr){
   for(var i = 0;i<arr.length;i++){
         for(var j  = 0;j<arr.length-1-i;j++){
               if (arr[j] > arr[j+1]) {        //相邻元素两两对比
                var temp = arr[j+1];        //元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
          }
       }
      return arr
}

（2）快速排序

function quickArr(arr){
      if(arr.length<=1){return arr;}
      var middle = arr[0];
      var left = [],right = [];
      for(var i = 1;i<arr.length;i++){
             if(arr[i]<middle){
                    left.push(arr[i]);
              }else{
                    right.push(arr[i]);
              }
        }
        return quickArr(left).concat(middle,quickArr(right));
 }

六、取对象数组中的某个属性的最大值和最小值

/**
	arr：对象数组
	type：last取最大值、first取最小值
**/
 function getNumber(arr,type){
      for(var i= 0;i<arr.length;i++){
        if(type=='last'){
          return Math.max.apply(Math, arr.map(function(o) {return o.number}))
        }else if(type=='first'){
          return Math.min.apply(Math, arr.map(function(o) {return o.number}))
        }
      }
    }