常见数组操作

数组去重

//利用filter
function unique(arr) {
  return arr.filter(function(item, index, arr) {
    console.log(item,arr.indexOf(item, 0),index);
    //当前元素在原始数组中的第一个索引==当前索引值，如果是返回当前元素
    return arr.indexOf(item, 0) === index;
  });
}
console.log(unique([1,1,2,2,3])) //[1,2,3]

//利用ES6 Set去重（ES6中最常用）
function unique (arr) {
  return Array.from(new Set(arr))
}
let arr = [1, true, true, false, undefined, null, NaN, NaN, 0, "a", {}, {}]
console.log(unique(arr))
 //[1, true, false, undefined, null, 0, "a", {…}, {…}]
// NaN === NaN //false, NaN 找不到自己，返回 -1

//利用 reduce
function unique(arr){
  return arr.reduce((pre,item)=>{
    if(!pre.includes(item)){
      pre.push(item)
    }
    return pre
  },[])
}
console.log(unique([1,1,2,2,3])) //[1,2,3]

数组排序

1. 插入排序

//插入排序
function sort(elements){
    // 假设第0个元素是一个有序数列，第1个以后的是无序数列，
    // 所以从第1个元素开始将无序数列的元素插入到有序数列中去
    for (var i =1; i<=elements.length; i++) {
        // 升序
        if(elements[i] < elements[i-1]){
            // 取出无序数列中的第i个作为被插入元素
            var guard=elements[i];
            //记住有序数列的最后一个位置，并且将有序数列的位置扩大一个
            var j=i-1;
            elements[i]=elements[j];
            // 比大小;找到被插入元素所在位置
            while (j>=0 && guard <elements[j]) {
                elements[j+1]=elements[j];
                j--;
            }
            elements[j+1]=guard; //插入
        }
    }
}
var elements=[3,5,6,8,2,4,7,9,1,10];
document.write('没调用之前：'+elements);
document.write('<br>');
sort(elements);
document.write('被调用之后：'+elements);

2. 快速排序

//快速排序
function quickSort(elements){
    if(elements.length <=1){
      return elements;  
    }
  var pivotIndex=Math.floor(elements.length / 2);
  var pivot=elements.splice(pivotIndex,1)[0];
  var left=[];
  var right=[];
  for(var i=0;i<elements.length;i++){
    if(elements[i] < pivot){
        left.push(elements[i]);
    }else{
       right.push(elements[i]);
    }
  } 
return  quickSort(left).concat([pivot],quickSort(right));
//concat()方法用于连接两个或者多个数组；该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。
};
var elements=[3,5,6,8,2,4,7,9,1,10];
document.write(quickSort(elements));

js 的 sort() ：插入排序+快速排序

• 数组长度不超过10时，使用插入排序。在数组较短时插入排序更有效率。
• 长度超过10使用快速排序。

3. 冒泡排序

//冒泡排序
function sort(elements){
    for(var i=0;i<elements.length-1;i++){
       for(var j=0;j<elements.length-1-i;j++){
          if(elements[j] > elements[j+1]){
               var  swap=elements[j];
               elements[j]=elements[j+1];
               elements[j+1]=swap;
          }
       }
    }
}
var elements=[3,5,6,8,2,4,7,9,1,10];
console.log('before'+elements);
sort(elements);
console.log('after'+elements);

判断两个数组包含的值完全相同，顺序无所谓

let flag = true
    const listA = [1, 2, 3]
    const listB = [2, 3, 4]
    if (listA.length !== listB.length) {
      flag = false
    } else {
      listA.forEach(item => {
        if (listB.indexOf(item) === -1) {
          flag = false
        }
      })
    }