一. JavaScript數組經常使用方法

1.基礎方法：
push：向數組的末尾增長一項 返回值是數組的新長度
unshift：向數組開頭增長一項 返回值是數組的新長度
pop:刪除數組的末尾項 返回值是刪除的數組項
shift:刪除數組開頭項 返回被刪除的開頭項目
splice：增刪改，功能強大
slice:複製數組 返回值是複製到的新數組 寫上數值以後 不包含被複制的最後一項

2.拼接：
concat:把一個數組和另外一個數組拼接在一塊兒 返回拼接好的數組 
join:把數組中的每一項 按照指定的分隔符拼接成字符串

3.排序：
reverse:倒序數組 返回值倒序數組 原有數組改變
sort:根據匿名函數進行冒泡排序 b-a倒序 a-b升序

4.兼容性很差：
indexOf:返回獲取項在數組中的索引
lastIndexOf:返回獲取項在數組中出現的最後一次索引
forEach: 循環遍歷數組 參數是一個匿名函數 默認返回爲undefined
map：循環遍歷數組 參數是一個匿名函數
filter：建立一個新的匹配過濾條件的數組
reduce：數組中的每一個值（從左到右）開始合併，最終爲一個值。

1.基礎方法：

push：向數組的末尾增長一項 返回值是數組的新長度
unshift：向數組開頭增長一項 返回值是數組的新長度

var array = ["a","b","c","d","e","f"];
var last = array.unshift("begin");
console.log(array)     // ["begin", "a", "b", "c", "d", "e", "f"]

 

pop:刪除數組的末尾項 返回值是刪除的數組項

var array = ["a","b","c","d","e","f"];
var last = array.pop();
console.log(array)    //["a", "b", "c", "d", "e"]

 

shift:刪除數組開頭項 返回被刪除的開頭項目

var array = ["a","b","c","d","e","f"];
var last = array.shift();
console.log(array)      // ["b", "c", "d", "e", "f"]

 

splice：增刪改，功能強大

（1）刪除：只須要提供兩個參數，要刪除的第一項的位置和要刪除的個數,並返回刪除的元素數組：
var num = [1,2,3,4,5];
var newNum = num.splice(1,2);
console.log(num);    //[1,4,5]
console.log(newNum); //[2,3]

（2）插入：提供多個參數，第一個參數是要插入的位置，第二個是0表示刪除0個，後面是要插入的元素，能夠是多個，由於刪除0個，因此返回空數組；
* 四個參數，第二個爲0表明插入
var num = [1,2,3,4,5];
var newNum = num.splice(1,0,"Tom","Jerry");
console.log(num);    //[1, "Tom", "Jerry", 2, 3, 4, 5]
console.log(newNum); //[]

（3）替換：提供多個參數，第一個參數是要插入的位置，第二個是刪除的個數，後面是要插入的元素，能夠是多個，返回刪除的數組；
* 四個參數，第二個大於0表明替換，是多少表示替換掉多少，第一個參數表明從下標爲幾處開始替換 var num = [1,2,3,4,5];
var newNum = num.splice(1,2,"Tom","Jerry");
console.log(num);    //[1, "Tom", "Jerry", 4, 5]
console.log(newNum); //[2,3]

 

slice:複製數組 返回值是複製到的新數組，該方法並不會修改原數組

　　　　*  返回一個新的數組，包含從 start 到 end （不包括該元素）的 arrayObject 中的元素。

　　　　*  若是 end 未被規定，那麼 slice() 方法會選取從 start 到數組結尾的全部元素。

var array = ["a","b","c","d","e","f"];
console.log(array.slice(-1))     //["f"]
console.log(array.slice(-2))     //["e","f"]
console.log(array.slice(1))      //["b", "c", "d", "e", "f"]
arrays.slice(1,4)                // ["b", "c", "d"]

 

2.拼接：

concat:把一個數組和另外一個數組拼接在一塊兒 返回拼接好的數組 

var array = ["a","b","c"];
var array1 = ["a","b","c"];
var array2 = array.concat(array1);
console.log(array2)    // ["a", "b", "c", "a", "b", "c"]

 

join:把數組中的每一項 按照指定的分隔符拼接成字符串

var array = ["a","b","c","d","e","f"];
var array1 = array.join("");   //"abcdef"
var array2 = array.join("_");  //"a_b_c_d_e_f"

 

3.排序：

reverse:倒序數組 返回值倒序數組 原有數組改變

