javascript数组详解

蔚落 2021-11-11 06:38 314阅读 0赞

## 静态成员 ##

*  from:将伪数组转换为真数组

let args = Array.from(arguments);

*  isArray 判断给定的数据是不是真数组（真数组:通过Array构造器构造的数组）
 *  of Array.of()与new Array()的区别,如果只有一个参数n，前者表示数组只有一位，值为n；后者表示创建一个长度为n的空数组

## 实例成员 ##

> 会改变原数组

*  fill 填充数组，将数组的指定区间的值换为某个固定值 fill(val,a,b); // fill with val from position a until position b
 *  pop 删除数组的最后一位并返回
 *  push 在数组末尾新增一个元素并返回数组长度
 *  reverse 将数组颠倒顺序
 *  shift 删除数组的第一个元素并返回
 *  unshift 将一个或多个元素添加到数组的开头，并返回该数组的新长度
 *  sort 排序
 *  splice splice(n1,n2,a,b,c…) 从第 n1 位开始删除 n2 个元素，插入a , b, 和 c …

> 不会改变原数组

*  concat `var newArr = arr1.concat(arr2,arr3...)`返回链接后的新数组
 *  includes 是否包含满足条件的元素 arr.includes(val,n) 第二颗参数可传可不穿，表示从下标为n的位置开始，是否包含val(严格比较)
 *  join 将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。如果省略参数，数组元素用逗号分隔。默认为 “,”
 *  slice 返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。
 *  toString 返回一个表示该对象的字符串。
 *  indexOf 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
 *  lastIndexOf 返回在数组中可以找到一个给定元素的最后一个索引，如果不存在，则返回-1。

> 迭代方法

*  forEach

//forEach 不会改变原数组 返回undefined 不允许中途break
            let arr = [1,2,3,4,5];
            arr.forEach(function (val,index) { //如果有第三个参数，此参数为该数组
                console.log(val,index);
             })
    
             //
             Array.prototype.myForEach = function(func){
                for(let i = 0; i < this.length; i++){
                    func(this[i],i);
                    // return ;
                }
             }

*  every 判断数组的所有元素是否都满足条件(返回true/false)

var arr = [2,3,4,-1];
        var noZero = arr.every(function(val,index,arr){
            return val !== 0;
        })

*  some 判断数组中是否有元素满足条件（只要又一个满足就返回true）

var arr = [1,2,3,-1];
        var negative = arr.some(function(val,index,arr){
            return val < 0;
        })

*  filter 过滤器

// filter 筛选 返回新的数组
            var arr = [1,2,3,4,5];
            var newArr = arr.filter(function (val,index) { 
                return val >= 2;
             })
             console.log(newArr);
    
             Array.prototype.myFilter = function (func) { 
                 let len = this.length,
                    newArr = [];
                 for(let i = 0;i < len; i++){
                    if(func(this[i],i))
                        newArr.push(this[i]);
                 }
                 return newArr;
              }
              var myArr = arr.myFilter(function(val,index){
                    return val > 2;
              })
              console.log(myArr);

*  find 查找第一个满足条件的元素，返回元素本身，如果没有找到,返回undefined

*  findIndex 查找第一个满足条件的元素，返回元素下标，如果没有找到，返回-1

*  map 映射

//map返回在原数组基础上修改后的数组
            var arr = [1,2,3,4,5];
            var newArr = arr.map(function (val,index) { 
                return val*2;
             })
            console.log(newArr);
    
            Array.prototype.myMap = function (func) { 
                let len = this.length,
                    newArr = [];
                    for(let i = 0; i < len; i++){
                        newArr.push(func(this[i],i));//这里需要deepclone！！！！
                    }
                return newArr;
             }
             var myArr = arr.myMap(function(val, index){
                 return val*2;
             })
             console.log(myArr);

*  reduce 对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

//reduce 从左向右迭代整个数组  做累加器    只会返回最后一个值
            var arr = [1,2,3,4,5];
            arr.reduce(function (preValue, val, index) { //preVal 上一次执行函数return 的值 
                console.log(preValue);
                console.log(index+":"+val);
                return val;
             })//初始值，在第一次执行函数时preVal的值,如果不传默认值，preValue会从数组的第一位开始，val从第二位开始
    
             var sum = arr.reduce(function (preVal, val, index) { 
                 return preVal + val;
              })
              console.log(sum);
    
              Array.prototype.myReduce = function(func,init){
                var preVal = init,k = 0;
                if(init === undefined){
                    preVal = this[0];
                    k = 1;
                }
                for(k; k < this.length;k++){
                    preVal = func(preVal,this[k],k);
                }
                return preVal;
              }
              var mySum = arr.myReduce(function(preVal, val, index){
                  return preVal + val;
              });
              console.log(mySum);

*  reduceRight 接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。