关于数组

创建数组两种方式： 

var arr = new Array(num);// num 可以为空

直接创建：

var arr = [];

数组常用方法：

改变原数组：

push、pop、shift、unshift、splice、sort、reverse

push 数组最后一位添加，可以push多个值，返回值为数组长度；

var arr = [1,2,3,4];
var len = arr.push(1,2); 
console.log(arr,len); // arr = [1,2,3,4,1,2]; len = 6;

push函数仿写：

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

pop 将数组最后一位剪切，一次只能一个，返回值为被剪切的值；

var arr = [1,2,3,4];
var value = arr.pop();
console.log(arr,value);// arr = [1,2,3]; value = 4;

pop函数仿写：

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

shift 将数组第一位进行剪切，一次只能一个，返回值为被剪切的值；

var arr = [1,2,3,4];
var value = arr.shift();
console.log(arr,value);// arr = [2,3,4]; value = 1;

unshift 在数组第一位添加，可以unshift多个值，返回值为数组长度；

var arr = [1,2,3,4];
var len = arr.unshift(666,888);
console.log(arr,len); // arr = [666,888,1,2,3,4]; len = 6;

  unshift函数仿写：

        Array.prototype.myUnshift = function () {
            var arr = [];
            for(var i = 0; i < this.length; i++){
                arr[i + arguments.length] = this[i];
            }
            for(var i = 0; i < arguments.length; i++){
                arr[i] = arguments[i];
            }
            for(var i = 0; i < arr.length; i++){
                this[i] = arr[i];
            }
            return this.length;
        }

splice 截取数组长度，在切口处添加的新数据； splice(arr[i], spliceArr.len, newValue);

var arr = [1,2,3,4,5,6];
var spliceArr = arr.splice(2,3,'222');
console.log(arr,spliceArr); // arr = [1,2,'222',6]; spliceArr = [3,4,5];

注意：arr[i] 可为负数；

splice函数仿写，可能复杂了……

Array.prototype.mySplice = function () {
            var arr = [];
            var newArr = [];
            if(arguments.length == 0){
                arguments[0] = 0;
                arguments[1] = 0;
            }else if(arguments.length == 1){
                arguments[0] = arguments[0] >= 0 ? arguments[0] : arguments[0] + this.length;
                arguments[1] = this.length - arguments[0];
            }
            arguments[0] = arguments[0] >= 0 ? arguments[0] : arguments[0] + this.length;
            //  arr 截取数组
            var len = arguments[1] <= this.length ? arguments[1] : this.length - arguments[0];
            for(var i = 0; i < len;i++){
                arr[i] = this[arguments[0] + i];
            }
            //  截取后数组Arr拼合
            //  前
            for(var i = 0; i < arguments[0]; i++){
                newArr[i] = this[i];
            }
            //  插入
            for(var i = 0; i < arguments.length - 2; i++){
                newArr[arguments[0] + i] = arguments[i + 2];
            }
            // 后
            for(var i = 0; i < this.length - arguments[0] - arguments[1]; i++){
                newArr[arguments[0] + arguments.length - 2 + i] = this[arguments[0] + arguments[1] + i];
            }
            // 将新数组重新赋值给 this
            this.length = newArr.length;
            for(var i = 0; i < newArr.length; i++){
                this[i] = newArr[i];
            }
            return arr;
        } 

sort  排序，按asc码进行排序，返回结果为处理后的新数组；

var arr = [1,15,13,4,33,5,6];
var retArr = arr.sort();
console.log(arr,retArr); // arr = [1,13,15,33,4,5,6]; retArr = [1,13,15,33,4,5,6];

sort（func）

 1、必须有两个形参 

2、看返回值；返回值为负数，则前面的数在前；返回值为正数，则后面的数在前；为0，则不动；

var arr = [1,2,12,3,4,5,6];
// 循环执行arr.length - 1 次操作
arr.sort(function(a,b){
    console.log(a,b); //(1,2);(2,12);(12,3);(3,4);(4,5);(5,6);
})

 

例：按大小升序排列

 

