- array.concat(item...)
concat方法产生一个新数组,它包含一份array的浅自制(shallow copy)并把一个或多个参数item附加在其后。如果参数item是一个数组,那么它的每个元素会被分别添加。后面你还会看到和它功能类似的array.push(item...)。
var a = ['a','b','c']; var b = ['x','y','z']; var c = a.concat(b,true); //c变成['a','b','c','x','y','z',true]
- array.join(separator)
join方法把一个array构成一个字符串。它先把array中的每个元素构成一个字符串,接着用一个separator分隔符把它们连接在一起。默认的separator是逗号','。要想做到无间隔的连接,我们可以使用空字符串作为separator。
var a = ['a','b','c']; a.push('d'); var c = a.join(''); //c = 'abcd';
- array.pop()
pop和push方法使得数组array可以像堆栈(stack)一样工作。pop方法移除array中的最后一个元素并返回该元素,如果该array是empty,它会返回undefined。
var a = ['a','b','c']; var c = a.pop(); //a=['a','b']; c='c';
pop可以像这样实现:
Array.method('pop', function(){ return this.splice(this.length - 1, 1)[0]; });
- array.push(item...)
var a = ['a','b','c']; var b = ['x','y','z']; var c = a.push(b,true); //a = ['a','b','c',['x','y','z'],true]; //c=5;push可以像这样实现:
Array.method('push',function(){ this.splice.apply(this,[this.length,0].concat(Array.prototype.slice.apply(arguments))); return this.length; });
- array.reverse()
reverse方法反转array里的元素的顺序,并返回array本身:
var a = ['a','b','c']; var b = a.reverse(); //a = ['c','b','a'];b = ['c','b','a'];
- array.shift()
shift方法移除数组array中的第1个元素并返回该元素。如果这个数组array是空的,它会返回undefined。shift通常比pop慢得多:
var a = ['a','b','c']; var c = a.shift(); //a = ['b','c'];c = 'a';
shift可以像这样实现:
Array.method('shift', function(){ return this.splice(0, 1)[0]; });
- array.slice(start,end)
slice方法对array中的一段做浅复制。首先复制array[start],一起复制到array[end]为止。end参数是可选的,默认值是该数组的长度array.length。如果两个参数中的任何一个是负数,array.length会和它们相加,试图让它们成为非负数。如果start大于等于array.length,得到的结果将是一个新的空数组。千万别把slice和splice弄混了。
var a = ['a','b','c']; var b = a.slice(0,1);//b = ['a']; var c = a.slice(1);//c = ['b','c']; var d = a.slice(1,2);//d = ['b'];
- array.sort(comparefn)
sort方法对array中的内容进行排序。它不能正确地给一组数字排序:
var n = [4, 8, 15, 16, 23, 42]; n.sort(); //n = [15, 16, 23, 4, 42, 8];
javascript的默认比较函数把要被排序的元素视为字符串。它尚未足够智能到在比较这些元素之前先检测它们的类型,所以当它比较这些数字的时候,会把它们转化为字符串,于是得到一个错得离谱的结果。
幸运的是,你可以使用自己的比较函数来替换默认的比较函数。你的比较函数应该接受两个参数,并且如果这两个参数相等则返回 0,如果第一个参数应该排在前面,则返回一个负数,如果第2个参数应该排在前面,则返回一个正数。
n.sort(function(a, b){ return a - b; }); //n=[4, 8, 15, 16, 23, 42];
上面这个函数可以使数字正确排序,但它不能使字符串排序。如果我们想要给任何包含简单值的数组排序,必须要做更多的工作:
var m = ['aa', 'bb', 'a', 4, 8, 15, 16, 23, 42]; m.sort(function (a, b) { if (a === b) { return 0; } if (typeof a === typeof b) { return a < b ? -1 : 1; } return typeof a < typeof b ? -1 : 1; }); //m = [4, 8, 15, 16, 23, 42, 'a', 'aa', 'bb'];
如果大小写不重要,你的比较函数应该在比较之前先将两个运算数转化为小写。
如果有一个更智能的比较函数,我们也可以使对象数组排序。为了让这个事情更能满足一般情况,我们将编写一个构造比较函数的函数:
//by函数接受一个成员名字符串作为参数, //并返回一个可以用来对包含该成员的对象数组进行排序的比较函数。 var by = function (name) { return function (o, p) { var a, b; if (typeof o === 'object' && typeof p === 'object' && o && p) { a = o[name]; b = p[name]; if (a === b) { return 0; } if (typeof a === typeof b) { return a < b ? -1 : 1; } return typeof a < typeof b ? -1 : 1; } else { throw { name: 'Error', massage: 'Expected an object when sorting by' + name }; } }; }; var s = [ { first: 'Joe', last: 'Besser' }, { first: 'Moe', last: 'Howard' }, { first: 'Joe', last: 'DeRita' }, { first: 'Shemp', last: 'Howard' }, { first: 'Larry', last: 'Fine' }, { first: 'Curly', last: 'Howard' } ]; s.sort(by('first')); //s = [ // { first: 'Curly', last: 'Howard' }, // { first: 'Joe', last: 'DeRita' }, // { first: 'Joe', last: 'Besser' }, // { first: 'Larry', last: 'Fine' }, // { first: 'Moe', last: 'Howard' }, // { first: 'Shemp', last: 'Howard' } //];
sort方法是不稳定的,所以下面的调用:
s.sort(by('first')).sort(by('last'));
不能保证产生正确的排序。如果你想基于多个键值进行排序,你需要再次做更多的工作。我们可以修改by函数,让其可以接受第2个参数,当主要的键值产生一个匹配的时候,另一个compare方法将被调用以决出高下。
//by函数接受一个成员名字符串和一个可选的次要比较函数作为参数, //并返回一个可以用来对包含该成员的对象数组进行排序的比较函数。 //当o[name]和p[name]相等时,次要比较函数被用来决出高下。 var by = function (name,minor) { return function (o, p) { var a, b; if (o && p&&typeof o === 'object' && typeof p === 'object' ) { a = o[name]; b = p[name]; if (a === b) { return typeof minor === 'function' ? minor(o, p) : 0; } if (typeof a === typeof b) { return a < b ? -1 : 1; } return typeof a < typeof b ? -1 : 1; } else { throw { name: 'Error', massage: 'Expected an object when sorting by' + name }; } }; }; s.sort(by('last', by('first'))); //s = [ // { first: 'Joe', last: 'Besser' }, // { first: 'Joe', last: 'DeRita' }, // { first: 'Larry', last: 'Fine' }, // { first: 'Curly', last: 'Howard' }, // { first: 'Moe', last: 'Howard' }, // { first: 'Shemp', last: 'Howard' } //];
- array.splice(start,deleteCount,item...)
splice方法从array中移除一个或多个元素,并用新的item替换它们。参数start是从数组array中移除元素的开始位置。参数deleteCount是要移除的元素个数。如果有额外的参数,那些item会插入到被移除的位置上。它返回一个包含被移除元素的数组。
splice最主要的用处是从一个数组中删除元素,千万不要把splice和slice弄混了。
var a = ['a','b','c']; var r = a.splice(1,1,'ache','bug'); //a = ['a','ache','bug','c']; //r = ['b'];
splice可以像这样实现:
Array.method('splice', function (start, deleteCount) { var max = Math.max, min = Math.min, delta, element, insertCount = max(arguments.length - 2, 0), k = 0, len = this.length, new_len, result = [], shift_count; start = start || 0; if (start < 0) { start += len; } start = max(min(start, len), 0); deleteCount = max(min(typeof deleteCount === 'number' ? deleteCount : len, len - start), 0); delta = insertCount - deleteCount; new_len = len + delta; while (k < deleteCount) { element = this[start + k]; if (element !== undefined) { result[k] = element; } k += 1; } shift_count = len - start - deleteCount; if (delta < 0) { k = start + insertCount; while (shift_count) { this[k] = this[k - delta]; k += 1; shift_count -= 1; } this.length = new_len; } else if (delta > 0) { k = 1; while (shift_count) { this[new_len - k] = this[len - k]; k += 1; shift_count -= 1; } this.length = new_len; } for (k = 0; k < insertCount; k += 1) { this[start + k] = arguments[k + 2]; } return result; });
- array.unshift(item...)
unshift方法像push方法一样,用于把元素添加到数组中,但它是把item插入到array的开始部分而不是尾部。它返回array的新的length:
var a = ['a','b','c']; var r = a.unshift('?','@'); //a = ['?','@','a','b','c'] //r = 5;
unshift可以像这样实现:
Array.method('unshift', function(){ this.splice.apply(this, [0, 0].concat(Array.prototype.slice.apply(arguments))); });
※摘抄自《JavaScript语言精粹(修订版)》