数组的遍历+es5+es6新增数组方法+数组经典案例(冒泡,选择,快速,数组去重)

数组的遍历

1.for

 		var arr1 = [11, 22, 33, 44, 55];
        arr1.length = 20;
        for (var i = 0; i < arr1.length; i++) {
            console.log(arr1[i]);
        }

2.for…in

  		var arr1 = [11, 22, 33, 44, 55];
        arr1.length = 20;
        for (var k in arr1) {
            console.log(k, arr1[k]);//k 下标,arr1[k]值
        }

for与for…in区别

 for 和for..in的区别?
            for是根据数组的length长度,来决定遍历的次数(遍历稀疏数组)
            for in 是根据内容来遍历次数(不遍历稀疏数组)
            for in 还能遍历下标不是数组,for只能遍历下标为数值的
            数组是特殊的对象

	 var arr = [11, 22, 33];
        arr["aa"] = 88;
        arr["bb"] = 99;
        console.log(arr);

        for (var i = 0; i < arr.length; i++) {
            console.log(arr[i]);//11,22,33

        }
        for (var key in arr) {
            console.log(arr[key]);//11,22,33,88,99
        }

5.数组的方法(ES5)

1.forEach

forEach(function(items,index){}) 没有返回值

items是数组元素

index是元素索引

 /* 
            forEach  只能做遍历,没有返回值
            不能被中止
            可以制造异常,结合 try..catch中断
        */ 
	var arr = [11, 22, 33, 44, 55];
        try {
            // item 是值 index是索引
            arr.forEach(function (item, index, aaa) {
                console.log(item, index, aaa);
                if (index == 2) {
                    throw new Error("制造异常");
                }

            })
        } catch (error) {

        }
        console.log(111);

2.map()

map 能做遍历,返回一个新的数组

新数组的内容,由回调函数决定

 var arr = [11, 22, 33, 44, 55];
        var res = arr.map(function (item, index, arr) {
            return item * 10
        })
        console.log(arr);// [11, 22, 33, 44, 55];
        console.log(res);//[110, 220, 330, 440, 550]

3.some()

some 只要一个满足条件,就返回true

在遍历过程中,条件满足,就中断遍历

 var arr = [11, 22, 33, 44, 55];
        var res = arr.some(function (item) {
            console.log(item);
            return item == 33
        })
        console.log(res);

4.every()

every()所有结果都满足返回true ,否则返回(默认)false

  var arr = [11, 22, 33, 44, 55];
	var res=arr.every(function(item){
        return item>20;
    })
    console.log(res);//false 因为11不满足比20大,所有返回false

5.filter()

filter()过滤,返回一个新的数组,数组的内容,有回调函数的条件决定

  var arr = [11, 22, 33, 44, 55];
var res=arr.filter(function(item){
    return item>20;
})
console.log(res);//[22,33,44,55]  返回满足条件的新数组

6.reduce()

reduce()有两个参数,第一个参数是回调函数,第二个参数是给pre的初始值

 // var arr = [11, 22, 34, 44, 55]
        // arr.reduce(function (pre, cur) {
        //     console.log(pre,cur);
        //     return 1
        // },100)
        //  var arr = [11, 22, 34, 44, 55]
        // arr.reduce(function (pre, cur) {
        //     console.log(pre,cur);
        //     return 1
        // })
        var arr = [11, 22, 34, 44, 55]
        var res = arr.reduce(function (pre, cur) {
            // pre 11 cur 22 -->33
            // pre 33 cur 34    67
            // pre 67  cur 44  111
            // pre 111 cur 55  166
            return pre + cur
        })
        console.log(res);//166
        var arr = [11, 22];
        var res = arr.reduce(function (pre, cur) {
            return pre * cur
        })
        console.log(res);//242

6.数组的方法(ES6)

1.find()

通过条件查找某一项,如果存在就返回这一项

var arr = [
            { id: 1, name: "刘德华", age: 20 },
            { id: 2, name: "刘德", age: 20 },
            { id: 3, name: "刘", age: 20 },
            { id: 4, name: "华", age: 20 },
        ]
var res=arr.find(function(item){
    return item.id==1;
})
console.log(res)//{id: 1, name: '刘德华', age: 20}

2.findIndex()

返回满足条件的下标

var arr = [
            { id: 1, name: "刘德华", age: 20 },
            { id: 2, name: "刘德", age: 20 },
            { id: 3, name: "刘", age: 20 },
            { id: 4, name: "华", age: 20 },
        ]
