数组方法（学习笔记）

数组的一些方法：
转换：join()
排序: reverse()、sort()
连接：concat()
裁剪: slice()
插入、删除：splice()、push()、pop()、unshift()、shift()
对象方法：toString()、toLocaleString()

一、join 转换
Array.join()方法是将数组中所有元素都转化成字符串并且连接在一起，返回最后生成的字符串。

    //join 转换
            var arr  = [1,2,3,4]
            //console.log(arr.join())//"1,2,3,4" '1'+','+'2'+','+'3'+','+'4'
            //alert(arr.join().length)//7
            alert(arr.join('-'))//1-2-3-4           
            //console.log(arr.join(''))// "1234" '1'+'2'+'3'+'4'
            //alert(arr.join('').length)//4
            var a = new Array(10);
        alert(a.join('a'))//'aaaaaaaaa' 9个连字号组成的字符串

1.arr.join()分别以逗号隔开，逗号也算字符串的长度
2.arr.join(”)以空格隔开 不会占字符串长度
3.可以自定义分割分割符号
Array.join()方法是String.split()方法的逆向操作，后者是将字符串分割成若干块来创建一个数组
二.排序reverse() sort()
Array.reverse()方法是将数组的元素颠倒位置，并返回该数组的引用，也就是原来的数组元素顺序颠倒。

Array.sort()方法是将数组元素排序并返回排序后的数组

//排序reverse() sort()
            var arr = [1,2,3,4];
            var a = ['a','d','c','b']
            var b = ['2','4','3','6']
            var c = ['9','4','6','10']
            //alert(arr.reverse());
            //颠倒顺序 [4,3,2,1]        
            //alert(a.sort())
            //按字符编码排序 从小到大
            alert(c.sort()) //['10','4','6','9'] 字符串与字符串比较的是第一个字符的编码大小
           //指定某总顺序排列的函数
            var num = [5,2,1,3,4];
            num.sort(function(a,b){
                return b-a;
            })
            alert(num)
            //a,b是数组的随机两个数
        //如果是正数就把a放到后面，负数或者相等就不换位置          

三、concat 链接
Array.concat()方法创建并返回一个新数组

        //concat 链接
        var a = [1,2,3,4];

        alert(a.concat(5)) //[1,2,3,4,5]

四、裁剪: slice()
Array.slice()方法返回指定数组的一个片段或者子数组。

//裁剪 slice（）
            var arr = [1,2,3,4,5]

            //alert(arr.slice(0)) 
            //[1,2,3,4,5]
            //alert(arr.slice(0,3))
            //[1,2,3]
            //alert(arr.slice(0,-1))
            //[1,2,3,4]
            alert(arr.slice(-1,-1))//5
            alert(arr.slice(2,1))//找不到          

1.他的两个参数分别指定了开始位置和结束位置。
2.返回的数组包含第一个参数指定的位置和所有到第二个参数指定的位置的前面，不包括第二个参数指定的位置
3.如果只有以一个参数，返回的是指定的位置到结束的位置的所有元素
4.如果出现负数，他就相当于数组中的最后一个元素到过来数，比如-1就是倒数第一个元素
5.第一个参数比第二个参数大不会交换位置(字符串的substring方法可以交换位置)并且找不到

五、插入、删除：splice()、push()、pop()、unshift()、shift()

在数组的尾部插入元素、删除元素：
push()、pop()
在数组的头部插入元素、删除元素：
unshift()、shift()
这些方法都可以被splice()替代；

1.splice()删除 替换 添加
Array.splice()方法是在数组中插入或删除元素的通用方法。

//删除
            //alert(arr.splice(1))
            //返回[2,3,4,5] arr是[1]
            //alert(arr.splice(3,2))
            //返回[4,5] arr是[1,2,3]
            //alert(arr.splice(1,1))
            //返回2 arr是[1,3,4,5]

//替换
                //arr.splice(0,1,'x','q')
                //alert(arr)//[x,q,2,3,4,5]
//添加 插入
            alert(arr.splice(1,0,'a'));
            //返回[]   第一位添加'a' 删除0个 
            alert(arr)

1.1.第一个参数是指定了插入或删除的起始位置
1.2.第二个参数是指定了应该从数组中删除元素的个数
1.3.如果第二个参数省略，从起始点开始到结尾里面所有元素都被删除
1.4.splice()返回一个由删除元素组成的数组，如果没有删除就会返回一个空数组
1.5.splice()会改变数组本身

2.push()和pop()方法
push()方法在数组的尾部添加一个或者多个元素，并且返回数组新的长度

