数组原型方法的分类:
一、会改变调用它们的对象自身的值
二、不会改变调用它们的对象自身的值
三、遍历方法
二、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