//长度
function arrLength(arr){
    return arr.length;
}

//增
// 向数组的尾部添加新的元素
function arrPush(arr,item){
    arr.push(item);
    return arr;
}

// 向数组元素的前面添加元素
function arrUnshift(arr,item){
    arr.unshift(item);
    return arr;
}


//删
// 删除数组里面的最后一个元素
function arrPop(arr){
    arr.pop();
    return arr;
}

// 删除数组里面的第一个元素
function arrShift(arr){
    arr.shift();
    return arr;
}

// 删除数组里面的某一项
// slice方法,不会改变原始数组。
function delArrItem(arr,starIndex,endIndex){
    //这里如果不赋值，就会返回原数组，而原数组是不会被改变的
    let newArr=arr.slice(starIndex,endIndex);
    return newArr;
}

//改
function arrChange(arr,index,newItem){
    arr[index]=newItem;
    return arr;
}

//查找
//查找是否存在数组中
function includes(arr,item){
    return arr.includes(item);
}

//方法
//splice对数组进行删除或添加,会改变原数组
/*
    arr数组
    index开始删除的索引
    delLength删除的长度
    insert插入的元素
*/

function arrSplice(arr,index,delLength,insert){
    if(typeof insert!='undefined'){
        arr.splice(index,delLength,insert);
    }else{
        arr.splice(index,delLength);
    }
}

//两个数组合并
function concat(arr1,arr2){
    let newArr=arr1.concat(arr2);  //方案1
    // let newArr=[...arr,...arr2]; //方案2
    return newArr;
}

//排序
//反向
function arrRev(arr){
    arr.reverse();
    return arr;
}    

//sort排序
function arrSort(arr,type){
    if(type==1)  arr.sort((a,b)=>a-b);  //从小到大排序
    else if(type==-1)  arr.sort((a,b)=>b-a);  //从大到小 
    return arr;
}

/*
    对比两个数组是否相同，不说顺序，
    执行这个方法之前先把两个数组排序
*/
function isSame(arr1,arr2){
    if(arrLength(arr1)==arrLength(arr2)){
        for(let i in arr1){
            if(arr1[i]!=arr2[i]){
                return false
            }
        }
        return true;
       
    }else{
       return false;
    }
}

//对比两个数组中是否存在相同的
//不包括元素是对象类型的
function hasSame(arr1,arr2){
    let sameArr=[];
    let result=false;
    arr1.filter((item)=>{
        result=includes(arrPush(sameArr,includes(arr2,item)),true); 
    })
    return result;
}

//判断数组中的元素类型
function itemType(arr){
    for(let i in arr){
        if(typeof arr[i]=='object'){
           if (isObject(arr[i])) 'object'
           else arr[i]    
        }else{
            return typeof arr[i];
        }
    }
}

//查找数组中的每个对象是否存在相同的key
function getRmName(arr){
    let rmObj={};
    let rmName='';
    arr.find(item=>{
        for(let key in item){
            rmObj[item[key]]=[];
        }
    })

    arr.find(item=>{
        for(let key in item){
            rmObj[item[key]].push(key)
        }
    })

    for(let i in rmObj){
        if(rmObj[i].length==arr.length){
            rmName=rmObj[i][0];
        }
    }
    return rmName
}


//数组求和
function sum(arr){
    // arr 例子 [1, 2, 3, 4, 5]
    const sum = arr.reduce((pre, item) => {
        return pre + item
    }, 0)
    return sum;
}

/**********数组去重************/
//判断是不是对象
function isObject(data){
    if(Object.prototype.toString.call(data) == '[object Object]'){
        return true;
    }else{
        return false;
    }
}

//二维数组去重
function removeRepeat(arr){
    const obj={};
    return arr.filter(item=>{
      console.log(item.toString())
      if(!obj[item.toString()]) {
        obj[item.toString()]=item.toString();
        return item;
      }
    });
}

//数组里面的对象去重
//先把对象转成字符串，进行去重，然后再转回来
function arrObj(arr){
    let arrList=[];
    for(let i in arr){
        arrList.push(JSON.stringify(arr[i]))
    }
    let newArr=[...new Set(arrList)];
    let arrResult=[];
    for(let i in newArr){
        arrResult.push(JSON.parse(newArr[i]))
    }

    return arrResult;
}

//综合数组去重
function removal(arr) {
    //无论存在数组中是否存在对象，都先去一次重再分类
    let newArr = [...new Set(arr)];  

    //把arr分为对象和非对象两个数组
    let arrList=[]; //单维数组
    let arr2List=[];  //二维数组
    let objList=[];  
    let resultArr=[]; //去重后的结果
    for(let i in newArr){
        if(typeof newArr[i]=='object'){
           if (isObject(newArr[i])) objList.push(newArr[i])
           else if(Array.isArray(newArr[i])) arr2List.push([...new Set(newArr[i])])
           else arrList.push(newArr[i]) 
        }else{
            arrList.push(newArr[i]);
        }
    }

    if(arr2List.length>=2){
        arr2List=removeRepeat(arr2List)
    }

    if(objList.length>=2){
        objList=arrObj(objList);
    }

    resultArr=[...arrList,...arr2List,...objList]
    return resultArr;
}