var arr = [1,2,12,3,4,5,6];
// 按大小升序；
arr.sort(function(a,b){
    return a - b;
})

给一个有序的数组乱序

var arr = [1,2,3,4,5,6,7,8,9];
arr.sort(function(a,b){
    return (Math.random() - 0.5);
})
console.log(arr); // 它是乱的

注意：asc码比较，逐位比较；

reverse 颠倒数组中的元素顺序；

var arr = [1,2,3,4,5,6];
var retArr = arr.reverse();
var isTrue = retArr === arr;
console.log(arr,retArr,isTrue); //arr = [6,5,4,3,2,1];  retArr = [6,5,4,3,2,1]; true;

reverse函数仿写：

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

注意：未生成新数组；

未改变原数组：

concat、join、toString、slice

concat 连接两个数组；

var arr = [1,2,3], arr1 = [4,5,6];
var newArr = arr.concat(arr1);
console.log(arr,arr1,newArr); // arr = [1,2,3]; arr1 = [4,5,6]; newArr = [1,2,3,4,5,6];

concat函数仿写：

Array.prototype.myConcat = function () {
            var newArr = [];
            var len = this.length;
            for(var i = 0; i < len; i++){
                newArr[i] = this[i];
            };
            len = newArr.length;
            for(var i = 0; i < arguments.length; i++){
                var tp = Object.prototype.toString.call(arguments[i]);
                if(tp == '[object Array]'){
                    for(var j = 0; j < arguments[i].length;j ++){
                        newArr[len] = arguments[i][j];
                        len = newArr.length;
                    }
                }else {
                    newArr[len] = arguments[i];
                    len = newArr.length;
                }
            }
            return newArr;
        }

join 数组变字符串；join参数为连接字符串；

var arr = [1,2,3];
var str = arr.join('.');
console.log(arr,str); // arr = [1,2,3]; str = '1.2.3';

join函数仿写：

        Array.prototype.myJoin = function () {
            var str = '';
            var join = arguments.length === 0 ? ',' : arguments[0];
            for(var i = 0; i < this.length - 1; i++){
                str += this[i] + join;
            }
            str += this[this.length - 1]; 
            return str;
        }

slice 从i位开始截取，截取到j位；

var arr = [1,2,3,4,5,6];
var arr1 = arr.slice(-3,-2);
console.log(arr,arr1); // arr = [1,2,3,4,5,6]; arr1 = [4];

slice函数仿写：

Array.prototype.mySlice = function () {
            var len = this.length;
            var arr = [];
            if(arguments.length == 0){
                arguments[0] = 0;
                arguments[1] = len;
            }else if(arguments.length == 1){
                if(Math.abs(arguments[0]) > len){
                    arguments[0] = arguments[0] >= 0 ? len : 0;
                }else{
                    arguments[0] = arguments[0] >= 0 ? arguments[0] : arguments[0] + len;
                }
                arguments[1] = len;
            }else{
                if(Math.abs(arguments[0]) > len){
                    arguments[0] = arguments[0] >= 0 ? len : 0;
                }else{
                    arguments[0] = arguments[0] >= 0 ? arguments[0] : arguments[0] + len;
                }
                if(Math.abs(arguments[1]) > len){
                    arguments[1] = arguments[1] >= 0 ? len : 0;
                }else{
                    arguments[1] = arguments[1] >= 0 ? arguments[1] : arguments[1] + len;
                }
            }
            for(var i = 0; i < arguments[1] - arguments[0]; i++){
                arr[i] = this[arguments[0] + i];
            }
            return arr;
        }

toString 返回值与没有参数的 join() 方法返回的字符串相同。

var arr = [1,2,3,4,5,6];
var str = arr.toString();
console.log(arr,str); // arr = [1,2,3,4,5,6]; str = '1,2,3,4,5,6';

ES5新增方法：

indexof、lastIndexof

