数组

数组是一组相关数据的集合

是一个特殊的对象 typeof(arr) ==="object"

创建数组

1.new Array()   创建的数组都会继承Array对象，可以使用很多数组内置的属性或者方法
var arr = new Array 
var arr3 = new Array(3); // 如果传递一个数字参数，则是创建数组并指定数组的长度 
console.log(arr3);    // [empty × 3]
var arr3 = new Array("a", "a2", "a3"); // 如果传递是非数字或者参数大于1，则是设置为数组的元素。
console.log(arr3);  // ['a', 'a2', 'a3']

2.利用字面量创建数组[]
var arr = [];  //创建一个空数组

特性

数组元素索引从0开始 arr[索引] (数组操作通过索引下标)
超出数组长度的索引输出结果 undefined
数组索引到3 指定5号索引的内容自动填充4索引，内容为空,输出为undefined
空位返回的值是undefined , length 包含空位empty
数组长度 arr.length

检测是否为数组

1.参数 instanceof Array

var arr = [1, 2, 3]
var string = "123"
console.log(arr instanceof Array);   //true
console.log(string instanceof Array);   //false

//后面还可以跟其他数据类型
var obj = {};
console.log(obj instanceof Object);//true

2.Array.isArray(参数) H5新增的方法，ie9以上版本支持

Array() 也是一个构造函数(可以构造一个数组出来)

console.log(Array.isArray(arr));   //true
console.log(Array.isArray(string)); //false

遍历数组

1.for循环遍历

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

2.内置方法 forEach()

可以遍历数组的每一个元素，item就是遍历数组的元素。

forEach遍历使不能使用break; 内部是一个回调函数不能return

数组.forEach(function(item){ 
      console.log(item);
    })

3.es6 map(function(item,[index]){return item}) 遍历数组的成员，把成员作为函数的参数

函数里面需要返回一个成员，然后再返回一个新的数组。

可以用来修改数组的成员 , 不影响原数组

    var arr1 = ["a", "b", "c", "d"];
    var newArr = arr1.map(function (item) {
      item += 666;
      return item;
    })
    console.log(newArr);  //['a666', 'b666', 'c666', 'd666']
    console.log(arr1);  //['a', 'b', 'c', 'd']

4.for...in 遍历数组

一般不用for in遍历，开销比较大

 for(var item in arr1){    //item就是索引
    console.log(arr1[item]);
 }

伪数组（类似数组对象）

具有length属性按索引方式储存数据

不具有数组的push()、pop()等方法

函数的arguments参数就是一个类数组对象

数组方法

数组转字符串

原生js

var str = ""
    for (var i = 0; i < arr.length; i++) {
        str += arr[i] + ","
    }
console.log(str)

内置方法

1.arr.toString()

var arr2 = ["zhangsan", "lisi", "wangwu", "lisi"];
console.log(arr2.toString()); //zhangsan, lisi, wangwu, lisi

2.arr.join(指定分隔符)

console.log(arr2.join()); //默认是逗号 zhangsan, lisi, wangwu, lisi
console.log(arr2.join("-")); //zhangsan-lisi-wangwu-lisi

添加元素

push() 数组末尾添加一个或多个元素

返回结果为新数组的长度会改变原数组

var arr = [1, 2, 3]
res = arr.push(4, 5, "13")   //6

unshift() 数组的头部添加一个或多个元素

返回结果为新数组的长度会改变原数组

res = arr.unshift("hello",5)  //8

concat() 可以接受其他类型的参数，把参数作为数组元素合并到数组里面。

push是在原数组的基础上操作，concat是返回一个新的数组。

console.log(arr1.concat("aaaa",{name:"test"}));

删除一个元素

pop() 数组末尾删除一个元素一次只能删除一个

返回被删除的元素会改变原数组

pop没有参数

 res = arr.pop()    //"13"

shift() 数组的头部删除一个元素一次只能删除一个

返回被删除的元素会改变原数组

shift没有参数

res = arr.shift()   //"hello"

delete 删除数组的元素

位置会被保留, 为空，一般不用delete删除数组元素。

    var arr2 = ["a", , "b", "c"];
    delete arr2[0]
    console.log("-------------");
    console.log(arr2[0], arr2)   //undefined   [empty × 2, 'b', 'c']

删除多个元素splice

重点splice() 数组删除splice(第几个开始，要删除个数)

还可以在删除的位置添加新的数组元素

返回被删除项目的新数组

注意，这个会影响原数组

var arr = ['pink', 'blue', 'black', 1, 'hh'];

1.只删除不添加
console.log(arr.splice(2, 2)); //['black', 1]
console.log(arr);//['pink', 'blue', 'hh']

2.删除且添加
console.log(arr.splice(2, 2,'red',666)); //['black', 1]
console.log(arr);//['pink', 'blue','red',666, 'hh']

3.不删除只添加
console.log(arr.splice(2, 0,'red',666)); //['black', 1]
console.log(arr);//['pink', 'blue','red',666,'black', 1, 'hh']

截取slice

slice() 数组截取slice(begin,end)

包括begin，不包括end 即 begin<=item<end

如果end省略，则是截取到结尾

返回被截取项目的数组参数为索引号可以为负值

不影响原数组

