JS經常使用數組、字符串操做

本文將記錄一些Javascript經常使用的數組、字符串的操做，方便項目開發以及JS算法的編寫。

 

數組（Array）

1.push():

向數組尾部添加一個或多個元素，並返回添加新元素後的數組長度。注意，該方法會改變原數組。

var arr = [1,2,3];
console.log(arr);        //  [1, 2, 3]
var b = arr.push(4);  
console.log(b);          //  4   //表示當前數組長度
console.log(arr);        // [1, 2, 3, 4]

2.pop():

刪除數組的最後一個元素，並返回該元素。注意，該方法會改變原數組。

var arr = [1,2,3];
console.log(arr);                // [1,2,3]
arr.pop();
console.log( arr.pop() );　　// [3]　　//返回刪除的元素
console.log(arr);                // [1,2]

3.unshift():

在數組的第一個位置添加元素，並返回添加新元素後的數組長度。注意，該方法會改變原數組。

var arr = ['a', 'b', 'c'];
arr.unshift('x');        // 4
console.log(arr);        // ['x', 'a', 'b', 'c']

4.shift():

刪除數組的第一個元素，並返回該元素。注意，該方法會改變原數組。

var arr = ['a', 'b', 'c'];
arr.shift()         // 'a'
console.log(arr)     // ['b', 'c']  

注意shift()方法還能夠遍歷並清空一個數組。

var list = [1, 2, 3, 4, 5, 6];
var item;

while (item = list.shift()) {
  console.log(item);
}

console.log(list);     // []

5.indexOf():

返回指定元素在數組中出現的位置，若是沒有出現則返回-1。

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

arr.indexOf('b') // 1
arr.indexOf('y') // -1

indexOf方法還能夠接受第二個參數，表示搜索的開始位置。

['a', 'b', 'c'].indexOf('a', 1)     // -1

上面代碼從1號位置開始搜索字符a，結果爲-1，表示沒有搜索到。　　

6.join():

以參數做爲分隔符，將全部數組成員組成一個字符串返回。若是不提供參數，默認用逗號分隔。

var arr = [1, 2, 3, 4];

arr.join(' ')     // '1 2 3 4'
arr.join(' | ')     // "1 | 2 | 3 | 4"
arr.join()     // "1,2,3,4"

7.concat():

用於多個數組的合併。它將新數組的成員，添加到原數組的尾部，而後返回一個新數組，原數組不變。

var arr = [1,2,3];
var b = arr.concat([4,5,6]);
console.log(b);        //[1,2,3,4,5,6]

8.reverse():

用於顛倒數組中元素的順序，返回改變後的數組。注意，該方法將改變原數組。

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

arr.reverse() // ["c", "b", "a"]
console.log(arr) // ["c", "b", "a"]

9.slice():
用於截取原數組的一部分，返回一個新數組，原數組不變。

slice(start,end)它的第一個參數爲起始位置（從0開始），第二個參數爲終止位置（但該位置的元素自己不包括在內）。若是省略第二個參數，則一直返回到原數組的最後一個成員。

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

arr.slice(0)         // ["a", "b", "c"]
arr.slice(1)         // ["b", "c"]
arr.slice(1, 2)     // ["b"]
arr.slice(2, 6)     // ["c"]
arr.slice()           // ["a", "b", "c"]    無參數返回原數組

arr.slice(-2)          // ["b", "c"]    參數是負數，則表示倒數計算的位置
arr.slice(-2, -1)     // ["b"]

10.splice():

刪除原數組的一部分紅員，並能夠在被刪除的位置添加入新的數組成員，返回值是被刪除的元素。注意，該方法會改變原數組。

splice(start,delNum,addElement1,addElement2,...)第一個參數是刪除的起始位置，第二個參數是被刪除的元素個數。若是後面還有更多的參數，則表示這些就是要被插入數組的新元素。

var arr = ['a', 'b', 'c', 'd', 'e', 'f'];
arr.splice(4, 2)     // ["e", "f"]　　從原數組4號位置，刪除了兩個數組成員
console.log(arr)     // ["a", "b", "c", "d"]

var arr = ['a', 'b', 'c', 'd', 'e', 'f'];
arr.splice(4, 2, 1, 2)     // ["e", "f"]　　原數組4號位置，刪除了兩個數組成員,又插入了兩個新成員
console.log(arr)         // ["a", "b", "c", "d", 1, 2]

var arr = ['a', 'b', 'c', 'd', 'e', 'f'];
arr.splice(-4, 2)     // ["c", "d"]    起始位置若是是負數，就表示從倒數位置開始刪除

var arr = [1, 1, 1];
arr.splice(1, 0, 2)     // []    若是隻插入元素,第二個參數能夠設爲0
conlose.log(arr)     // [1, 2, 1, 1]

var arr = [1, 2, 3, 4];
arr.splice(2)     // [3, 4] 若是隻有第一個參數，等同於將原數組在指定位置拆分紅兩個數組
console.log(arr)     // [1, 2]

11.sort():

對數組成員進行排序，默認是按照字典順序排序。排序後，原數組將被改變。

['d', 'c', 'b', 'a'].sort()
// ['a', 'b', 'c', 'd']

[4, 3, 2, 1].sort()
// [1, 2, 3, 4]

[11, 101].sort()
// [101, 11]

[10111, 1101, 111].sort()
// [10111, 1101, 111]

上面代碼的最後兩個例子，須要特殊注意。sort方法不是按照大小排序，而是按照對應字符串的字典順序排序。也就是說，數值會被先轉成字符串，再按照字典順序進行比較，因此101排在11的前面。

若是想讓sort方法按照自定義方式排序，能夠傳入一個函數做爲參數，表示按照自定義方法進行排序。該函數自己又接受兩個參數，表示進行比較的兩個元素。若是返回值大於0，表示第一個元素排在第二個元素後面；其餘狀況下，都是第一個元素排在第二個元素前面。

var arr = [10111, 1101, 111];
arr.sort(function (a, b) {
  return a - b;
})
// [111, 1101, 10111]

var arr1 = [
              { name: "張三", age: 30 },
              { name: "李四", age: 24 },
              { name: "王五", age: 28 }
           ]

arr1.sort(function (o1, o2) {
  return o1.age - o2.age;
}) 
// [
//   { name: "李四", age: 24 },
//   { name: "王五", age: 28 },
//   { name: "張三", age: 30 }
// ]

12.map():

對數組的全部成員依次調用一個函數，根據函數結果返回一個新數組。

var numbers = [1, 2, 3];

numbers.map(function (n) {
  return n + 1;
});
// [2, 3, 4]

numbers
// [1, 2, 3]

上面代碼中，numbers數組的全部成員都加上1，組成一個新數組返回，原數組沒有變化。

11.filter():

參數是一個函數，全部數組成員依次執行該函數，返回結果爲true的成員組成一個新數組返回。該方法不會改變原數組。

var arr = [1, 2, 3, 4, 5]
arr.filter(function (elem) {
  return (elem > 3);
})
// [4, 5]