数组对象的操作方法

方法名	功能	是否改变原数组
array.toString()	把数组转换为用‘,’连接的字符串 var arr = [‘ty’,‘xy’] arr.toString() //“ty,xy”	否
array.join()	也是将所有的数组元素连接成字符串，和toString不同的是，可以指定连接的分隔符 var arr = [‘ty’,‘xy’] arr.join(") //"tyxy"	否
array.pop()	从数组中删除最后一个元素，返回被删除的值 var arr = [1,2,3,4] var x = arr.pop() //4	是
array.push()	在数组结尾处添加一个元素，并返回新数组的长度 var arr = [1,2,3,4] var x = arr.push(5) //5	是
array.shift()	删除首个数组元素，并返回被删的值 var arr = [1,2,3,4] var x = arr.shift() //1	是
array.unshift()	向数组的开头添加一个新元素，并返回新数组的长度 var arr = [1,2,3,4] var x = arr.unshift(0) //5	是
array.reverse()	颠倒数组中元素的顺序	是
array.sort()	返回排序后的数组，如果没有传参数默认是按照ASCII码来排列的如果自定义一个函数来排序的话1、要有两个参数a,b.2、返回值： 如果是负值， a就排在前,如果是正值，b就排在前	是
array.delete()	删除元素,数组会留下为定义的空洞 var arr = [1,2,3,4] delete arr[1]// arr:[1,3,4] 删除后打印arr[1]为undefind	是
array.copyWithin(target, start, end)	将数组元素复制到数组中的另一个位置，覆盖原来的值,会覆盖原始数组 var arr = [1,2,3,4] arr.coprWhithin(0,1) //将索引1到数组结束 复制到 索引0的位置 [2,3,4,4],arr.coprWhithin(0,2) /将索引2到数组结束 复制到 索引0的位置 [3,4,3,4]	是
array.fill(value，start, end)	用静态值填充数组，覆盖原始数组，返回改变后的数组,参数：（用于填充的值，开始索引，结束索引默认arr.length） var arr = [1,2,3,4] var x = arr.fill(8,1) //[1,8,8,8]	是
array.splice(start, del,new)	拼接数组添加、删除、替换，返回被删除或者替换的元素，第一个参数是新元素添加的位置，第二个参数是删除元素的个数，第三个参数是需要添加的元素，不写就没有 var arr = [1,2,3,4] arr.splice(2, 0, 21,23) //在数组2的位置开始，向数组中添加21，23两个元素 var arr = [1,2,3,4] arr.splice(1,2) //从数组下标为1的位置开始删除两个元素 arr:[1,4]	是
array.slice(start, end)	截取指定位置的数组,包括开始位置不包括结束位置，结束参数省略则一直截取到末尾，并返回 var arr = [1,2,3,4] var x = arr.slice(1) //arr:[2,3,4]	否
array.concat()	连接数组，两个或多个数组，返回合并之后的数组 var arr = [1,2,3,4] ；var arr1 = [5,6,7] var newArr = arr…concat(arr1) //[1,2,3,4,5,6,7]	否
array.entries()	方法返回带有键/值对的 Array Iterator 对象。对于原始数组中的每一项，新的迭代对象将包含一个以索引为键，以项值为值的数组 var arr = [1,2,3,4] var x = arr.entries()	否
array.every()	检查数组中的每一项都通过测试，每一项都满足条件返回true，有一项不满足则返回false	否
array.some()	检查数组中的任何元素是否满足条件，只要有一个满足的就返回true，都不满足返回false	否
array.filter(function(currentValue, index, arr), thisValue)	筛选出符合条件的数组，参数：function(当前元素的值，当前元素索引，当前所属的数组对象)，要传递给函数以用作其 “this” 值的值。如果此参数为空，则值 “undefined” 将作为其 “this” 值传递。	否
array.find()	返回数组中第一个通过测试的元素，一找到就返回，不会检查剩余值，没找到返回undefined，不对空数组执行该函数	否
array.findIndex()	返回数组中第一个符合条件的元素的下标，如果找到函数返回 true 值的数组元素，则 findIndex() 返回该数组元素的索引不会检查剩余值，否则返回 -1	否
array.forEach()	按顺序为数组中的每个元素调用一次函数,对于没有值的元素不执行
Array.from()	从具有length属性或可迭代对象的任何对象返回Array对象
array.includes()	检查数组是否包含指定元素，包含元素返回true，否则返回false，includes方法区分大小写	否
array.indexOf()	在数组中搜索指定元素，并返回其位置，搜索将从指定的位置开始，如果没有指定位置，则从头开始，并在数组末尾结束搜索，如果未找到该项目返回-1，如果出现多次，则返回第一次出现的位置。array.indexOf(item, start(可选。从哪里开始搜索。负值给定的位置将从结尾计数，然后搜索到最后。))
array.lastIndexof()	在数组中搜索指定元素，并返回其位置，搜索将从指定的位置开始，如果没有指定位置，则从末尾开始，并在数组开头结束搜索，如果未找到该项目返回-1，如果出现多次，则返回第一次出现的位置。array.lastIndexOf(item, start(可选。从哪里开始搜索。负值的给定的位置从末尾计数，然后搜索到开头。))
isArray()	Array.isArray(obj)判断对象是否是数组， 如果对象是数组返回true，否则返回false
array.keys()	返回带有数组键的的 Array Iterator 对象。	否
array.map()	使用为每个数组元素调用函数的结果，创建新数组，对没有值的数组元素不执行函数	否
array.reduce()	将数组缩减为单个值，为数组中的每个值（从左到右）执行提供的函数，函数返回值存储在累加器中，对于没有值的元素不执行reduce方法，array.reduce(function(total(必须，初始值或者函数先前返回的值), currentValue(当前元素的值), currentIndex, arr(当前元素所属数组)), initialValue(可选。作为初始值传递给函数的值。))	否
array.reduceRight()	将数组缩减为单个值。为数组的每个值（从右到左）执行提供的函数,函数的返回值存储在累加器中,对没有值的数组元素，不执行 reduceRight() 方法。	否
array.valueOf()	返回数组,是数组对象的默认方法	否

arr.copyWithin(target, start, end)
1、范围[start, end)
2、target从…开始
3、如果end > length - 1取到末尾
4、当target > length - 1不发生任何变替换

 const newArr = arr.copyWithin(5,1,2);
 console.log(newArr)//[1, 2, 3, 4, 5]

5、target > start 正常替换
6、start end是负数的时候 start + length end + length 转为正数
7、如果没有start取整个数组的元素
8、 copyWithin 是不改变数组长度，返回原数组的引用
使用这个方法的时候this不一定非要指向一个数组，也可以指向一个对象

   var obj = {
        0: 1,
        1: 2,
        2: 3,
        3: 4,
        4: 5,
        length: 5
    }
    var newObj = [].copyWithin.call(obj, 0, 2, 4);
    console.log(newObj);
    console.log(obj === newObj)

重写copyWithin方法
1、关于左移右移 '<< ’ ‘>>’
‘<<’ 左移 各二进位都左移若干外， 高位丢弃，低位补零
‘>>’ 右移 各二进位都右移若干位，正数高位补零，负数高位补一

 Array.prototype.myCopyWithin = function(target){
        if(this == null){
            throw new TypeError('this is null or not defined');
        }
        var obj = Object(this),//保证调用方法的都是引用对象
            len = obj.length >>> 0,//保证len为正整数
            start  = arguments[1],
            end = arguments[1],
            count = 0,
            dir = 1;
        target = target >> 0;//保证target为正数 null >> 0 0 undefined >> 0 0
        target = target < 0 ? Math.max(target + len, 0) : Math.min(target, len);
        start = start ? start >> 0 : 0;//如果start存在，就得保证它要是一个整数，不存在就直接给0
    //    start小于0时，取大的
        start = start < 0 ? Math.max(start + len, 0) : Math.min(start, len);
        end = end ? end >> 0 : len;//如果end存在，就得保证它要是一个整数，不存在就直接给0
    //    end小于0时，取大的
        end = end < 0 ? Math.max(end + len, 0) : Math.min(end, len)
        if(start < target && target < (start + count)){
            dir = -1;
            start += count - 1;
            target += count - 1
        }
        while(count > 0){
            if(start in obj){
                obj[target] = obj[start];
            } else {
                delete obj[start];
            }
            start +=dir;
            target +=dir;
            count--;
        }
    }