数组原型方法的分类：

一、会改变调用它们的对象自身的值

二、不会改变调用它们的对象自身的值

三、遍历方法

二、8个不会改变调用它们的对象自身的值的方法

concat(value1,value2,...valueN)

作用：将传入的数组或者元素与原数组合并，组成一个新的数组并返回。
参数：valueN -> 要合并的元素

var array = [1, 2, 3];
var array2 = [["a", "b"],9];
var array3 = array.concat(4,[5,6],array2);
console.log(array3); // [1, 2, 3, 4, 5, 6, "a", "b", 9]
console.log(array); // [1, 2, 3],原数组并未被修改
array2[0][0] = 12;
console.log(array3);// [1, 2, 3, 4, 5, 6, 12, "b", 9]
，合并嵌套数组后并保留了引用

若concat方法中不传入参数，那么将基于原数组浅复制生成一个一模一样的新数组。

var array = [{a: 1}];
var array3 = array.concat();
console.log(array3); // [{a: 1}]
console.log(array3 === array); // false
console.log(array[0] === array3[0]); // true，新旧数组第一个元素依旧共用一个同一个对象的引用
array[0].a = 5;
console.log(array3[0].a); // 5,所以array[0]这个对象修改值会影响到array3[0]一起改变

slice(startIndex,endIndex)

作用：将数组中一部分元素浅复制存入新的数组对象，并且返回这个数组对象。
参数：startIndex -> 指定复制开始位置的索引
endIndex -> 指定复制结束位置的索引

var array = ["one", "two", "three","four", "five"];
console.log(array.slice()); // ["one", "two", "three","four", "five"]
console.log(array.slice(2,3)); // ["three"]
console.log(array.slice(-1,-2)); //[]

浅复制是指当对象被复制时，只是复制了对象的引用，指向的依然是同一个对象。

var array = [{color:"yellow"}, 2, 3];
var array2 = array.slice(0,1);
console.log(array2); // [{color:"yellow"}]
array[0]["color"] = "blue";
console.log(array2); // [{color:"bule"}]

join(separator)

作用：将一个数组(或类数组对象)的所有元素以指定的分隔符连接成一个字符串,并返回该字符。(默认以逗号分隔元素)
参数：separator -> 指定一个字符串来分隔数组的每个元素

var array = ['We', 'are', 'Chinese'];
console.log(array.join()); // "We,are,Chinese"
console.log(array.join('+')); // "We+are+Chinese"
console.log(array.join('')); // "WeareChinese"

join处理类数组对象。

var o = {0:"We", 1:"are", 2:"Chinese", length:3};
console.log(Array.prototype.join.call(o,'+')); // "We+are+Chinese"
console.log(Array.prototype.join.call('abc')); // "a,b,c"

//arguments
function f(a, b, c) {
  var s = Array.prototype.join.call(arguments);
  console.log(s); // '1,a,true'
}
f(1, 'a', true);

toString()：返回一个字符串，表示指定的数组及其元素。

var array = ['Jan', 'Feb', 'Mar', 'Apr'];
var str = array.toString();
console.log(str); // Jan,Feb,Mar,Apr

当数组直接和字符串作连接操作时，将会自动调用其toString() 方法。

var str = ['Jan', 'Feb', 'Mar', 'Apr'] + ',May';
console.log(str); // "Jan,Feb,Mar,Apr,May"

toString处理类数组对象。

//toString处理类数组对象，并没有达到预期效果。
var o = {0:'Jan', 1:'Feb', 2:'Mar', length:3};
var o2 = Array.prototype.toString.call(o);
console.log(o2); // [object Object]
//因为Array.prototype.toString调用时，如果对象存在join方法，
//将会被调用；没有则调用Object.prototype.toString
console.log(o.toString()=== o2); // true

//但可以通过给对象添加一个join方法解决
var o = {
  0:'Jan', 
  1:'Feb', 
  2:'Mar', 
  length:3, 
  join:function(){
    return Array.prototype.join.call(this); // 调用数组中的join方法
  }
};
console.log(Array.prototype.toString.call(o)); // "Jan,Feb,Mar"

toLocalString()：返回一个字符串表示数组中的元素。

数组中的元素将调用各自的 toLocaleString 方法

Object：Object.prototype.toLocaleString()
Number：Number.prototype.toLocaleString()
Date：Date.prototype.toLocaleString()

var array= [{name:'Tom'}, 123, "abc", new Date()];
var str = array.toLocaleString();
console.log(str); // [object Object],123,abc,2016/1/5 下午1:06:23

indexOf(searchElement,fromIndex)

作用：查找元素在数组中第一次出现时的索引，如果没有，则返回-1;有，则返回对应索引。（正向查找，从前往后找）
参数：searchElement -> 要查找的元素
fromIndex -> 开始查找的位置

indexOf使用严格相等（即使用 === 去匹配数组中的元素）。

var array = ['abc', 'def', 'ghi','123'];
console.log(array.indexOf('def')); // 1
console.log(array.indexOf('def',-1)); // -1 此时表示从最后一个元素往后查找,因此查找失败返回-1
console.log(array.indexOf('def',-4)); // 1 由于4大于数组长度,此时将查找整个数组,因此返回1
console.log(array.indexOf(123)); // -1, 由于是严格匹配,因此并不会匹配到字符串'123'

indexOf处理类数组对象。

var o = {0:'abc', 1:'def', 2:'ghi', length:3};
console.log(Array.prototype.indexOf.call(o,'ghi',-4));//2
    
// 如果类数组对象不具有length属性或length属性不能被转成一个数值，对象不会改变,返回-1。  
var o = {0:'abc', 1:'def', 2:'ghi',length:'a'};
console.log(Array.prototype.indexOf.call(o,'ghi',-4)); //-1
   
//indexOf受length属性的影响。
var o = {0:'abc', 1:'def', 2:'ghi', length:8};
console.log(Array.prototype.indexOf.call(o,'ghi',-4)); // -1

var o = {0:'abc', 1:'def', 2:'ghi', length:2};
console.log(Array.prototype.indexOf.call(o,'def',-4)); // 1

lastIndexOf(searchElement,fromIndex)

作用：查找元素在数组中最后一个出现时的索引，如果没有，则返回-1;有，则返回对应索引。（逆向查找，从后往前找）
参数：searchElement -> 要查找的元素
fromIndex -> 从此位置开始逆向查找

eg：省略，参考indexOf；

includes(searchElement,fromIndex )

作用：判断当前数组是否包含某指定的值，如果使返回true，否则返回false。（正向查找，从前往后找）
参数：searchElement -> 要查找的元素
fromIndex -> 从该索引处开始查找

var array = [1, 2, NaN];
console.log(array.includes(1)); // true
console.log(array.includes(NaN)); // true
console.log(array.includes(2,-4)); // true

JavaScript Array原型方法整理(二)