indexof 两个参数 arr[index] 和 searchBeginIndex（若未填写，则从零开始）;若存在，返回第一个index值；若不存在，返回-1；

        var arr = [1,2,3,4,5,6,7,5,7,5];
        var index = arr.indexOf(5);
        var isExsit = arr.indexOf(2,4);
        console.log(index,isExsit + '不存在的'); // index = 4; isExist = -1;

lastIndexof 两个参数arr[index] 和searchBeginIndex（若未填写，则从arr.length - 1 位开始）; 若存在，返回第一个index值；若不存在，返回 -1；

    var arr = [1,2,3,4,5,6,7,5,7,5];
    var index = arr.lastIndexOf(5);
    var isExsit = arr.lastIndexOf(2,4);
    console.log(index,isExsit);  // index = 9； isExsit = 1; 从index = 4 开始，向前找值为2的索引；

foreach、filter、map、some、every

foreach（func） func函数有三个参数 ele，index，arr；

var newArr = arr.forEach(function(ele,index,arr){
  console.log(ele,index,arr);// ele = 1; index = 0; arr = [1,2,3]; ...
}) // newArr = undefined

foreach 源码仿写

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

filter（func） func函数有三个参数，ele，index，arr；对数组中数值进行筛选，return值为true，插入到新数组中；

    var newArr = arr.filter(function(ele,index,arr){
        console.log(ele,index,arr); // ele = 1; index = 0; arr = [1,2,3]; ...
        if(index % 2 == 0){
            return true;
        }
    })
    console.log(newArr); // newArr = [1,3];

filter源码仿写

    Array.prototype.myFilter = function(func){
        var newArr = [];
        for(var i = 0; i < this.length; i++){
            var target = {};
            if(func(this[i],i,this)){
                if(this[i] && typeof this[i] == 'object'){
                    deepClone(target,this[i]);
                    newArr.push(target);
                }else{
                    newArr.push(this[i]);
                }
            }
        }
        return newArr;
    }

map（func） func函数的三个参数，ele，index，arr；返回值的集合；

    var arr = [1,2,3];
    var newArr = arr.map(function(ele,index,arr){
        return 'this is a map';
    })
    console.log(newArr);// newArr = ['this is a map','this is a map','this is a map'];

map源码仿写

    Array.prototype.myMap = function(func){
        var newArr = [];
        for(var i = 0; i <　this.length; i++){
            if(func(this[i],i,this)){
                newArr.push(func(this[i],i,this));
            }
        }
        return newArr;
    }

some（拥有你便拥有全世界）every（一个都不能少）

    var arr = [1,2,3];
    var result = arr.some(function(ele,index,arr){
        return ele > 2;        
    })
    console.log(result); // true
    var result1 = arr.every(function (ele, index, arr) {
        return ele > 2;
    })
    console.log(result1); // false

some/every源码：

    Array.prototype.mySome = function (func) {
        for(var i = 0; i < this.length; i++){
            if(func(this[i],i,arr)){
                return true;
            }
        }
    }
    Array.prototype.myEvery = function (func){
        var count = 0;
        for(var i = 0; i < this.length; i++){
            if(func(this[i],i,arr)){
                count++;
            }
        }
        return count = count=== this.length ? true : false;
    }

reduce、reduceRight

reduce（func） func的三个参数prevValue ,ele, index

    var arr = [1,2,3,4,5,7];
    var newArr = arr.reduce(function(prevValue,ele,index){
        console.log(prevValue,ele); // (0,1) (1,2) (3,3) (6,4) ...
        return ele + prevValue;
    },0);
    console.log(newArr); //newArr = 22;

reduceRight(func) func 从len - 1 开始遍历

    var arr = [1,2,3,4,5,6];
    var newArr = arr.reduceRight(function(prevValue,ele,index){
        console.log(prevValue);// 6, 11, 15, 18, 20
        return prevValue + ele;
    },0);
    console.log(newArr); // 21;

reduce源码仿写：

    Array.prototype.myReduce = function(func,init){
        var prev = init,
            i = 0,
            len = this.length;
        if(init === undefined){
             prev = this[0];
             i = 1;
        }
        for(i; i < len; i++){
            prev = func(prev,this[i],i);
        }
        return prev;
    }