var arr = ['pink', 'blue', 'black', 1, 'hh'];
console.log(arr.slice(1, 5));  //从1开始 截取到5之前 ['blue', 'black', 1, 'hh']
console.log(arr.slice(1, -1)); // ['blue', 'black', 1]  倒数第一个为-1，依次类推
console.log(arr);  //['pink', 'blue', 'black', 1, 'hh'];

获取元素索引

arr.indexOf( ) 从前面开始查找

arr.lastIndexOf( ) 从数组元素的后面开始查找

一般用来检测数组中是否存在该数据

如果找到数据，返回的是索引下标号无法找到该元素，返回-1

只返回第一个满足条件的索引号

判断是否有该元素

in 运算符可以判断数组里面是否有该元素更常用indexOf()

   var arr1 = ["a", "b", "c", 3, { a: 1 }, [1, 2, 3]]
    console.log(3 in arr1); //true
    console.log(31 in arr1);//false

过滤 filter

es6 filter(function(item){return true}) 用户过滤数组成员

满足条件的成员组成一个新的数组返回。

    var arr2 = [1,3,2,4,7,8,10];
    var newArr=arr2.filter(function(item){ // 返回一个新的数组
      return item % 2 === 0; // 如果除2的余数为0，则是偶数，返回true，则会把该元素添加新数组里面。
    })
    console.log(newArr2); //[2, 4, 8, 10]

累计reduce

es6 reduce(function (a, b) { }); 依次处理数组的成员，最终累计为一个值。

reduceRight(),和reduce一样的作业，reduce是从左边开始累计，reduceRight是从右边开始累计。

第一次遍历： a是数组第一个元素，b是数组第2个元素。

第二次遍历: a则是上一轮的返回值，b则是第3个元素。......

    var arr2 = [1, 3, 2, 5];
    var res = arr2.reduce(function (a, b) {
      return a + b;
    })
    console.log(res); //11

判断some/every

some(function( elem, index , arr) {return 条件 })

只要有一个成员返回true, 整个some返回值都是true, 否则返回false

    var arr2 = [1, 3, 2, 5, 0];
    var flag = arr2.some(function (ele) {
      return ele > 2;
    })
    console.log(flag);  //true

every(function (elem, index, arr) { })

所有成员返回true, 整个ervery返回值都是true, 否则返回false

    var arr2 = [1, 3, 2, 5, 0];
    var flag = arr2.every(function (ele) {
      return ele > 2;
    })
    console.log(flag);  //fasle

数组去重

核心算法：遍历旧数组，然后拿着旧数组的元素去查询新数组，如果该元素在新数组里面没有出现过就添加，否则不添加

利用新数组.indexOf(数组元素) 如果返回值是-1就说明新数组里面没有该元素

 var arr = [1,2,3,4,4,1,11,22,11,33,1];
 var newArr = []
 for (var i=0;i< arr.length;i++) {
        if (newArr.indexOf(arr[i]) === -1){
            newArr.push(arr[i])
        }        
 }
 console.log(newArr);

排序sort

冒泡排序

// 每次比一遍所有的数冒出一个最大或者最小的数字

// 每次比较两个数字交换位置

数组总长度为5

//第0轮 i=0, j<4=5-1-i

//0位置 1位置比较 0》1 交换两个位置的值

//1位置 2位置比较 0》1 交换两个位置的值

//2位置 3位置比较 0》1 交换两个位置的值

//3位置 4位置比较 0》1 交换两个位置的值

//第1轮 i=1, j<3=5-1-i

//0位置 1位置比较 0》1 交换两个位置的值

//1位置 2位置比较 0》1 交换两个位置的值

//2位置 3位置比较 0》1 交换两个位置的值

   var arr = [11,22,12,3,111,21,21,3]
    //第一层循环 来控制冒泡需要的轮数
    for (var i=0;i<arr.length-1;i++) {
        //第二层循环 控制每一轮比较的次数
        for(var j=0;j<arr.length-i-1 ;j++){
            //内部交换2个变量的值 前一个和后一个数组元素相比较
            if (arr[j] > arr[j+1]){    //从小到大
                //交换两个数组元素的值
                var tmp = arr[j]
                arr[j] = arr[j+1]
                arr[j+1] = tmp
            }
        }
    }
    console.log(arr)

内置方法 sort()

默认是按字典(a,b,c......)排序。可以接受一个函数作为参数，

a,b两个参数是数组的相邻两个元素，如果返回值大于0，表示第一个成员排在第二个成员后面，

其他则是第一个元素在第二个元素前面。会改变原数组，返回的也是排序后的数组。

a-b 是由小到大，b-a是由大到小。

        var arr1 = [5, 34, 9, 12, 1];
        arr1.sort(); //只对个位数起作用   
        console.log(arr1);    // [1, 12, 34, 5, 9]
        
        //改良方法
        arr1.sort(function (a, b) {
            return a - b;//升序    [1, 5, 9, 12, 34]
            //return b - a;//降序    [34, 12, 9, 5, 1]
        })
        console.log(arr1);

数组反转

原生js

1 声明一个新数组 arrNew

2 把旧数组第五个元素过来(arr.length-1) 放在新数组第一个位置 (arr.[0]) arr.length

3 依次递减处理

    var oldArr = [1, 2, 3, 4, 5]    //得到数组为 [5,4,3,2,1] 
    var newArr = [];
    for (var i = oldArr.length - 1; i >= 0; i--) {
        newArr.push(oldArr[i]);
        //newArr[newArr.length] = oldArr[i]
    }
    console.log(newArr)