JS数组（总结）

1数组的概念

所谓数组，就是将多个元素（通常是同一类型）按一定顺序排列放到一个集合中，那么这个集合我们就称之为数组.

2.数组的定义

数组是一个有序的列表，可以在数组中存放任意的数据，并且数组的长度可以动态的调整。
例子：
// 创建一个空数组
var arr1 = [];
// 创建一个包含3个数值的数组，多个数组项以逗号隔开
var arr2 = [1, 3, 4];
// 创建一个包含2个字符串的数组
var arr3 = [‘a’, ‘c’];

// 可以通过数组的length属性获取数组的长度
console.log(arr3.length);
// 可以设置length属性改变数组中元素的个数
arr3.length = 0;

3.通过数组字面量创建数组

**

3.遍历方法的总结

遍历：遍及所有，对数组的每一个元素都访问一次就叫遍历。

数组遍历的基本语法：
for(var i = 0; i < arr.length; i++) {
// 数组遍历的固定结构
}
问题：遍历数组arr，将各个元素全部转成大写

var arr = [‘a’,’b’,’c’,’d’];

1 var arr = ['a','b','c','d'];

方法1：for循环 这个方法比较常用

“use strict”;
var arr = [‘a’,’b’,’c’,’d’];
var arrUp = [];
for(var i = 0; i < arr.length; i++){
arrUp.push(arr[i].toUpperCase());
}
console.log(arrUp); //[‘A’,’B’,’C’,’D’]

1 "use strict";
2 var arr = ['a','b','c','d'];
3 var arrUp = [];
4 for(var i = 0; i < arr.length; i++){
5    arrUp.push(arr[i].toUpperCase());
6 }
7 console.log(arrUp);             //['A','B','C','D']

方法2：for in 循环 该方法通常用于遍历对象（数组一种特殊的对象）

“use strict”;
var arr = [‘a’,’b’,’c’,’d’];
var arrUp = [];
for(var i in arr){
arrUp.push(arr[i].toUpperCase());
}
console.log(arrUp); //[‘A’,’B’,’C’,’D’]

1 "use strict";
2 var arr = ['a','b','c','d'];
3 var arrUp = [];
4 for(var i in arr){
5     arrUp.push(arr[i].toUpperCase());
6 }
7 console.log(arrUp);             //['A','B','C','D']

方法3：forEach方法 数组的迭代方法（下文解释）
返回值：无返回值

“use strict”;
var arr = [‘a’,’b’,’c’,’d’];
var arrUp = [];
arr.forEach(function(key, index, array){
arrUp.push(key.toUpperCase());
});
console.log(arrUp); //[‘A’,’B’,’C’,’D’]

1 "use strict";
2 var arr = ['a','b','c','d'];
3 var arrUp = [];
4 arr.forEach(function(key, index, array){
5     arrUp.push(key.toUpperCase());
6 });
7 console.log(arrUp);             //['A','B','C','D']

方法4：map方法 数组的迭代方法（下文解释）
返回值：返回每次函数调用结果组成的数组

“use strict”;
var arr = [‘a’,’b’,’c’,’d’];
var arrUp = arr.map(function(key, index, array){
return key.toUpperCase();
});
console.log(arrUp); //[‘A’,’B’,’C’,’D’]

1 "use strict";
2 var arr = ['a','b','c','d'];
3 var arrUp = arr.map(function(key, index, array){
4     return key.toUpperCase();
5 });
6 console.log(arrUp);             //['A','B','C','D']

对于上面的简单问题，可能这个四种方法相对于比较好，但是问题一复杂呢

var arr = [1, 4, 10, 5, 8];

1 var arr = [1, 4, 10, 5, 8];

问题：对于这个数组，请计算大于6的数组元素个数
只是举一个简单的例子，上面的四种方法也行，只不过可能判断比较麻烦，这里介绍遍历数组的方法，相信在不同的情景中，它们可能更优。
数组迭代方法

下面的方法，仅仅返回值不同，其余完全一样：接收2个参数，一个函数（必选）和运行该函数的作用域对象（可选，一般不用，目前我不知道有什么妙用，所以不做过多解释）

//要接受的函数，本文叫判断函数
function(key, index, array){
//key： 数组项值
//index： 该项的数组下标
//arr：待操作的数组
}

1 //要接受的函数，本文叫判断函数
2 function(key, index, array){
3     //key： 数组项值
4     //index： 该项的数组下标
5     //arr：待操作的数组
6 }

方法5：every方法
返回值：如果判断函数对于每一项都返回true，则返回true
用处：根据条件检测数组每一项，只想得到布尔值

