javascript的数组方法重写

push()方法：可接受任意类型的参数，将它们逐个添加到数组的末尾，并返回数组的长度

Array.prototype.myPush = function () {
	var L = this.length;
	for (var i = L; i < L + arguments.length; i++) {
		this[i] = arguments[i - L];
	}
	return this.length;
}

pop()方法：从数组的末尾移除最后一项，减少数组的length值，返回移除的项

Array.prototype.myPop = function () {
	if (this.length == 0) {
		return undefined;
	}
	var last = this[this.length - 1];
	this.length = this.length - 1;
	return last;
}

unshift()方法：在数组的前端添加任意个项，并返回新数组的长度。

Array.prototype.myUnshift = function () {
	var L = this.length;
	for (var i = L + arguments.length - 1; i >= 0; i--) {
		if (i > arguments.length - 1) {
			this[i] = this[i - arguments.length];
		} else {
			this[i] = arguments[i];
		}
	}
	return this.length;
}

shift()方法：移除数组中的第一个项并且返回该项，同时将数组的长度减一。

Array.prototype.myShift = function () {
	if (this.length == 0) {
		return undefined;
	}
	var firstElement = this[0];
	for (var i = 1; i < this.length; i++) {
		this[i - 1] = this[i];
	}
	this.length = this.length - 1;
	return firstElement;
}

forEach()方法：对数组中的每一元素运行给定的函数,没有返回值，常用来遍历元素。

Array.prototype.myForEach = function (callback) {
	for (var i = 0; i < this.length; i++) {
		var element = this[i];
		callback(element, i, this);
	}
}

every()方法：对数组中的每一运行给定的函数，如果该函数对每一项都返回true,则该函数返回true。

Array.prototype.myEvery = function (callback) {
	for (var i = 0; i < this.length; i++) {
		var item = this[i];
		if (!callback(item, i, this)) {
			return false;
		}
	}
	return true;
}

some()方法：对数组中的每一运行给定的函数，如果该函数对任一项都返回true,则返回true。

Array.prototype.mySome = function (callback) {
	for (var i = 0; i < this.length; i++) {
		var item = this[i];
		if (callback(item, i, this)) {
			return true;
		}
	}
	return false;
}

filter()方法：对数组中的每一运行给定的函数，会返回满足该函数的项组成的数组。

Array.prototype.myFilter = function (fn) {
	//fn作为判断元素的条件，所以返回值为boolean
	var newArray = [];
	var len = this.length;
	for (var i = 0; i < len; i++) {
		//判断是否满足函数条件
		if (fn(this[i], i)) {
			//过滤出满足条件的元素并深度克隆下来。
			if (typeof this[i] == 'object') {
				var obj = {};
				newArray.push(deepClone(obj, this[i]));
			} else {
				newArray.push(this[i]);
			}
		}
	}
	return newArray;
}

reduce()方法：接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。

Array.prototype.myReduce = function (callback, initialValue) {
	var num = 0;
	if (initialValue != undefined) {
		total = initialValue;
	} else {
		total = this[0];
		num = 1;
	}
	for (i = num; i < this.length; i++) {
		var item = this[i];
		total = callback(total, item, i, this);
	}
	return total;
}

concat()方法：数组拼接，先创建当前数组的一个副本，然后将接收到的参数添加到这个副本的末尾，返回副本，不改变原数组。

Array.prototype.myConcat = function () {
	var arr2 = [];
	for (var i = 0; i < this.length; i++) {
		arr2[i] = this[i];
	}
	for (var i = 0; i < arguments.length; i++) {
		if (Array.isArray(arguments[i])) {
			for (var j = 0; j < arguments[i].length; j++) {
				arr2.myPush(arguments[i][j]);
			}
		} else {
			arr2.myPush(arguments[i]);
		}
	}
	return arr2;
}

indexOf()方法：从数组开头向后查找，使用全等操作符，找不到该元素返回-1。第一个参数为要查找
的项，第二个参数（可选）为索引开始位置。

Array.prototype.myIndexOf = function (item, start) {
	var index = -1;
	if (start == undefined) {
		start = 0;
	}
	for (var i = start; i < this.length; i++) {
		if (this[i] == item) {
			index = i
			return index;
		}
	}
	return index;
}

join()方法：用于把数组中的所有元素放入一个字符串。

Array.prototype.myJoin = function (separator) {
	if (this.length == 0) {
		return "";
	}
	if (separator == undefined) {
		separator = ",";
	}
	var str = "" + this[0];
	for (var i = 1; i < this.length; i++) {
		str = str + separator + this[i];
	}
	return str;
}

reverse()方法：反转数组项的顺序

Array.prototype.myReverse = function () {
	var temp;
	for (var i = 0; i < Math.floor(this.length / 2); i++) {
		temp = this[i];
		this[i] = this[this.length - 1 - i];
		this[this.length - 1 - i] = temp;
	}
	return this;
}

deepClone()：深度克隆

function deepClone(target, option) {
	if (option) {
		var copy, src;
		for (var prop in option) {
			//罗列出option的属性名
			copy = option[prop];
			//罗列出target的属性名用于对比copy值是否已经有了一样的名称。
			src = target[prop];
			//判断是引用值还是原始值
			if (copy && typeof copy == 'object') {
				//判断引用值是数组还是对象
				if (Object.prototype.toString.call(copy) == '[object Array]') {
					//如果target本身就有这个属性名那就用自己的属性名，如果没有就创建一个空数组用于存放属性值。
					src = src ? src : [];
				} else {
					src = src ? src : {};
				}
				//用递归函数层层渗透解析，一直到原始值。
				target[prop] = deepClone(src, copy);
			} else {
				target[prop] = copy;
			}
		}
	}
	return target;
}