var res=arr.findIndex(function(item){
    return item.id==3;
})
console.log(res)//2

3.indexOf()

找到了返回下标,找不到返回-1

它有两个参数,第二个参数默认从0开始,也可以从指定的位置开始

        var arr = [11, 22, 33, 44, 55]
        console.log(arr.indexOf(22, 2));//-1 因为从第二个开始的后面没有22,所以返回-1
        console.log(arr.indexOf(22));//1

4.includes()

有就返回true ,没有就返回false

 var arr = [11, 22, 33, 44, 55]
        console.log(arr.includes(22));//true 有就返回true ,没有就返回false

7.数组的经典案例(冒泡,选择,快速排序,数组去重)

1.冒泡排序

冒泡排序口诀:

​ 1.外层循环-1

​ 2.内层循环-1-i

​ 3.内层循环两邻两个比较大小

​ 4.邻里交换位置

   var arr = [1, 9, 5, 6, 10, 3];
	//外层循环 循环次数 5个数循环4次 6个数循环5次 所以-1
	for(var i=0;i<arr.length-1;i++){
        //内层循环 循环躺数  -1是为了防止j+1造成下标越界,-i是因为比较一次下来,会出来一个最大的,就不要再			//比较,刚好跟i的增长一样
        for(var j=0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){
                var temp=arr[j];
                arr[j]=arr[j+1]
                arr[j+1]=temp
            }
        }
    }
console.log(arr)
 /*
            1.为什么外循环要-1?
            外层循环次数,交换四次,五个数交换4次,4个数交换三次,所以-1
            2.为什么内层循环-1又-i?
            -1防止下班越界 j+1容易出现越界 -i是因为比较一轮会选出一个最大的数,然后这个最大的数就不进行			比较刚好和i的增长是一样
            3.比较的时候为什么是j和j+1
            前一个数和后一个数进行比较

        */

2.选择排序

 		// 台上的和台下的进行比较	
		var arr = [5, 6, 7, 4, 3];
		//台上
		for(var i=0;i<arr.length-1;i++){
            //假设第一个是获胜
            var win=i;
            //台下
            for(var j=i+1;j<arr.length;j++){
                //如果我假设的这个输了,那就把赢的那个的下标赋值给我指定的这个win
                if(arr[win]<arr[j]){
                    win=j;
                }
            }
            if(win!=i){
                var temp=arr[win]
                arr[win]=arr[i]
                arr[i]=temp
            }
        }
	console.log(arr)

3.快速排序

    //1.定义个方法，输入一个数组
        function quickSort(arr) {
            //2.如果数组的长度小于2，就返回输入的数组（小于2个，没办法比较)
            if (arr.length < 2) {
                return arr;
            }
            //3.如果是大于等于2，找出下标，遇到不能被整除，向下取整
            var middleIndex = parseInt(arr.length / 2);
            //4.通过中间下标，得到中间数，并且要从原来数组扣出来
            var middleValue = arr.splice(middleIndex, 1);
            //5.准备2个空数组，左边和右边的空数组
            var left = [], right = [];
            //6.大于中间数放置右边数组，否则放置左边数组
            for (var i = 0; i < arr.length; i++) {
                if (arr[i] > middleValue) {
                    right.push(arr[i])
                } else {
                    left.push(arr[i])
                }
            }

            //7.递归进行继续拆，拆到只有1个数的数组，就不拆
            //进行合并  左边数组+中间+右边数组
            return quickSort(left).concat(middleValue, quickSort(right));
        }
        var res = quickSort([5, 6, 7, 4, 3]);
        console.log(res);

4.数组去重

 // 数组去重
        var arr = [1, 2, 3, 2, 1, 4, 3, 6, 6, 9, 7, 9];
        function noRepeat(arr) {
            // 创建新数组
            var newArr = [];
            for (var i = 0; i < arr.length; i++) {
                // 把每一项放到空数组,在放到空数组之前,问 是否已存在
                // 如果存在 就不添加
                // if (newArr.indexOf(arr[i]) == -1) {
                //     newArr.push(arr[i])
                // }
                // includes 找到了返回true,找不到返回false
                if (!newArr.includes(arr[i])) {
                    newArr.push(arr[i])
                }
            }
            return newArr
        }
        console.log(noRepeat(arr));