Array数组

数组的定义

var arr = [10];//字面量，定义了一个只有一个元素10的数组
var arr = new Array(10);//构造方法，当（）内只有一个参数时，定义了长度为10的空数组。

数组的方法都来自于Array.prototype,字符串的方法都来自于String.prototype。

数组的方法

改变原数组

pop、push、ushift、unshift

关于splice和sort

//splice方法
var arr = [1,2,3,4,5];
var t = [];
/*
    * splice(x,y,z1,z2,z3...)
    * x:第[x]位开始删除，如果为负数表示倒数第几位
    * y:删除多少个
    * z:在切口处添加数据（不限个数）
    * 返回值是被删除数据组成的数组
*/
t = arr.splice(2,1,"a","b","c");//t=[3],arr=[1,2,"a","b","c",4,5]

splice(index,num,addItem1,addItem2...)

//sort方法
var arr = [1,3,5,4,10];
/*
    *sort(function(a,b){..写逻辑..})
    * 1、必须写两个形参
    * 2、看返回值 ->返回值为负数，那么a排在前面
    *           ->返回为正数，a排在后面后面
    *           ->为0，不动
    * 3、传参方式符合冒泡排序即：01,02,03,04,12,13,14,23,24,34(数字为索引)
*/
arr.sort(function(a,b){
    if(a>b){
        return 1;
    }else{
        return -1;
    }
})//升序排序

不改变原数组

字符串有一个方法：str.split("-")把字符串按照 “-” 拆分，返回数组。这与join相对应。

有回调函数的方法，回调函数的参数都是（value，index，arr）

这个特殊：reduce第一个参数是回调函数（preValue，value，index，arr），第二个是preValue.

some：有一项成立就返回true

//some方法用于检测数组中是否含有符合条件的的元素。返回值是boolean，找到第一个符合条件的元素即停止遍历
const arr = [1,2,3,4,5,6]
let flag = arr.some((value)=>{
    return value%5==0;
})
console.log(flag);//true
//检测数组中是否有5的倍数

every：全部成立才返回true

//every方法判断a里面的元素是否都符合函数的条件。
const arr = [5,10,15,20]
let flag = arr.every((value)=>{
    return value%5==0;
})
//判断数组中的元素是否都是5的倍数

参数都是(function(value,index,arr,){},thisArg)，thisArg很少用。

filter：筛选数组元素

//filter创建一个新数组，新数组的元素是符合条件的传入数组元素。
var a=[1,2,3,4,5]
var b=a.filter(function(value,index,arr){
    return a>2;//筛选>2的数组元素，如果符合条件则把此元素放到新数组。
});
console.log(b);
//打印[3,4,5]

foreach：单纯的遍历数组，无返回值
如何跳出forEach循环？使用try...catch配合throw new Error('...')。

//foreach
var a=[1,2,3,4,5];
a.forEach(
    function(value,index,arr){
        console.log("每一个数组元素"+value);
        console.log("每一个数组元素索引"+index);
        console.log("数组本身"+arr);
    });
//回调函数可以只要部分形参

map：处理每个元素
如果没有return的话，默认return undefined。

//map 把a数组里面的每一个元素遍历传入函数并处理，返回每个元素被处理后的数组。
var a=[1,4,6,8,9];
var b=a.map(function(z){
    return z*2;
})
console.log(b);
//打印[2, 8, 12, 16, 18]

reduce：

//reduce累计数组里元素。
var  arr = [1, 2, 3, 4];
var add = arr.reduce(function(accumulator,value,index,arr){
  //第一次遍历把第二个参数（0）作为accumulator，把数组[0]作为value传入函数，
  //函数里面的return值作为第二次遍历的accumulator，直到遍历完成。
  console.log(value);
  return accumulator + n;
},0);
console.log(add); //求和

var a = eval(arr.join('+'));//数组汇总最快捷的方法

keys

//keys返回一个迭代器，包含数组每个元素的索引值。
var a=[1,4,6,8,9];
var b=a.keys();
for (var i of b) {
    console.log(a[i]);
}
//打印1，4，6，8，9

类数组

类数组就是一个对象，arguments就是一个类数组，但是实质上他是一个对象

类数组：

• 利用属性名模拟数组特性
• 动态增长length属性
• 给类数组定义push方法，可以根据length进行属性扩充
• 添加splice方法。

    var obj = {
        "0":"a",
        "1":"b",
        "2":"c",
        "length":3,
        "push":Array.prototype.push,
        "splice":Array.prototype.splice
    }
    obj.push("d");

    /*类数组中：属性要为索引（数字）属性
              必须有length属性
              最好加上push，方便为类数组添加属性。

    push方法中会根据length新增新的索引和值。
    Array.prototype.push = function(target){
        obj[obj.length] = target;
        obj.length++
    }
    */

类数组既有对象的特性又有数组的特性，所以在开发中很常用。

数组去重

利用类数组进行数组去重。

var arr = [1,2,3,0,1,1,2,2,9,9,10];
Array.prototype.unique = function(){
    var temp = {},
        a = [],
        len = this.length;
    for (var i=0;i<len;i++){
        if (temp[arr[i]]==null){
          temp[arr[i]] = '占坑';
          //数组元素作为属性名，"占坑"作为属性值，下一次循环到这个数，因为这个属性已经存在所以不遍历
          a.push(arr[i]);
        }
    }
    return a;   
}
var a = arr.unique();