数组常用方法，数组遍历，数组去重

数组常用方法

unshift()在首部添加数据

// unshift 在数组首部添加
arr.unshift(0,2);
console.log(arr) // 0,2,1,2,3,4,5,6

push() 在尾部添加数据

var arr = [1,2,3];
// push 在末尾添加
arr.push(4,5,6);
console.log(arr) // 1,2,3,4,5,6

splice() 在指定位置添加数据

// splice 在指定位置添加指定数据
// splice(添加的位置，截取几位，添加的数)
// splice(0,2,99,99,99) 在第一位添加，截取2位数，添加99,99,99
arr.splice(0,2,99,99,99)
console.log(arr) // 99,99,99,1,2,3,4,5,6

shift()在首部删除数据

// shift 在首部删除
arr.shift(0)
console.log(arr) // 99, 99, 1, 2, 3, 4, 5

pop()在尾部删除元素

// pop在末尾删除一个
arr.pop(0);
console.log(arr) //99, 99, 99, 1, 2, 3, 4, 5

slice()在指定位置截取数据 不会改变原数据

// slice 在指定位置截取（起始位置，终止位置）
// 截取的位置包含起始位置，不包含终止位置
// 且不会改变原数组
var slice = arr.slice(2,5);
console.log(arr) //99, 99, 1, 2, 3, 4, 5
console.log(slice) //1,2,3

concat()数组拼接

// concat() 数组拼接
var arr1 = [1,2,3]
var arr2 = [3,4,5];
var arr3 = arr1.concat(arr2);
console.log(arr3); // 1,2,3,4,5

reverse()数组翻转

// reverse() 数组翻转
arr.reverse()
console.log(arr) // 5, 4, 3, 2, 1, 99, 99

sort()数组排序

数组遍历

indexOf()数组遍历（可用于查找某个元素是否存在）

	var arr9 = [1,2,3,4,5,6,9]
    console.log(arr9.indexOf(2));  //1(数组下标)
    console.log(arr9.indexOf(99)) // -1(不存在返回-1)

for循环遍历数组

 for(var i = 0; i< arr5.length; i++) {
        console.log(arr5[i]
   }

for… in 遍历数组（遍历的是索引号）

for(let index in arr) {
	console.log(arr[index]
}

for … of遍历数组（遍历的是值）

	for(let item of arr) {
	console.log(item)
}

map() 遍历数组（遍历数组并操作数组元素，并返回新的数组）

var arr9 = [1,2,3,4,5,6,9]
    let newArr = arr9.map(function(item,index){
        return item * 2;
    })
    console.log(newArr) //2, 4, 6, 8, 10, 12, 18

forEach()遍历数组

	 var arr9 = [1,2,3,4,5,6,9]
    arr9.forEach(function(item,index){
    })

filter() 遍历数组 过滤 筛选数组

var arr9 = [1,2,3,4,5,6,9]
    let newArray = arr9.filter(function(item,index) {
        return item % 2 == 0
    })
    console.log(newArray) //[2, 4, 6]

some() every()遍历数组遍历之后返回值为boolean

	var arr9 = [1,2,3,4,5,6,9]
    let newsomeArr = arr9.some(function(item,index){
        return item % 2 == 0
    })
    console.log(newsomeArr) // true
    let neweveryArr = arr9.every(function(item,index) {
        return item % 2 == 0
    })
    console.log(neweveryArr) // false

数组去重

set() ES6新增 （{} 无法去掉）

// 1.set() 无法去掉{}
    var arr5 = [1,6,99,1,3,6,0,10,55,undefined,{},{},null,null,NaN,NaN,undefined]
    var arr6 = Array.from(new Set(arr5));
    console.log(arr6) // 1, 6, 99, 3, 0, 10, 55, undefined, {…}, {…}, null, NaN

for嵌套for 然后splice()截取重复的 (NaN 去重不了，null直接消失)

2. for嵌套for 然后splice去重 (NaN 去重不了，null直接消失)
    function qc(arr) {
        for(var i = 0; i< arr5.length; i++) {
        for(var j = i + 1; j < arr5.length; j++) {
            if(arr[i] == arr[j]) {
                arr.splice(j,1);
                j--
            }
        }
    }
        return arr
    }
    
    console.log(qc(arr5));// 1, 6, 99, 3, 0, 10, 55, undefined, {…}, {…}, NaN, NaN

indexOf()去重 {}和NaN不能去重
新建空数组，将原数组的元素依次添加到新数组中，然后通过判断新数组是否存在该元素，如果不存在再添加到新数组

// 3.indexOf() {}和NaN不能去重
    var arr8 = [1,6,99,1,3,6,0,10,55,undefined,{},{},null,null,NaN,NaN,undefined]
        function qc2(arr) {
            var array = []
            for(var i = 0; i <arr.length; i++) {
                if(array.indexOf(arr[i]) === -1) {
                    array.push(arr[i])
                }
            }
            return array
        }
        console.log(qc2(arr8)) // 1, 6, 99, 3, 0, 10, 55, undefined, {…}, {…},null, NaN, NaN

fliter()去重

// 6.filter() // NaN 消失，{} 未去重
            function qc5(arr) {
                return arr.filter(function(item,index,arr) {
                    // indexOf(item,0) 查找item,从0开始查找
                    // 当前元素在原始数组中的第一个索引 == 当前索引值，否则返回当前元素
                    return arr.indexOf(item,0) === index;
                })
                
            }
            console.log(qc5(arr8))

sort()去重 // NaN 和 {} 无法去掉

// 4.sort() 先排序再判断 arr[i] 是否与 arr[i+1]相等;
            // NaN 和 {} 无法去掉
        function qc3(arr) {
            arr= arr.sort();
            var array = [];
            for(var i = 0; i< arr.length; i++) {
               
                if(arr[i] !== arr[i+1]) {
                   
                    array.push(arr[i])
                }
            }
            return array
        }
       
        console.log(qc3(arr8)) //0, 1, 10, 3, 55, 6, 99, NaN, NaN, {…}, {…}, null

includes() {}不能去重

// 5.includes()     {}不能去重
        //  循环整个数组，新建一个新的空数组，判断新的数组中是否含该值，如果不含就将该值拼接在新数组中；
            function qc4(arr) {
                var array = []
                for(var i = 0; i<arr.length;i++) {
                    if(!array.includes(arr[i])) {
                        array.push(arr[i])
                    }
                }
                return array
            }
            console.log(qc4(arr8))