数组，类数组相关知识点

创建数组

var arr=new Array(10);//只写一个10相当于创建一个长度为10的空数组,括号不可为小数
var arr1=[10]  //只有一个10的数组，长度是1

数组的相关方法

改变数组的方法

可以改变原数组 👉 push pop shift unshift sort reverse splice

push

在数组末端添加，并返回新的长度

//push  重写
Array.prototype.push=function (){
    for(i=0;i<arguments.length;i++){
        this[this.length]=argments.i;}
        //在数组的最后一位进行赋值。最后一位的下标就是length
        return this.length;
}

pop

将数组从后往前剪切出去,添加参数无意义,执行一次剪切一次,返回原始长度

var arr=[1,2,3]
arr.pop();//3 arr=[1,2]
arr.pop();//2 arr=[1]

shift

在原数组数组前端剪切内容，并且返回该项

arr=[1,2,3,4,5]
arr.shift(5)//加参数也没用。
[2, 3, 4, 5]

unshift

在原有数组前端添加内容和push方向不同,返回数组的新长度

var arr=[1,2,3]
arr.unshift(1,2);//arr=[1,2,1,2,3]

重写unshift

Array.prototype.unshift=function(){
    var len=arguments.length;
    for(var i=this.length-1;i>=0;i--){
        this[i+len]=this[i];
    }
    for(var j=0;j<this.length;j++){
        this[j]=arguments[j];
    }
    return this.length
}

reverse

逆转原数组的数据

var arr=[1,2,3]
arr.reverse();//arr=[3,2,1]

splice

• 给数组添加、删除、替换一个或多个元素，返回被删除的元素
• （开始的下标，截取多少长度，在切口处添加新的数据）
• 返回截取出来的数据
• 可以用于数据插入

arr=[1,2,3,5]
arr.splice(3,0,4)//arr=[1,2,3,4,5]
//可以传负数，就是从倒数下标开始截取
arr=[1,2,3,4,5]
arr.splice(-1);//arr=[1,2,3,4]

splice 使用

var arr1=arr.splice();//创建一个空数组
var arr1=arr.splice(0);//将数组的所有元素传递给新数组

// 负数指从后向前数
var arr1=arr.splice(-2);//从数组的倒数第二位开始截取到尾部
var arr1=arr.splice(2,2);//从第二位开始删除2个元素
var arr1=arr.splice(2,0,12,14);//插入元素12，14，插入在下标2
var arr1=arr.splice(2,2,12,14);//替换元素，删除两位并且插入12，14

sort

给数组排序 升序排列改变原数组， ascII排序

//降序就是sort.reverse，只是ascII排序
arr=[1,3,4,5,10]
arr.sort()//[1,10,3,4,5] ,没有按照正常的顺序进行排序，
//但是可以同过sort提供的接口进行进一步的修改排序。有规定的顺序
//设置两个形参 
//编写的代码需要有返回值，返回正数，后面去前面，返回负数前面的数放在前面。
//算法就是冒泡排序
arr.sort(function(a,b){
    return a-b;//升序 如果a>b 则a-b>0  则较小的b去前面
    return b-a;//降序 如果a<b 则b-a>0  则较大的b去前面
})
//拓展 ！！！实现一个数组的乱序，并且一次输出，每次乱序不得一致。
var arr=[1,2,3,4,5,6]
arr.sort(function(){
   return Math.random()-0.5;  //Math.random产生一个(0,1)之间的开区间随机数
})
//-0.5后随机数的范围就是-0.5~0.5，就可以正负数都有50%的概率，
//正负数会影响sort的调换位置，所以要减去0.5

利用sort实现字符串字节排序：

  function retByte(str){
	  var num=str.length;
	  for(i=0;i<str.length;i++){
		  if(str.charCodeAt(i)>255){num++;}//>255占两字节
	  }
	  return num;
  }
  var arr=['angelababy','cxknmsl','蔡xk','蔡徐坤','黄'];

	arr.sort(function(a,b){
		return retByte(a)-retByte(b);
	});

不改变原数组

