自己封装JavaScirpt数组方法
pop
功能简述：删除末尾项，返回值为删除的项，原数组发生改变。
核心思想：取得并返回该数组的最后一项，且该数组长度减一，实现删除。
var ary = [1,2,3,4,5,6];
Array.prototype.MyPop = function () {
let len = this.length;
if (!len) {
return
}
let a = this[len - 1];
this.length--;
return a
};
console.log(ary.MyPop()); //6
console.log(ary); //[1, 2, 3, 4, 5]push
功能简述：向数组末尾增加项，返回值为增加后的数组长度，原数组发生改变。
核心思想：以原数组的总长度为索引起点，通过循环将形参依次加入原数组的末尾，实现末尾添加。
var ary = [1,2,3,4,5,6];
Array.prototype.MyPush=function (item) {
var len = this.length;
for (let i = 0; i < arguments.length; i++) {
this[i+len]=arguments[i]
}
return this.length
};
console.log(ary.MyPush(7,8,9)); //9
console.log(ary) //[1, 2, 3, 4, 5, 6, 7, 8 ,9]shift
功能简述：删除数组首项，返回值为删除的项，原数组发生改变。
核心思想：将原数组的首项储存在变量中作为函数的返回值，尔后数组中的每一项取后一项的值，最后删除数组的末尾项实现此功能。
var ary = [1,2,3,4,5,6];
Array.prototype.MyShift=function () {
var len =this.length,first=this[0];
if (!len){return}
for (let i = 0; i < len-1; i++) {
this[i]=this[i+1]
}
this.length--;
return first
};
console.log(ary.MyShift()); //1
console.log(ary) //[2, 3, 4, 5, 6]unshift
功能简述：向数组的前端增加项，返回值为增加后的数组长度，原数组改变。
核心思想：考虑到增加后的数组长度为原数组长度与形参长度之和，即以从后向前的顺序将原数组排入数组的后端，以从前向后的顺序将传入的形参排入数组的前端，实现数组的＂拼接＂，得到改变后的数组。
var ary = [1,2,3,4,5,6];
Array.prototype.MyUnshift=function (item){
var len1 =this.length;
var len2 =arguments.length;
for (let i = len1+len2-1; i >= len2; i--) {
this[i]=this[i-len2]
}
for (let i = 0; i < len2; i++) {
this[i]=arguments[i]
}
return this.length
};
console.log(ary.MyUnshift(0,1,2)); //9
console.log(ary) //[0, 1, 2, 1, 2, 3, 4, 5, 6]reverse
功能简述：反转数组，返回值是反转后的数组，原数组改变。
核心思想：通过循环将数组第一项与最后一项的值互换，第二项与倒数第二项互换······依次类推实现功能。
var ary = [1,2,3,4,5,6];
Array.prototype.MyReverse=function () {
var len=this.length;
for (let i = 0; i < len/2; i++) {
var cur = this[i];
this[i] = this[len-i-1];
this[len-i-1] =cur
}
return this
};
console.log(ary.MyReverse()); //[6, 5, 4, 3, 2, 1]
console.log(ary) //[6, 5, 4, 3, 2, 1]indexOf
功能简述：正向查找数值在数组中对应的索引，如果没找到返回负一，原数组不发生改变。
核心思想：正向循环数组找到与形参相等的值后，返回其索引，否则返回负一。
var ary = [1,2,3,3,2,1];
Array.prototype.MyIndexOf=function (item) {
for (let i = 0; i < this.length; i++) {
if(item ===this[i]){
return i;
}
}
return -1;
};
console.log(ary.MyIndexOf(3)); // 2
console.log(ary); //[1, 2, 3, 3, 2, 1]lastIndexOf
功能简述：反向查找数值在数组中对应的索引，如果没找到返回负一，原数组不发生改变。
核心思想：反向循环数组找到与形参相等的值后，返回其索引，否则返回负一。
var ary = [1,2,3,3,2,1];
Array.prototype.MyLastIndexof=function (item) {
for (let i = this.length-1; i >=0; i--) {
if (item === this[i]){
return i;
}
}
return -1;
};
console.log(ary.MyLastIndexof(2)); // 4
console.log(ary); // [1, 2, 3, 3, 2, 1]slice
功能简述：截取数组中的项并返回，原数组不变，根据参数分为以下几种情况：
1.若不传参，截取整个数组；
2.参数只有一个时，以其为索引起点，截取之后所有项；
3.参数有两个时，以第一个为索引起点，第二个为索引终点（不包含第二个索引对应的值），截取中间项。
核心思想：根据参数的数量分为三种情况，没有参数时返回原数组；有一个参数时取其索引之后的值，插入新数组并返回；有两个参数时，取两个索引之间的值，插入新数组并返回。若参数为负数时，将其与数组总长度相加转换为正数后，进入循环。
var ary = [1, 2, 3, 4, 5, 6, 7, 8, 9];
Array.prototype.MySlice = function (a, b) {
var len = arguments.length;
var newAry = [];
if (len === 0) {
return this
}
if (a < 0) {
a += this.length
}
if (b < 0) {
b += this.length
}
if (len === 1) {
for (var i = a; i < this.length; i++) {
newAry[i - a] = this[i]
}
}
for (var i = a; i < b; i++) {
newAry[i - a] = this[i]
}
return newAry;
};
console.log(ary.MySlice()); //[1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log(ary.MySlice(2)); //[3, 4, 5, 6, 7, 8, 9]
console.log(ary.MySlice(-4, -2)); //[6, 7]
console.log(ary.MySlice(-4, 8)); //[6, 7, 8]
console.log(ary.MySlice(4, 8)); //[5, 6, 7, 8]
console.log(ary); //[1, 2, 3, 4, 5, 6, 7, 8, 9]splice
功能简述：返回删除的项，原数组发生改变，根据参数分为以下几种情况：
1.若不传参，返回值为空数组；
2.当参数为一个时，以其索引为起点，删除数组中后续所有项；
3.当参数为两个时，以第一个参数为索引起点，第个参数为数量，执行删除；
4.当参数为两个以上时，第三个参数和后续的参数为加入数组的项，实现数组的修改。
核心思想：当无参数时，直接返回空数组；当参数长度为一时，以该参数为索引起点，删除并返回数组中后续的项；当参数长度大于等于两个时，删除并返回删除的项，同时将新传入的项插入原数组删除的位置，确保原数组发生改变。
var ary = [1, 2, 3, 4, 5, 6, 7, 8, 9];
Array.prototype.MySplice = function () {
var len = arguments.length;
var index = arguments[0];
var num = arguments[1];
var ins = [], s1 = [], s2 = [], newAry = [];
for (let i = 0; i < len - 2; i++) {
ins[i] = arguments[i + 2]
}
if (len === 0) {
return newAry
}
if (index < 0) {
index += this.length
}
if (len === 1) {
for (let i = 0; i < this.length - index; i++) {
newAry[i] = this[index + i]
}
this.length = index;
return newAry;
}
if (len >= 2) {
for (let i = 0; i < num; i++) {
newAry[i] = this[index + i];
}
for (let i = 0; i < index; i++) {
s1[i] = this[i]
}
for (let i = 0; i < this.length - index - num; i++) {
s2[i] = this[i + index + num]
}
for (let i = 0; i < ins.length; i++) {
this[i + index] = ins[i];
}
this.length = ins.length + index;
for (let i = 0; i < s2.length; i++) {
this[i + index + ins.length] = s2[i];
}
return newAry;
}
};
console.log(ary.MySplice(3, 4, 'a', 'a')); //[4, 5, 6, 7]
console.log(ary.MySplice()); //[]
console.log(ary); //[1, 2, 3, "a", "a", 8, 9]
console.log(ary.MySplice(-2)); //[8, 9]MyJoin
功能简述：将任一字符插入数组项之间，返回值为加入字符转换后的字符串，原数组不发生改变
核心思想：循环数组每一项除了最后一项，与传入的字符进行拼接，最后再拼接上数组的最后一项。
var ary =[1,2,3,4,5,6];
Array.prototype.MyJoin = function myJoin(item) {
var str ='';
var len =this.length;
for (let i = 0; i < this.length-1; i++) {
str += this[i] + item
}
str +=this[len-1];
return str
};
console.log(ary.MyJoin("^")) //1^2^3^4^5^6末完待续。。。