• 1）concat方法：不會改變原數(shù)組，會返回一個拼接后的新數(shù)組

  var arr1 = [1,2,3];
  var arr2 = [3,4];
  arr1.concat(arr2);
  console.log(arr1.length); // 3
  console.log(arr1); // [1, 2, 3]
  console.log(arr2); // [3, 4]
  console.log(arr1.concat(arr2)) // [1, 2, 3, 3, 4]

• 2）slice方法：不會改變原數(shù)組，會返回一個截取后的新數(shù)組

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

// slice方法的手動實現(xiàn)，不綁定到原型鏈上
  function my_slice(start, end) {
    var start = start || 0;
    var end = end || this.length; //this指向調(diào)用的對象，當用了call后，能夠改變this的指向，也就是指向傳進來的對象，這是關(guān)鍵
    var result = [];
    for (var i = start; i < end; i++) {
      result.push(this[i]);
    }
    return result;
  }
  arr = [1, 2, 3, 4, 5, 6];
  console.log(my_slice.call(arr)); // [1, 2, 3, 4, 5, 6]
  console.log(my_slice.call(arr, 1, 4)); // [2, 3, 4]
  console.log(my_slice.call(arr, 1, 6)); // [2, 3, 4, 5, 6]

// // slice方法的手動實現(xiàn)，綁定到原型鏈上
  Array.prototype.my_slice = function(start, end) {
    var result = [];
    var start = start || 0;
    var end = end || this.length;
    for (var i = start; i < end; i++) {
      result.push(this[i]);
    }
    return result;
  }

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

• 3）join方法：不會改變原數(shù)組，會返回一個字符串

  var arr = [1,2,3,4,5];
  arr.join('-');
  console.log(arr); // [1, 2, 3, 4, 5]
  console.log(arr.length); // 5
  console.log(arr.join('-')); // '1-2-3-4-5'

• 4）push/pop方法：會改變原數(shù)組

  var arr = [1, 2, 3, 4, 5];
  arr.push(6);
  console.log(arr); // (6) [1, 2, 3, 4, 5, 6]
  console.log(arr.push(7)); // 7
  console.log(arr); // (7) [1, 2, 3, 4, 5, 6, 7]
  arr.pop();
  console.log(arr); // (6) [1, 2, 3, 4, 5, 6]
  console.log(arr.pop()); // 6

• 5）shift/unshift方法：會改變數(shù)組

  var arr = [1,2,3,4,5];
  arr.shift();
  console.log(arr); // (4) [2, 3, 4, 5]
  console.log(arr.length); // 4
  arr.unshift(6);
  console.log(arr); // (5) [6, 2, 3, 4, 5]
  console.log(arr.length); // 5

• 6）sort方法：會改變數(shù)組

  var arr = [21, 1, 3, 45, 2];
  arr.sort();
  console.log(arr); // (5) [1, 2, 21, 3, 45]
  arr.sort(function(a, b) {
    if (a < b) {
      return -1;
    } else if (a > b) {
      return 1;
    } else {
      return 0;
    }
  })
  console.log(arr); // (5) [1, 2, 3, 21, 45]

• 7）reverse方法：會改變數(shù)組

  var arr = [21, 1, 3, 45, 2];
  arr.reverse();
  console.log(arr); // (5) [2, 45, 3, 1, 21]

• 8）splice方法：會改變數(shù)組，并以數(shù)組形式返回被刪除的部分，插入時返回空數(shù)組

  var arr = [1, 2, 3, 4, 5];
  console.log(arr.splice(1,3)); // (3) [2, 3, 4] 返回被刪除的數(shù)
  console.log(arr); // (2) [1, 5]
  var arr1 = [1,2,3,4,5];
  console.log(arr1.splice(1,0,7,8)); // [] 插入時返回空數(shù)組
  console.log(arr1); // (7) [1, 7, 8, 2, 3, 4, 5]
  var arr2 = [1,2,3,4,5];
  console.log(arr2.splice(1,1,7,8)); // [2] 返回被替換掉的數(shù)
  console.log(arr2); // (6) [1, 7, 8, 3, 4, 5]

