标签：
Array
array.concat(item...); //产生一个新数组
如果item，是一个数组，那么它的每个元素会被分别添加(浅复制，只解析一层)。
示例：
var a = [1, 3, 4];
var b = [5, 8];
var c = a.concat(b, true, false);
console.log(a);
console.log(b);
console.log(c);
=>1, 3, 4
=>5, 8
=>1, 3, 4, 5, 8, true, false
var a = [1, 3, 4];
var b = [[9, 9], 8];
var c = a.concat(b, true, false);
console.log(a);
console.log(b);
console.log(c);
=>1, 3, 4
=>[9, 9], 8
=>1, 3, 4, [9, 9], 8
array.join(separator); //将数组中的元素，用separator连接成字符串。separator默认‘,‘。在IE6/7中效率优于+号连字符。
示例：
var a = [1, 3, true, 4];
console.log(a.join(‘‘));
console.log(a.join(‘|‘));
console.log(a);
=>13true4
=>1|3|true|4
=>1, 3, true, 4
array.slice(start, end); //浅复制，[start, end)左闭右开。end默认是array.length,如果start或end为负数，array.length会尝试与其相加。
示例：
var a = [5, 3, 4, 8];
var b = a.slice(1, 3);
var c = a.slice(-2, -1);
var d = a.slice(-2);
console.log(a);
console.log(b);
console.log(c);
console.log(d);
=>5, 3, 4, 8
=>3, 4
=>4
=>4, 8
array.splice(start, deleteCount, item...); //移除一个或多个元素，并用新的item替换它们。返回一个包含被移除元素的数组。
模拟实现：
Function.prototype.method = function (name, func) {
this.prototype[name] = func;
return this;
};
Array.method(‘splice‘, function (start, deleteCount) {
var len = this.length;
var insertCount = Math.max(arguments.length - 2, 0);
var gap = insertCount - deleteCount;
var newLen = this.length + gap;
var delArr = [];
var delCountTemp = deleteCount;
var i = 0;
var j = 0;
var k;
start = start || 0;
if (start < 0) {
start = start + len;
}
start = Math.max(Math.min(start, len), 0);
while (delCountTemp > 0) {
delArr[i] = this[start + i];
i++;
delCountTemp--;
}
k = len - 1 - (start + deleteCount - 1); //原数组中需要移动位置的元素个数
if (gap > 0) {
while ( k > 0) {
this[len - 1 + gap - j] = this[len - 1 - j];
j++;
k--;
}
console.log(newLen);
this.length = newLen;
} else if (gap < 0) {
while (k > 0) {
this[start + deleteCount - 1 + gap + j + 1] = this[start + deleteCount - 1 + j + 1];
j++;
k--;
}
this.length = newLen;
}
for (i = 0; i < insertCount; i++) {
this[start + i] = arguments[i + 2];
}
return delArr;
});
示例：
var a = [1, 3, 4, 5];
var b = a.splice(1, 1, [22, 4], ‘aa‘);
console.log(a);
console.log(b);
=>1, [22, 4], ‘aa‘, 4, 5
=>3
array.push(item...); //在数组尾部增加元素，会修改原始array，返回数组长度。当item是一个数组，会将其视为一个元素。
模拟实现：
Function.prototype.method = function (name, func) {
this.prototype[name] = func;
return this;
};
Array.method(‘push‘, function () {
this.splice.apply(this, [this.length - 1, 0].concat(Array.prototype.slice.apply(arguments)));
return this.length;
});
示例：
var a = [1, 3, 4];
var b = [5, 8];
var c = a.push(b, true, false);
console.log(a);
console.log(b);
console.log(c);
=>1, 3, 4, [5, 8], true, false
=>5, 8
=>6
array.pop(); //移除array中最后一个元素并返回该元素。
模拟实现：
Function.prototype.method = function (name, func) {
this.prototype[name] = func;
return this;
};
Array.method(‘pop‘, function () {
return this.splice(this.length - 1, 1)[0]; //基于splice实现
});
示例：
var a = [1, 3, true, 4];
var b = a.pop();
console.log(a);
console.log(b);
=>1, 3, true
=>4
array.unshift(item...); //在数组头部部增加元素，会修改原始array，返回数组长度。当item是一个数组，会将其视为一个元素。IE6中的返回值，永远是undefined。
模拟实现：
Function.prototype.method = function (name, func) {
this.prototype[name] = func;
return this;
};
Array.method(‘unshift‘, function () {
this.splice.apply(this, [0, 0].concat(Array.prototype.slice.apply(arguments)));
return this.length;
});
实例：
var a = [1, 3, 4];
var b = [5, 8];
var c = a.unshift(b, true, false);
console.log(a);
console.log(b);
console.log(c);
=>[5, 8], true, false, 1, 3, 4
=>5, 8
=>6
array.shift(); //移除数组中第一个元素并返回该元素。通常，shift比pop慢得多。
模拟实现：
Function.prototype.method = function (name, func) {
this.prototype[name] = func;
return this;
};
Array.method(‘shift‘, function () {
return this.splice(0, 1)[0]; //基于splice实现
});
示例：
var a = [5, 3, 4];
var b = a.shift();
console.log(a);
console.log(b);
=>3, 4
=>5
array.reverse(); //反转数组，返回当前数组。
示例：
var a = [1, 3, 4];
var b = a.reverse();
console.log(a);
console.log(b);
=>4, 3, 1
=>4, 3, 1
array.sort(compareFn); //默认排序的元素都是字符串。可以自定义比较函数替换默认的比较函数。如果两参数相等，返回0。如果第一个参数应该在前，返回负数。如果第二个参数应该在前，返回正数。
示例：
var a = [5, 6, ‘31‘, ‘a‘, ‘A‘, ‘ade‘, ‘aDe‘];
var b = a.sort(); //按字符串排序
console.log(a);
console.log(b);
=>‘31‘, 5, 6, ‘A‘, ‘a‘, ‘aDe‘, ‘ade‘
=>‘31‘, 5, 6, ‘A‘, ‘a‘, ‘aDe‘, ‘ade‘
var a = [3, 5, 11, 8, 33];
var b = a.sort(function (a, b) {//对数字排序
return a - b;
});
console.log(a);
console.log(b);
=>3, 5, 8, 11, 33
=>3, 5, 8, 11, 33
var a = [5, 6, ‘3‘, ‘a‘, ‘A‘, ‘ade‘, ‘aDe‘];
var b = a.sort(function (a, b) {//对数字和字符串排序
if (a === b) {
return 0;
} else if (typeof a === typeof b) {
return a < b ? -1 : 1;
} else {
return typeof a < typeof b ? -1 : 1;
}
});
console.log(a);
console.log(b);
=>5, 6, ‘3‘, ‘A‘, ‘a‘, ‘aDe‘, ‘ade‘
=>5, 6, ‘3‘, ‘A‘, ‘a‘, ‘aDe‘, ‘ade‘
var a = [
{‘first‘: 5, ‘second‘: ‘d‘},
{‘first‘: ‘dd‘, ‘second‘: 44},
{‘first‘: 3, ‘second‘: ‘e2‘},
{‘first‘: ‘3a‘, ‘second‘: 3}
];
var by = function (name) {//对对象排序,sort方法是不稳定的（两个相等元素的相对位置不固定），因此链式多次调用该by方法，不能保证得到想要的结果。可以使用下面的增强版，来得到想要的结果。
return function (a, b) {
var temp1, temp2;
if (typeof a === ‘object‘ && typeof b === ‘object‘ && a && b) {
temp1 = a[name];
temp2 = b[name];
if (temp1 === temp2) {
return 0;
} else if (typeof temp1 === typeof temp2) {
return temp1 < temp2 ? -1 : 1;
} else {
return typeof temp1 < typeof temp2 ? -1 : 1;
}
} else {
throw {
‘name‘: ‘排序出错！‘,
‘message‘: ‘数组含有Object类型的元素‘
};
}
};
};
var b = a.sort(by(‘first‘));
console.log(a);
console.log(b);
=>{‘first‘: 3, ‘second‘: ‘e2‘},
{‘first‘: 5, ‘second‘: ‘d‘},
{‘first‘: ‘3a‘, ‘second‘: 3},
{‘first‘: ‘dd‘, ‘second‘: 44}
=>{‘first‘: 3, ‘second‘: ‘e2‘},
{‘first‘: 5, ‘second‘: ‘d‘},
{‘first‘: ‘3a‘, ‘second‘: 3},
{‘first‘: ‘dd‘, ‘second‘: 44}
var a = [
{‘first‘: 5, ‘second‘: ‘d‘},
{‘first‘: ‘dd‘, ‘second‘: 44},
{‘first‘: 3, ‘second‘: ‘e2‘},
{‘first‘: 3, ‘second‘: 3}
];
var by = function (name, minor) {//minor是次级比较函数，在a和b相等时，调用。
return function (a, b) {
var temp1, temp2;
if (typeof a === ‘object‘ && typeof b === ‘object‘ && a && b) {
temp1 = a[name];
temp2 = b[name];
if (temp1 === temp2) {
return typeof minor === ‘function‘ ? minor(a, b) : 0;
} else if (typeof temp1 === typeof temp2) {
return temp1 < temp2 ? -1 : 1;
} else {
return typeof temp1 < typeof temp2 ? -1 : 1;
}
} else {
throw {
‘name‘: ‘排序出错！‘,
‘message‘: ‘数组含有Object类型的元素‘
};
}
};
};
var b = a.sort(by(‘first‘));
console.log(a);
console.log(b);
=>{‘first‘: 3, ‘second‘: 3},
{‘first‘: 3, ‘second‘: ‘e2‘},
{‘first‘: 5, ‘second‘: ‘d‘},
{‘first‘: ‘dd‘, ‘second‘: 44}
=>{‘first‘: 3, ‘second‘: 3},
{‘first‘: 3, ‘second‘: ‘e2‘},
{‘first‘: 5, ‘second‘: ‘d‘},
{‘first‘: ‘dd‘, ‘second‘: 44}
标签：
原文地址：http://www.cnblogs.com/bugong/p/4356768.html