“use strict”;
var arr = [1, 4, 10, 5, 8];
var arrTest = arr.every(function(key, index, array){
return (key > 2);
});
console.log(arrTest); //false

1 "use strict";
2 var arr = [1, 4, 10, 5, 8];
3 var arrTest = arr.every(function(key, index, array){
4     return (key > 2);
5 });
6 console.log(arrTest);   //false

方法6：filter方法
返回值：返回一个数组，数组元素由判断函数会返回true的项组成
用处：条件筛选

“use strict”;
var arr = [1, 4, 10, 5, 8];
var arrTest = arr.filter(function(key, index, array){
return (key > 6);
});
console.log(arrTest); //[10, 8]

1 "use strict";
2 var arr = [1, 4, 10, 5, 8];
3 var arrTest = arr.filter(function(key, index, array){
4     return (key > 6);
5 });
6 console.log(arrTest);   //[10, 8]

方法7：some方法
返回值：如果判断函数对于任一项返回true，则返回true
用处：条件筛选

1 “use strict”; 
2 var arr = [1, 4, 10, 5, 8]; 
3 var arrTest = arr.some(function(key, index, array){ 
4 return (key > 6); 
5 }); 
6 console.log(arrTest); //true

4.数组的方法
数组的方法：
arr.concat(arr1);//把arr1拼接再arr后边
arr.indexOf(1);//判断某个值是否在数组中，

一堆的数组操作方法
四个必须记住的:
1.push():往最后一位追加
2.pop():删除最后一位
3.shift():删除第一位
4.unshift():在第一位追加
实例：
var arr = [“red”, “green”, “blue”];
var length1 = arr.push(“black”); //作用：在原来的数组上再追加一位。
console.log(arr);

        arr.pop(); //删除数组的最后一位，返回值是被删除的值
        console.log(arr);
        console.log(str1);

        var str2 = arr.shift() //删除第一个，返回删除的值
        console.log(arr);
        console.log(str2);

        var length2 = arr.unshift("第一位追加") //在第一位追加，返回值是数组的新长度
        console.log(arr);
        console.log(length2);
 arr.pop(); //删除数组的最后一位，返回值是被删除的值
        console.log(arr);
        console.log(str1);

        var str2 = arr.shift() //删除第一个，返回删除的值
        console.log(arr);
        console.log(str2);

        var length2 = arr.unshift("第一位追加") //在第一位追加，返回值是数组的新长度
        console.log(arr);`

        console.log(length2);

5.数组的方法——其它

数组的属性:.length
静态方法：Array.isArray(值)
数组的常用方法：
arr.concat(arr1);//把arr1拼接早arr后边，返回值是新数组–不会改变原数组
arr.indexOf(1);//判断某个值是否在数组中，如果有返回索引号，日过如果没有返回-1
arr.lastIndexOf(1)
arr.join(“.”);//用指定的拼接数组为字符串，返回值为拼接成的字符串–不会更改原数组
arr.sort()//从新排序-从小到大，只能正常排纯数字数组，其他类型的数据排序规则不确定[1,1,2]
arr.reverse()//数组反转
arr.slice(0,4)//start end 如果只给了开开始，代表截取从开始到全部
arr.splice(start，legth，值)//从开始位置 截掉多长的 第三个参数作为填充的值
//返回值是截掉的元素组成的新数组，追加的数据会改变原素组

数组的特殊方法：可以实现遍历数组
arr.every()//判断数组的元素是够否满足条件,找到一个不满足的就结束循环，返回false
arr.some()//和every()作用相反，找到一个真的就就结束吗，返回true 。否则返回false
//方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
arr.find(function(item){
return item>50
})
//方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。
var index = arr.findIndex(function(item.index){
return item>5
})
arr.filter()//挑出所有满足条件的元素，组成新数组

    例子：数组买鞋
       var data = [
            {price:10},
            {price:20},
            {price:200},
            {price:540},
            {price:30},
            {price:99},
        ]
        var newarr = data.filter(function(item,index,ar){
            return item.price>50;
        })
        console.log(newarr);
    例子：数组买鞋
       var data = [
            {price:10},
            {price:20},
            {price:200},
            {price:540},
            {price:30},
            {price:99},
        ]
        var newarr = data.filter(function(item,index,ar){
            return item.price>50;
        })
        console.log(newarr);

forEach() 方法。遍历数组，无返回值。
例子：

var arr = [1,2,3] 
var str=”“; 
var add = function(a,arr){ 
for(var i= 0;i