ES5中数组的方法

ES5中原生数组方法的描述

数组方法	参数描述	函数原理简述	原数组变化	返回值
push	(需要插入的元素)	添加一个或多个元素到数组的末尾	改变	操作后的数组长度
pop	无	删除一个数组中的最后一个元素	改变	被删除的元素
shift	无	删除数组的第一个元素，并返回这个元素	改变	被删除的元素
unshift	(需要插入的值)	在数组的开头插入一个或多个元素	改变	数组长度
reverse	无	前后颠倒数组中元素的位置，第一个元素会成为最后一个	改变	操作后数组
sort	(空/比较函数)	对数组的元素做原地的排序，并返回这个数组。sort可能不稳定，默认按照字符串的unicode码位点排序	改变	操作后的原数组
splice	(开始索引，要删除数量，要插入值)	在任意的位置给数组添加或删除任意个元素（拼接）；拼接，拆分数组	改变	被删除的值（数组形式）无则为空数组
copyWithin	(开始索引，替代数组开始的索引/空[默认为0]，替代数组结束的索引/空[默认为数组长度])	用于在数组内的替换操作，即替换元素和被替换元素都是数组内的元素	改变	操作后的原数组
concat	(需要拼接的数组)	用于合并两个或多个数组	不变	操作后的数组
includes	(值，索引/查询起始位置) 用来判断当前数组是否包含某指定的值	不变	布尔值
indexOf	(值，索引/查询起始位置)	返回在数组中可以找到一个给定元素的第一个索引	不变	索引
lastIndexOf	(值，索引/查询起始位置)	返回在数组中可以找到一个给定元素的最后一个索引，会从数组的后面向前查找	不变	索引
join	（连接符）	将一个数组（或一个类数组对象）的所有元素连接成一个字符串	不变	连接后的字符串
slice	(开始索引，终止索引/不包含该位置)	在任意的位置给数组添加或删除任意个元素（拼接）	不变	按逻辑增删后的数组（不改变原数组）
toString	无	使数组变成字符串，用’，’连接。若数组的值存在数组，会便遍历拼接在字符串里；对象，会变成[object Object]；undefined则什么都不连接，即会变成，	不变	字符串
toLocalString	无	使数组变成字符串，用’，’连接。数组内的元素会调用自己的toLocalString方法	不变	字符串
forEach	(callback(item/值，index/索引，array/原数组)，v/callback执行的作用域) )	forEach遍历的范围在第一次调用 callback前就会确定。调用forEach后添加到数组中的项不会被 callback访问到。如果已经存在的值被改变，则传递给 callback的值是 forEach遍历到他们那一刻的值。已删除的项不会被遍历到	不变	无
map	(callback(item/值，index/索引，array/原数组),v/callback执行的作用域))	一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组	不变	返回值构成的新数组
keys	无	返回一个新的Array迭代器，它包含数组中每个索引的键	不变	Array迭代器
values	无	返回一个新的Array迭代器，它包含数组中每个值的键	不变	Array迭代器
entries	无	返回一个新的Array迭代器，它包含数组中每个键值对[index，item]	不变	Array迭代器
every	（callback(value，key，arr)，v/callback执行的作用域)）	若数组的值执行callback全部返回true，则最终返回true	不变	布尔值
some	（callback(value，key，arr)，v/callback执行的作用域)）	若数组的值执行callback有一个返回true，则最终返回true	不变	布尔值
filter	（callback(value，key，arr)，v/callback执行的作用域)）	使用指定的函数测试所有元素，并创建一个包含所有测试通过的元素的新数组	不变	使callback返回true的值组成的数组
find	((callback(v，k，a)，v/callback执行的作用域) )	返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。	不变	通过测试的第一个元素值或undefined
findIndex	((callback(v，k，a)，v/callback执行的作用域) )	返回数组中满足提供的测试函数的第一个元素的值的索引。否则返回 undefined。	不变	通过测试的第一个元素值的索引或undefined
reduce	(callback(p/上一次回调的返回值，v/当前被处理的元素，i/索引，a/原数组)=> {}，initialValue初始值)	该方法接收一个函数作为累加器(accumulator)，数组中的每个值（从左到右）开始合并，最终为一个值	不变	最后的返回值
reduceRight	(callback(p/上一次回调的返回值，v/当前被处理的元素，i/索引，a/原数组) ，initialValue初始值)	该方法接收一个函数作为累加器(accumulator)，数组中的每个值（从右到左）开始合并，最终为一个值	不变	最后的返回值
Array.from	(类数组对象)	一个类似数组或可迭代对象中创建一个新的数组实例	不变	数组实例
Array.isArray	(需要检测的元素)	判断一个元素是否为数组	不变	布尔值
Array.isArray	(元素–可多个)	创建一个具有可变数量参数的新数组实例	不变	数组实例
fill	(value，开始索引，结束索引)	将数组中指定区间的所有元素的值，都替换成value	改变	无