• 9）indexOf/lastIndexOf方法：不會改變數(shù)組，返回指定數(shù)值的數(shù)組下標

  var arr = [1, 2, 3, 2, 5];
  console.log(arr.indexOf(2)); // 1 返回值為2的數(shù)組的下標
  console.log(arr.indexOf(2,2)); // 3 第一個參數(shù)表示要查找的數(shù)，第二個參數(shù)表示查找起點位置的索引
  console.log(arr.indexOf(6)); // -1
  console.log(arr.lastIndexOf(2)); // 3 從數(shù)組的末尾開始向前查找，返回正序下標
  console.log(arr.lastIndexOf(2,2)); // 1 從數(shù)組的末尾開始向前查找，返回正序下標

• 10）forEach方法：不會改變數(shù)組且方法沒有返回值

  var arr = [1, 2, 3, 2, 5];
  arr.forEach(function(a, index, array) { // 循環(huán)遍歷,對每一項運行給定函數(shù),這個方法沒有返回值
  console.log(a, index, array === arr); // 參數(shù)分別為：遍歷的數(shù)組內(nèi)容,內(nèi)容對應(yīng)的數(shù)組索引,數(shù)組本身
    // 1 0 true
    // 2 1 true
    // 3 2 true
    // 2 3 true
    // 5 4 true
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.forEach(function(a) { // forEach方法沒有返回值
    return a * 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // undefined

• 11）map方法：不會改變原數(shù)組且返回一個新數(shù)組

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.map(function(a) { // 對每一項運行給定函數(shù)，返回每次函數(shù)調(diào)用的結(jié)果組成的數(shù)組
    return a * 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // (5) [2, 4, 6, 4, 10]

• 12）filter方法：不會改變原數(shù)組，且返回一個新數(shù)組

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.filter(function(a) { // 返回滿足過濾條件組成的數(shù)組
    return a > 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // (2) [3, 5]

• 13）every方法：不會改變原數(shù)組，且返回一個布爾值

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.every(function(a) { // 判斷數(shù)組中每一項都是否滿足條件，所有項都滿足條件才會返回true
    return a > 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // false

• 14）some方法：不會改變原數(shù)組，且返回一個布爾值

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.some(function(a) { // 判斷數(shù)組中每一項都是否滿足條件，只要有一項滿足條件就會返回true
    return a > 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // true

• 15）reduce方法：不會改變原數(shù)組，迭代數(shù)組的所有項，然后構(gòu)建一個最終返回的值，從數(shù)組的第一項開始，逐個遍歷到最后

  var arr = [1, 2, 3, 2, 5];
  // reduce方法有兩個參數(shù)：在每一項上調(diào)用的函數(shù)和（可選的）作為歸并基礎(chǔ)的初始值
  // reduce方法的函數(shù)接收 4 個參數(shù)：前一個值、當前值、項的索引和數(shù)組對象
  // 這個函數(shù)返回的任何值都會作為第一個參數(shù)自動傳給下一項
  // 第一次迭代發(fā)生在數(shù)組的第二項上，因此第一個參數(shù)是數(shù)組的第一項，第二個參數(shù)是數(shù)組的第二項
  var sum = arr.reduce(function(pre, cur, index, array) { 
    return pre + cur;
  }, 10)
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(sum); // 23

• 16）reduceRight：不會改變原數(shù)組，迭代數(shù)組的所有項，從數(shù)組的最后一項開始，向前遍歷到第一項

  var arr = [1, 2, 3, 2, 5];
  var sum = arr.reduceRight(function(pre, cur, index, array) { 
    return pre + cur;
  }, 10)
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(sum); // 23

• 17）fill：會改變原數(shù)組，元素填充

// arr.fill(value, start, end)
  var arr = [1, 2, 3, 2, 5];
  arr.fill(1,2,4); // 用1填充數(shù)組中從起始索引到終止索引內(nèi)的全部元素
  console.log(arr); // (5) [1, 2, 1, 1, 5]

• 18）find：不會改變原數(shù)組，返回數(shù)組中滿足提供的測試函數(shù)的第一個元素的值

  function big(element) {
    return element >= 2;
  }
  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.find(big); // 返回數(shù)組中滿足提供的測試函數(shù)的第一個元素的值
  console.log(arr1); // 2 
  console.log(arr); // (5) [1, 2, 3, 2, 5]

• 19）includes方法：用來判斷一個數(shù)組是否包含一個指定的值，返回 true或 false

  var arr = [1, 2, 3, 2, 5];
  console.log(arr.includes(2)); // true
  console.log(arr.includes(6)); // false

• 20）toLocaleString：不會改變原數(shù)組，返回一個字符串表示數(shù)組中的元素，數(shù)組中的元素將使用各自的 toLocaleString 方法轉(zhuǎn)成字符串，這些字符串將使用一個特定語言環(huán)境的字符串（例如一個逗號 “,”）隔開

  var arr = [11111111, 2222222];
  console.log(arr.toLocaleString()); // 11,111,111,2,222,222
  console.log(arr); // (2) [11111111, 2222222]

• 21）toString：不會改變原數(shù)組，返回一個字符串，表示指定的數(shù)組及其元素

  var arr = [1,2,3];
  arr.toString();
  console.log(arr.toString()); // '1,2,3'
  console.log(arr); // (3) [1, 2, 3]

• 22）Array.from：將偽數(shù)組或可迭代對象(包括arguments Array,Map,Set,String…)轉(zhuǎn)換成數(shù)組對象

// arrayLike：想要轉(zhuǎn)換成數(shù)組的偽數(shù)組對象或可迭代對象
// mapFn (可選參數(shù))：如果指定了該參數(shù)，新數(shù)組中的每個元素會執(zhí)行該回調(diào)函數(shù)
// thisArg (可選參數(shù))：可選參數(shù)，執(zhí)行回調(diào)函數(shù) mapFn 時 this 對象
// 返回值：一個新的數(shù)組實例
Array.from(arrayLike, mapFn, thisArg)

toString()方法與toLocalString()方法區(qū)別：

??????1）toLocalString()是調(diào)用每個數(shù)組元素的 toLocaleString() 方法，然后使用地區(qū)特定的分隔符把生成的字符串連接起來，形成一個字符串；

??????2）toString()方法獲取的是String(傳統(tǒng)字符串),而toLocaleString()方法獲取的是LocaleString(本地環(huán)境字符串)；

??????3）如果你開發(fā)的腳本在世界范圍都有人使用，那么將對象轉(zhuǎn)換成字符串時請使用toString()方法來完成；

??????4）LocaleString()會根據(jù)你機器的本地環(huán)境來返回字符串，它和toString()返回的值在不同的本地環(huán)境下使用的符號會有微妙的變化；

??????5）使用toString()是保險的，返回唯一值的方法,它不會因為本地環(huán)境的改變而發(fā)生變化；如果是為了返回時間類型的數(shù)據(jù)，推薦使用LocaleString()；若是在后臺處理字符串，請務(wù)必使用toString()；

###toString()、toLocaleString()、valueOf()方法的區(qū)別
// JS Array
  var arr = [12421,22232,3333];
  console.log(arr.valueOf()); // (3) [12421, 22232, 3333] 返回數(shù)組本身
  console.log(arr.toString()); // '12421,22232,3333' 把數(shù)組轉(zhuǎn)換為字符串，并返回結(jié)果，每一項以逗號分割
  console.log(arr.toLocaleString()); // '12,421,22,232,3,333' 把數(shù)組轉(zhuǎn)換為本地數(shù)組，并返回結(jié)果

// JS Boolean
  var boolean = new Boolean();
  console.log(boolean.valueOf()); // false 返回 Boolean 對象的原始值
  // 根據(jù)原始布爾值或者 booleanObject 對象的值返回字符串 "true" 或 "false",默認為"false"
  console.log(boolean.toString()); // 'false'
  // Boolean對象沒有toLocalString()方法,但是在Boolean對象上使用這個方法也不會報錯

// JS Math
console.log(Math.PI.valueOf()); // 3.141592653589793

// JS Number
  var num = new Number(11337);
  console.log(num.valueOf()); // 11337
  console.log(num.toString()); // '11337'
  console.log(num.toLocaleString()); // '11,337'

// JS String
  var str = 'fsflgs';
  console.log(str.valueOf()); // 'fsflgs'
  console.log(str.toString()); // 'fsflgs'
  console.log(str.toLocaleString()); // 'fsflgs'

// JS Date
  var date = new Date();
  console.log(date); // Thu Sep 13 2018 21:51:58 GMT+0800 (中國標準時間)
  console.log(date.toLocaleString()); // 2018/9/13 下午9:51:58

會改變原數(shù)組的方法

pop、push、shift、unshift、fill、sort、reverse、splice

參考鏈接：
js數(shù)組方法大全
Javascript toString()、toLocaleString()、valueOf()三個方法的區(qū)別