数组中常用方法的总结

数组中常用方法

1. push()
2. pop()
3. shift()
4. unshift()
5. splice()
6. slice()
7. join()
8. concat()
9. sort()
10. reverse()

其中不会修改原数组并返回一个新的数组或者字符串的有

1. slice()
2. join()
3. concat()

给数组的尾部添加或者删除元素

1. push(element1, ..., elementN) 给数组尾部添加一个或者多个元素，返回数组新的长度（length属性值）

arr.push(element1, ..., elementN)

参数:elementN   被添加数组尾部的元素。
返回值:  当调用该方法时，新的 length 属性值将被返回。

2. pop()方法删除数组最后一个元素，并返回被删除的元素。

arr.pop()

代码演示

var a=[1,2,3,4,5]
var b=a.push(6,7)
console.log(b)  //7
console.log(a)  //[1, 2, 3, 4, 5, 6, 7]
var c=['a','b','c','d']
var d=c.pop();
console.log(d)   //'d'
console.log(c)   //["a", "b", "c"]

给数组开头添加和删除元素

1. unshift()方法给数组的开头添加一个或者多个元素，返回数组新的length值。

arr.unshift(element1, ..., elementN)

参数:elementN    被添加到数组的开头。
返回值:   当调用该方法的时，返回其length属性值。

2. shift()方法删除数组的第一个元素，并返回这个元素。该方法是改变当前数组，所以会改变数组的长度

arr.shift()

描述:
shift() 方法移除索引为 0 的元素(即第一个元素)，并返回被移除的元素，其他元素的索引值随之减 1。如果 length属性的值为 0 (长度为 0)，则返回 undefined 。

代码演示

var a=[1,2,3,4]
var c=[1,2,3,4]
var b= a.unshift(5,6)  //b=6
var d=c.shift()  // d=1
a  // [5, 6, 1, 2, 3, 4]
c  // [2, 3, 4]

获取数组的片段的2个方法

splice()和slice()都可以获取数组的片段，但是2个方法有很大的区别

splice()和slice()的区别

1. splice()会改变原数组。而slice()不会改变原数组，返回一个新的数组。
2. splice()方法用新元素替换旧元素，以此来修改数组内容。而slice()方法会浅复制数组的一部分到一个新的数组，并返回这个新数组。

splice()方法

arr.splice(start,deleteCount,item1 .....itemN)

返回值: 由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。

1. start:从数组的哪一个索引来开始修改内容，如果超过数组长度，则从数组末尾开始添加内容，如果是负值，则从数组的末尾开始的第几位。
2. deleteCount:整数，表示删除的个数。如果deleteCount是0，则不删除元素。这种情况下，一般都是添加新元素，不然就没有实际意义。（** 从start开始，包括start **）
3. item1 .....itemN要添加的元素，如果不指定，splice()则只删除元素。(会在start前面添加元素)

splice()代码事例

    var a=['a','b','c','d'];
    var b= a.splice(0,2,1,2);  //b=[a,b]  a=[1,2,c,d]
    //给a开头添加一个元素
    var c =a.splice(0,0,'start','add'); //c=[]  a=["start", "add", 1, 2, "c", "d"]

用splice()方法变相的模拟push(),pop(),shift(),unshift()

    //splice()方法模仿push()*/
    function push(arr,val){
        arr.splice(arr.length,0,val);
        return arr.length
    }
    //splice()方法模仿pop()
    function pop(arr){
        return arr.splice(arr.length-1,1)[0]
    }
    //splice()方法模仿unshift()
    function unshift(arr,val){
        arr.splice(0,0,val);
        return arr.length;
    }
    //splice()方法模拟shift()
    function shift(){
        return arr.splice(0,1)[0]
    }

slice()方法

slice()方法提取元素，返回一个又提取元素组成的新数组

arr.slice(start,end);

参数
start : 从该索引开始提取元素（索引是从0开始）。如果start是负数，则从最后倒数几个来提取元素。如果省略begin，则slice()从0开始。
end : slice()方法截取元素的停止位置。如果为负数，则从倒数第几个元素结束。
返回值 : 一个含有提取元素的新数组。
新数组的长度等于（end- start) ，截取从start开始，end结束，但是不包括end

slice(-2,-1)表示从原数组的倒数第二个元素开始截取，到最后一个前停止
（不包含最后一个元素，也就是说只有倒数第二个元素）

slice()代码事例

    var hh=[1,2,3,4]
    var cc=hh.slice(0, 2)  //cc=[1, 2] 
    console.log(hh);  //hh=[1,2,3,4]

join()方法

join()把数组中所有元素连接成字符串。不会改变原数组的内容，返回的新的字符串。

arr.join(separator)

separator: 可选，用于指定连接每个数组元素的分隔符。分隔符会被转成字符串类型；如果省略的话，默认为一个逗号。如果 seprator 是一个空字符串，那么数组中的所有元素将被直接连接。

join()代码事例

    var a=[1,2,3,4];
    var b=a.join(); //b='1,2,3,4'
    var c=a.join("") //c='1234'
    var d=a.join("+") //d = "1+2+3+4"

concat()方法

concat()方法连接2个数组，返回一个新的数组，不改变原来的数组

    var aa=[1,2,3,4];
    var bb=['a','b','c','d'];
    var cc=aa.concat(bb)  //cc  = [1, 2, 3, 4, "a", "b", "c", "d"]
    var dd=aa.concat(5,6,7) //dd =[1, 2, 3, 4, 5, 6, 7]

reverse()方法

reverse()方法反序数组的内容，第一个元素会成为最后一个，最后一个会成为第一个。（是改变的原数组）
返回值 : 返回改变后的数组

arr=[1, 2, 3]
arr.reverse()  //[3, 2, 1]
//arr= [3, 2, 1]

sort()方法

sort()方法对数组的做原地的排序，并返回这个数组。（是改变的原数组）
返回值 : 返回改变后的数组

arr.sort(compareFunction)

compareFunction : 可选，按照某种顺序进行排列的函数。如果省略，元素按照Unicode进行排序

sort()方法代码事例

1. 无参数

var a=[1,10,2,21] 
a.sort()  //  [1, 10, 2, 21]
// a=[1, 10, 2, 21] 
所以sort有时候会不准

2. 添加函数进行比较

指明了 compareFunction ，那么数组会按照调用该函数的返回值排序。记 a 和 b 是两个将要被比较的元素：

• 如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；
• 如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。
• 如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。

数字的排序比较
function(a,b){
      return a-b;
}
eg：
var a=[3,5,7,45,36,1,18]
a.sort(function(a,b){
      return a-b;
})  //[1, 3, 5, 7, 18, 36, 45]
// a=[1, 3, 5, 7, 18, 36, 45]

对象属性的比较
function(a,b){
    if(a.value>b.value)  return  1;
    else if (a.value<b.value) return -1;
    else return 0
}
    var items = [
      { name: 'Edward', value: 21 },
      { name: 'Sharpe', value: 37 },
      { name: 'And', value: 45 },
      { name: 'Ahe', value: -12 },
      { name: 'Magnetic' },
      { name: 'Zeros', value: 37 }
    ];
items.sort(function(a,b){
     if(a.value>b.value)  return  1;
    else if (a.value<b.value) return -1;
    else return 0
})
此时items会按照value的大小排列
我们获取items[i].value  看看
    var arr=[]
    for(var i=0 ;i<items.length ;i++){
        arr[i]= items[i].value;
    }
      // arr=[-12, 10, 21, 37, 37, 45]