数组的实现原理:

push()可以接受多个参数，并将这些参数放置于数组尾部，返回新数组的长度，原始数组发生改变。

Array.prototype.myPush =function(){
   
for (var i = 0; i < arguments.length; i++) {
   
//arguments代表实参的集合
//this 指向的是arr数组
this[this.length] = arguments[i];
}
//由于push 返回值 是一个数组的长度 所以 我们来个return；
return this.length;
};

arr.push(4,5,6);
alert(arr);
//-----结果 [1,2,3,4,5,6];
12345678910111213

pop()不接收参数，从数组尾部删除一个元素，并返回这个删除的元素，原数组发生改变。

  Array.prototype.myPop = function( ){
   
            var len=this.length;
            var result = this[len-1];
            this.length = len - 1;
            return result;
        }
        var a = [1,2,3,4]
        console.log(a.myPop( ))//-----结果4;
        console.log(a);//-----结果 [1,2,3];
123456789

unshift()接受多个参数并,将这些参数放置于数组头部，返回新数组的长度，原数组发生改变。

  Array.prototype.myUnshift=function( ){
   
    var len=arguments.length-1;
    this.length=this.length+len;
    for(var i=this.length-1;i>=0;i--){
   
        this[i+len]=this[i]
    }
    for(var j=1;j<arguments.length;j++){
   
            this[j-1]=arguments[j]
        }
    return this.length
}
var arr=[1,2,5,6];
arr.unshift(10,11)//6
console.log(arr)//[10,11,1,2,5,6];
1234567891011121314

shift()不接受参数，从数组的头部删除一个元素，并返回这个删除的元素，原数组发生改变。

 Array.prototype.myShift = function(){
   
      var result = this[0]
      for(var i=0;i<this.length-1;i++){
   
        this[i] = this[i+1]
      }
      this.length = this.length-1
      return result;
   }
    var a = [1,2,3,4]
     a.myShift()//1
     console.log(a)//[2,3,4]
1234567891011

slice()如果是一个参数，那么该参数表示的索引开始截取，直至数组结束，返回截取的数组，原数组不发生改变。
如果有两个参数，从第一个参数表示的索引开始截取，到第二个参数表示的索引结束，不包括第二个参数对应的索引位上的元素。

Array.prototype.mySlice = function () {
   
    var startIndex = Number(arguments[0]), 
   endIndex = Number(arguments[1]), 
    newArr = [];
   endIndex =endIndex === undefined ? this.length : Number(endIndex) ? Number(endIndex) : 0;
   endIndex =endIndex < 0 ? Math.abs(endIndex) > this.length &&endIndex > -1? 0 : 
   this.length + Math.ceil(endIndex) :endIndex > this.length ? this.length : Math.floor(endIndex);
    startIndex = startIndex ? startIndex < 0 ? Math.abs(startIndex) > this.length