pop()方法删除数组的最后一个元素，减小数组长度并且返回他删除的值

            var arr = [];
            alert(arr.push(1,2,3));
            //返回3 新数组长度
            //alert(arr)//[1,2,3]
            //3 返回删除的值
            alert(arr)//[1,2]

3.unshift()和shift()方法
unshift()在头部添加一个或多个元素，并移动其他元素获取空间，最后返回新数组长度

shift()删除数组的第一个元素并返回删除的值，然后把其他元素前移。

//unshift()和shift()
            //var arr = [1,2,3];

            //alert(arr.unshift(0))
            //返回新数组长度4 
            //alert(arr)//[0,1,2,3]
            //alert(arr.shift(0))
            //返回删除的值
            //alert(arr)//[1,2,3]

toString()和toLocaleString()
toStrimg()将数组所有元素转化为字符串并且输出用逗号分隔的字符串列表，和不使用任何参数调用join()方法返回的字符串一致.
注意，输出不包括方括号或其他任何形式包裹数组数值的分隔符。

            //var arr = [1, 2, 3, 4];
            //var a = [[1, 2], 3, 4];
            //alert(arr.toString())
            //1,2,3,4
            //alert(typeof arr.toString())
            //string
            //alert(a.toString())//1,2,3,4

toLocaleString()是数组对象的本地字符串表示，返回结果随机器不同而不同，最好不要在脚本中用来基本运算。

var number = 337;
var date = new Date();
var myArr = [number, date, "foo"];
var str = myArr.toLocaleString(); 
console.log(str); 
// 输出 "337,2015/2/27 下午8:29:04,foo" 
// 假定运行在中文（zh-CN）环境，北京时区

ES5数组方法：
indexOf()lastIndexOf()方法
用于查找数组内指定元素位置，查找到第一个后返回其索引，没有查找到返回-1，indexOf从头至尾搜索，lastIndexOf反向搜索。

var a = [0, 1, 2, 1, 0]
                a.indexOf(1);
                // => 1:a[1]是1
                a.lastIndexOf(1); 
                //=>3:a[3]是1

forEach方法遍历数组，为每个元素调用指定的函数。传递的函数为forEach的第一个参数，该函数有三个参数，依次为：数组元素、数组索引和数组本身。

var keys = [1,2,3];
keys.forEach(function(value, index, array){
        console.log(value);//1,2,3

})

使用forEach遍历数组十分简洁但是存在一些缺陷，在forEach方法中不能使用break中断遍历，也不能使用return返回值到外层函数。

map()
map()方法将调用数组的每个元素传递给指定的函数，并返回一个数组，它包含该函数的返回值。
map()方法返回的是新数组，它不修改调用的数组；如果是稀疏数组，返回的也是相同方式的稀疏数组。它具有相同的长度，相同的缺失元素。

            var arr = [1,2,3,4];
            b = arr.map(function(x){
                return x*x;
            })
            alert(b)//返回[1,4,9,16]

filter()
filter()方法创建并返回调用数组的一个子集。传递的函数用来进行逻辑判定的，该函数返回true或false。
返回true的元素将被添加成为这个子集的成员。

a=[1,2,3,4,5];
b=a.filter(function(x){
    return x>3
})                 //b是[4,5]
c=a.filter(function(x,i){
    return i%2==0；
})                 //c是[1,3,5]

every()和some()方法
所有：every()每个数组元素回调函数都返回true的时候才会返回true，当遇到false的时候终止执行，返回false；

a=[1,2,3,4];
a.every(function(x){
    return x < 10;      //返回true
});
a.every(function(x){
    return x % 2 == 0;  //返回false,并非所有元素都能被2整除   
})

存在：some()
存在有一个数组元素的回调函数返回true的时候终止执行并返回true，否则返回false。

a=[1,2,3,4];
a.some(function(x){
    return x % 2 == 0;  //返回true 
});
a.some(isNaN);    //false

reduce()和reduceRight()方法
遍历数组，调用回调函数，将数组元素组合成一个值
参数1：回调函数：把两个值合为一个
参数2：value，一个初始值，可选
reduce从索引最小值开始
reduceRight反向，方法有两个参数

var a=new Array(1,2,3,4,5,6);
console.log(a.reduce(function(v1,v2){
   return v1+v2;
}));              // 21
console.log(a.reduceRight(function(v1,v2){
   return v1-v2;
},100));          // 79

ES6新增一些方法：
Array.from()方法从一个类似数组或可迭代对象中创建一个新的数组实例。

const bar = ["a", "b", "c"];
Array.from(bar);
// ["a", "b", "c"]

Array.from('foo');
// ["f", "o", "o"]

Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。
参考资料
《ECMAScript 6 入门》数组的扩展