找元素：

• arr.indexOf() 找到返回索引,找不到返回-1
• arr.includes(item,2) 从索引为2开始找,返回true 或者false 可以用于去重

增删改查

• arr.push() 末尾增加
• arr.unshift() 开头增加
• arr.pop() 末尾删除
• arr.shift() 开头删除

删除新增

arr.splice(n,m,num) 从下标为n的开始(包括n) 删除m个,把num增加到删除的n下标的前面（非常强大）

填充：

value：填充值。

start：填充起始位置，可以省略。

end：填充结束位置，可以省略，实际结束位置是end-1。

arr.fill(value, start, end) 
const arr3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
arr3.fill(7, 2, 5)
console.log('%s', arr3)
1,2,7,7,7,6,7,8,9,10,11

排序

• arr.sort(function(a,b){return a-b}) || arr.sort(function(a,b){return a.age-b.age})
• arr.sort(function() { return Math.random() - 0.5 }) 随机排列
• arr.reverse()反向排序

交换两个数

let a = 5;
let b = 8;
[a,b] = [b,a]

数据拼接

• arr.concat(arr1) 不改变原数组
• [1,2,...rest]

截取：

• arr.slice(n,m) 截取,包括n但不包括m
• arr.slice(1,-1)允许负数 不改变原数组，-1为倒数第一个，-2 为倒数第二个

字符串和数组之间转换

• arr.join('') 将数组装换成字符串,并将''里的分隔每一项
• str.split(“”) 将字符串分割为数组
• arr.toString()装换为字符串
• arr.toLocaleString() 装换为本地数组

总结：

• num.toFixed(2) 保留两位小数
• 交换两个数的值[x,y]=[y,x]
• filter()、concat() 和 slice()。它们不会变更原始数组，而总是返回一个新数组
• 返回值:增加返回新增后的长度,删除返回删除的项,splice返回删除的数组,slice返回截取的数组

数组降维 /拍平

• arr.flat() 数组降维 默认传1 ，将一个维度 ，传入 Infinity ，表示降维 一维数组，不改变原数组

function flattening(arr,num){
        if(!Array.isArray(arr)) return arr
        return arr.flat(num);
} 

• flatMap

//flatMap()允许在对数组进行降维之前，先进行一轮映射，用法和map()一样。然后再将映射的结果降低一个维度。可以说arr.flatMap(fn)等效于arr.map(fn).flat(1)。但是根据MDN的说法，flatMap()在效率上略胜一筹，谁知道呢。

//flatMap()也可以等效为reduce()和concat()的组合，下面这个案例来自MDN，但是这不是一个map就能搞定的事么？
var arr1 = [1, 2, 3, 4];


arr1.flatMap(x => [x * 2]);
// 等价于
arr1.reduce((acc, x) => acc.concat([x * 2]), []);
// [2, 4, 6, 8]

• arr.tostring().split(',’)
• 利用 reduce 进行迭代，核心的思想是递归实现

function flattening(arr,num){
        if(!Array.isArray(arr)) return arr
        return arr.reduce((a,b)=>a.concat(Array.isArray(b)?flattening(b):b),[])
}

构造数组

1. apply

Array.apply(null, { length: 10 })     Array.apply(null,[1,2,3,4])   
值为 undefined 
map(()=>100)  填充 

2.Array()

Array(10)

• empty * 10 站位
• 不能被map 填充 可以 用 fill
• Array(10).fill({})

3.Array.from

• Array.from({length:100}, (v,k) => k);

推荐这个：生成数组 ，第二个参数函数 进行遍历

伪数组/数组 之间的转化

• Array.prototype.slice.call(arguments);
• [ ].slice.call(arguments,0)
• Array.from(arguments)

判断数组

5.判断数组的方法:

使用instaceof和construcor,被判断的array必须是在当前页面声明的！

• a instanceof Array
• a.constructor == Array a的构造函数是Array
• Array.isArray(a) 推荐

清空数组

• arr.length = 0
• arr.splice(0)
• arr = []

过滤数组中的空值

• arr.filter(Boolean) 删除arr 里为false的项 null，undefined，false，0,'',NaN ， 不改变原数组

排序+去重

冒泡排序

//1. 冒泡排序,一次选一个最大的放在后面,arr.length次,每次少比较一个
  function mpSortFun(arr){
        for ( var i = 0 ; i < arr.length ; i++ ){
          //一遍就选一个最大的放在最后,要arr.length遍才能把这个数组排序好.
            for ( var j = 0 ; j < arr.length - 1 - i ; j++ ){
              //小循环，和其他元素进行比较,把最大的放在最后面,其余的我不管.
                //交换位置 arr[j] arr[j+1]
                var temp ;
                if ( arr[j] > arr[j+1] ){
                    temp = arr[j] ;
                    arr[j] = arr[j+1] ;
                    arr[j+1] = temp ;
                }
            }
        }
        return arr ;
    }

快速排序

// 2. 快速排序 一次一轮 两两交换
    function quickSortFun(arr){
        for( var i = 0  ; i < arr.length ; i++ ){//数组中的每一个数
            var min = arr[i] ;  //假设最小的值
            var minIndex = i ;  //最小值所在的索引
            for ( var j = i + 1 ; j < arr.length ; j++ ){//当前项依次于其他项进行比较
                if ( min > arr[j]){  //如果不是最小的
                    min = arr[j] ;  //把更小的值和索引交给假定的最小的值和索引
                    minIndex = j ;
                }  
            }
            //通过中间变量互换值
            arr[minIndex] = arr[i] ;  //循环结束以后,把最小的值和假设最小的值交换
            arr[i] = min ;
          
        }
        return arr ;
    }

复合排序

var arr = ["sp12","su18","au13","wi14"]
    for(var i = 0 ; i < arr.length;i++){
        for(var j = 0 ; j < arr.length-i-1;j++){
            if(parseInt( arr[j].substr(2,2) ) > parseInt( arr[j+1].substr(2,2) ) ){
                var temp = arr[j];
                arr[j]=arr[j+1];
                arr[j+1] = temp
            }
        }
    }

原生排序

arr.sort(function(a,b){return a.age-b.age}}) 

filter去重

let newarr = arr.filter((item,index)=>!arr.includes(item,index+1))     
array.filter((item,idx,arr) => arr.indexOf(item) === idx); 

set 去重

Array.from(new Set(arr)) 
const nonUnique = [...new Set(array)]; 

相邻去重

    var str = 'abccdedeefghiiiabbbbnnnsssfgg'; || 数组
    function QC(data){
        let arr
        Array.isArray(data)?arr = data:arr = data.split('')
        for(var i = 0 ; i < arr.length;i++){
            if(arr[i] == arr[i+1]){
               arr.splice(i+1,1)
                i = i-1
            }
        }
        return arr.join('')
    }
    onsole.log(QC(str))

单行的回文数检查

function checkPalindrome(str) {
  return str == str.split('').reverse().join('');
}
checkPalindrome('naman');
// 输出: true