不会改变原数组的数据👉 concat,join->split,toString,slice,map,filter,some,every,indexof,reduce

concat

拼接数组,赋值,给数组添加新元素,多个数组连接形成新数组，返回新数组

arr=[1,2,3],arr1=[3,5,6];
arr.concat(arr1);//[1,2,3,3,5,6]  产生一个新的数组，不改变原数组

concat 重写

Array.prototype.newConcat=function(arr){
	var arr1=[];
	for(var i=0;i<this.length;i++){
		arr1.push(this[i]);
	}
    for(var i=0;i<arguments.length;i++){
    	if(arguments[i].constructor==Array){
        	for(var j=0;j<arguments[i].length;j++){
            	arr1.push(arguments[i][j]);
            }
        }
        else arr1.push(arguments[i])
    }
     return arr1;
}

slice

截取 返回截取出来的新数组，可以用于赋值数据组。

slice(从该下标开始截取，截取到该下标之前)//两个参数,
slice(从该位置开始截取一直到最后)//一个参数
slice()//不写参数  复制一个新的数组

join("a"); 将数组内的数据用a连接成字符串，
split("a") 将字符串按照a拆分成数组
arr=[1,2,3,4,5,6];

map

• 返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
• 方法按照原始数组元素顺序依次处理元素。
  map 重写

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

filter

方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

方法重写：

//普通写法
Array.prototype.myFilter = function (fn){
    var arr=[];
    for(var i=0;i<this.length;i++){
        var isTrue=fn(this[i],i,this);
        isTrue&&arr.push(this[i]);
    }
    return arr
}

//精简写法
Array.prototype.myFilter = function (fn){
    var arr=[];
    for(var i=0;i<this.length;i++){
        var isTrue=fn(this[i],i,this);
        isTrue&&arr.push(this[i]);
    }
    return arr
}

some

遍历数组，查找是否有满足条件（返回的结果如果是true，）就直接跳出遍历，返回true

some(function(item,index,a)){}

some 重写：

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

every

个是否都满足条件，如果有一个返回的结果是false，直接返回false

every 重写：

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

reduce

• 接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
• 4个参数 (上一个值,项,索引,数组名)

arr.reduce(function(preValue,ele,index,arr){
    //prevalue 上一次执行函数所返回的值
},initial)
//initial preValue的初始值可以为null,可以为空,为空时取数组第一位,ele则为第二位

var arr=[1,2,3,4,5]
var value=arr.reduce(function(preValue,ele,index){
    return preValue+ele;
});
console.log(value

reduce重写：

Array.peototype.myReduce=function(fnc,init){
    var previous=init,i;
    if(init===undefined){
        previous=this[0];
        i=1;
    } 
    for(i;i<this.length;i++){
        previous=fnc(previous,this[i],i){
        }
        return previous
    }
}

indexOf

indexof(要查找的元素,从第几位开始查找该位置被包含);
//返回被查找的下标,没有则返回-1

foreach重写

//foreach重写
Array.prototype.myForeach = function (fn){
    for(var i=0;i<this.length;i++){
        fn(this[i],i)
    }
}

转换为数组的方法

var list=Array.prototype.slice.call(inputs);
var list=[].slice.call(inputs);
var list=Array.prototype.concat.apply([],inputs);
var list=[].concat.apply([],inputs);

类数组

类数组的构成：属性要为索引(数字)属性，必须要有length属性，最好加上push方法
其实是对象但是可以当做数组来用

var arr={
    "0":"a",
    "1":"b",
    "2":"c",
    "length":"3",
    "push":Array.prototype.push
} 

Array.prototype.push=function(target){
    this[this.length]=target;//因为是对象调用，所以this就相当于对象obj
    this.length++;
}

阿里巴巴笔试题：

var obj={
	"2":"a",
	"3":"b",
	"length":2,
	"push":Array.prototype.push
}
obj.push('c');
obj.push('d');

因为push的原理是： 所以length为2 就相当于在下标2赋值，所以2,3变为c,d

Array.prototype.push=function(target){
    this[this.length]=target;//this.2=target;
    this.length++;
}