var  arr = [1, 2, 3, 4, 5];
arr.reverse()     // [5, 4, 3, 2, 1]

 

sort:根據匿名函數進行冒泡排序 b-a倒序 a-b升序,但須要注意的是這個方法是按Ascii碼排序(實用性不大)

var arr = [1,3,7,5,14,24];
arr.sort();
console.log(arr);　　==>[1,14,24,3,5,7]

 

4.經常使用方法：

indexOf:返回獲取項在數組中的索引（第一次出現的索引）

var arr = ['apple','orange','pear'];
 
console.log("found:", arr.indexOf("orange")); // 返回索引  1

 

lastIndexOf:返回獲取項在數組中出現的最後一次索引

var arr = ['apple','orange','orange','pear'];
 
console.log("found:", arr.lastIndexOf("orange"));// 返回索引2

 

forEach: 循環遍歷數組 參數是一個匿名函數 默認返回爲undefined

var array1 = [1,2,3,4,5,6];
var x = array1.forEach(function(value,index,array){
     array[index] = value+1;
     return array;
});
console.log("新數組"+x); //無論以上返回什麼，x都爲undefined
console.log("原數組"+array1); //[2,3,4,5,6,7]

 

map：循環遍歷數組 參數是一個匿名函數

var array1 = [1,2,3,4,5,6];
var x = array1.map(function(value,index,array){
    return value+1;
});
console.log("新數組"+x);         //[2,3,4,5,6,7];
console.log("原數組"+array1);    //[1,2,3,4,5,6];

 

filter：建立一個新的匹配過濾條件的數組

var arr = [
  {"name":"apple", "count": 2},
  {"name":"orange", "count": 5},
  {"name":"pear", "count": 3},
  {"name":"orange", "count": 16},
];
   
var newArr = arr.filter(function(item){
  return item.name === "orange";
});
 
console.log("Filter results:",newArr); // [
　　　　　　　　　　　　　　　　　　　　　　　　　　{"name":"orange", "count": 5},
　　　　　　　　　　　　　　　　　　　　　　　　　　{"name":"orange", "count": 16}
　　　　　　　　　　　　　　　　　　　　　　　　　 ]

 

reduce：數組中的每一個值（從左到右）開始合併，最終爲一個值。

var arr = [1,2,3,4];
var newarr = arr.reduce(function(x, y) {
        return x * 10 + y;
    });
console.log(newarr)   // 1234

/**
*   reduce(callback, initialValue)會傳入兩個變量
*　　回調函數(callback)，初始值(initialValue)
*　　通常來說prev是從數組中第一個元素開始的，next是第二個元素。
*　　可是當你傳入初始值(initialValue)後，第一個prev將是initivalValue，next將是數組中的第一個元素。
*/

var arr = ["apple","orange"];
function noPassValue(){
  return arr.reduce(function(prev,next){
    console.log("prev:",prev);    //prev: apple
    console.log("next:",next);    //prev: orange
     
    return prev + " " +next;    //"apple orange"
  });
}
noPassValue();


var arr = ["apple","orange"];
function passValue(){
  return arr.reduce(function(prev,next){
    console.log("prev:",prev);    //  {}       {"apple"}
    console.log("next:",next);    //"apple"    "orange"
     
    prev[next] = 1;               //在此賦值{}["apple"]=1  -->{apple: 1}
    return prev;                  //{apple: 1, orange: 1}
  },{});
}
passValue();

//由此，能夠實現：統計一個數組中有多少個不重複的單詞
var arr = ["apple","orange","apple","orange","pear","orange"];
function getWordCnt(){
  return arr.reduce(function(prev,next){
    prev[next] = (prev[next] + 1) || 1;
    return prev;
  },{});
}
console.log(getWordCnt());   //{apple: 2, orange: 3, pear: 1}

某同窗的期末成績以下表示

var result = [{
        subject: 'math',
        score: 88
    },
    {
        subject: 'chinese',
        score: 95
    },
    {
        subject: 'english',
        score: 80
    }];
如何求該同窗的總成績？
很顯然，利用for循環能夠很簡單得出結論
var sum = 0;
for(var i=0; i<result.length; i++) {
    sum += result[i].score;
}
可是咱們的宗旨就是拋棄for循環，所以使用reduce來搞定這個問題，如下至關於設置初始分爲0，
var sum = result.reduce(function(prev, cur) {
    return cur.score + prev;
}, 0);