2015-03-22——常用的js Array方法

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}