JS——重构方法（push、pop、shift、unshift、reverse、every、some、filter、map、forEach）

重构方法

//声明数组  用于下文
var arr1 = ['zhangsan', 'lisi', 1, 3, 6]
var age = [20, 36, 22, 54, 18];

1.栈与队列方法

push()方法

向数组的末尾添加一个或多个元素，并返回新的长度

// 重构push
Array.prototype.Mypush = function (key) {
    var Arr = this;  //调用方法的数组对象
    for (i in arguments) {   //包含传递给函数的每个参数的类数组对象
        Arr[Arr.length] = arguments[i];
    }
    return Arr.length;
}
arr1.Mypush(1, 'jerry', name1 = { num: '123' })
console.log(arr1);
//结果
/*
[ 'zhangsan', 'lisi', 1, 3, 6, 1, 'jerry', { num: '123' } ]
*/

pop()方法

删除数组的最后一个元素并返回删除的元素，改变数组的长度

// 重构pop
Array.prototype.MyPop = function () {
    var Arr = this;
    if (Arr.length == '') {
        return undefined;
    } else {
        var temp = Arr[Arr.length - 1]
        Arr.length -= 1
        return temp;
    }
}
arr1.MyPop();
console.log(arr1);
//结果
/*
	[ 'zhangsan', 'lisi', 1, 3, 6, 1, 'jerry']
*/

shift()方法

用于删除数组的第一个元素，并返回第一个元素的值

//重构shift
Array.prototype.Myshift = function () {
    var Arr = this;
    var first = Arr[0];
    for (i = 0; i < Arr.length; i++) {
        Arr[i] = Arr[i + 1];
    }
    Arr.length--;
    return first;
}
console.log(arr1.Myshift(), arr1);
//结果
/*
	zhangsan [ 'lisi', 1, 3, 6, 1, 'jerry' ]
*/

unshift()方法

向数组的开头添加一个或更多元素，并返回新的长度

//重构unshift
Array.prototype.Myunshift = function (key) {
    var Arr = this;
    for (j = Arr.length + arguments.length - 1; j > 0; j--) {
        var temp = Arr[j - arguments.length];
        Arr[j] = temp;
    }
    for (i in arguments) {
        Arr[i] = arguments[i]
    }
    return Arr.length;
}
console.log(age.Myunshift(23), age);
//结果
/*
	6 [ 23, 20, 36, 22, 54, 18 ]
*/

2.排序方法

reverse()方法

用于颠倒数组中元素的顺序

//重构reverse
Array.prototype.Myreverse = function () {
    var Arr = this;
    newArr = [];
    for (i = 0, j = Arr.length - 1; i < Arr.length, j >= 0; i++, j--) {
        newArr[i] = Arr[j];
    }
    for (i = 0; i < Arr.length; i++) {
        Arr[i] = newArr[i];
    }
}
age.Myreverse();
console.log(age);
//结果
/*
	[ 18, 54, 22, 36, 20, 23 ]
*/

3.迭代方法

every()方法

用于检测数组所有元素是否都符合指定条件，都符合返回true，有一个元素不符合返回false

语法

array.every(function(currentValue,index,arr), thisValue)
//  当前元素 当前元素下标 当前数组  
//函数体参数是必需的，函数体中currentValue是必需的，index,arr是可选的
//thisValue   该参数可选，用于改变this指向

// 重构every方法
Array.prototype.MyEvery = function (f, obj) {
    var Arr = this;
    for (i = 0; i < Arr.length; i++) {
        if (!(obj ? f.bind(obj)(Arr[i], i, Arr) : f(Arr[i], i, Arr)))
            return false;
    }
    return true;
}
// 调用
// 方法中的第二个参数用于改变this指向，参数可选
// 没有该参数的话，this指向全局或window，有的话指向该参数
var res = age.MyEvery(function (x) {
    // console.log(this);
    return x >= 18;
}, 12)
console.log(res);
//结果
/*
	true
*/

some()方法

用于检测数组中的元素是否满足指定条件，只要有一个数组元素满足条件，则返回true，一个数组元素都不满足条件，就返回false

语法

array.some(function(currentValue,index,arr), thisValue)
//  当前元素 当前元素下标 当前数组  
//函数体参数是必需的，函数体中currentValue是必需的，index,arr是可选的
//thisValue   该参数可选，用于改变this指向

// 重构some
Array.prototype.MySome = function (f, obj) {
    var Arr = this;
    // 判断是否有obj这个参数
    var newThis = obj ? f.bind(obj) : f;
    for (i in Arr) {
        if (newThis(Arr[i], i, Arr) == true)
            return true;
    }
    return false;
}
// 调用
var res1 = age.MySome(function (x) {
    return x >= 19;
})
console.log(res1);
//结果
/*
	true
*/

filter()方法

返回一个新数组，新数组中包含指定数组中符合条件的所有元素

语法

array.filter(function(currentValue,index,arr), thisValue)
//  当前元素 当前元素下标 当前数组  
//函数体参数是必需的，函数体中currentValue是必需的，index,arr是可选的
//thisValue   该参数可选，用于改变this指向

//重构filter
Array.prototype.MyFilter = function (f, obj) {
    var Arr = this;
    var newArr = [];
    for (i in Arr) {
        if (obj ? f.bind(obj)(Arr[i], i, Arr) : f(Arr[i], i, Arr)) {
            newArr.Mypush(Arr[i]);
        }
    }
    return newArr;
}
var res2 = age.filter(function (x) {
    return x >= 19;
})
console.log(res2);
//结果
/*
	[ 54, 22, 36, 20, 23 ]
*/

map()方法

返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值

语法

array.map(function(currentValue,index,arr), thisValue)
//  当前元素 当前元素下标 当前数组  
//函数体参数是必需的，函数体中currentValue是必需的，index,arr是可选的
//thisValue   该参数可选，用于改变this指向

// map
Array.prototype.Mymap = function (fun, obj) {
    var Arr = this;
    var result = [];
    for (i = 0; i < Arr.length; i++) {
    	result.push(obj ? fun.bind(obj)(Arr[i], i, Arr) : fun(Arr[i], i, Arr))
    }
    return result;
}
var result = age.Mymap(function (item, index, arr) {
    return item + 2;
})
console.log(result);
//结果
/*
	[ 20, 56, 24, 38, 22, 25 ]
*/

forEach()方法

调用数组的每个元素，并将元素传递给回调函数

语法

array.forEach(function(currentValue, index, arr), thisValue)
//  当前元素 当前元素下标 当前数组  
//函数体参数是必需的，函数体中currentValue是必需的，index,arr是可选的
//thisValue   该参数可选，用于改变this指向

// 重构forEach
Array.prototype.MyforEach = function (f,obj) {
    var Arr = this;
    for (i = 0; i < Arr.length; i++) {
        var fun = obj ? f.bind(obj) : f;
        fun(Arr[i], i, Arr);
    }
}
age.MyforEach(function (age1, index) {
    console.log(index + '--' + age1);
})
//结果
/*
	0--18
	1--54
	2--22
	3--36
	4--20
	5--23
*/