es6数组总结

最新推荐文章于 2020-12-27 20:11:57 发布

子非鱼@ma

最新推荐文章于 2020-12-27 20:11:57 发布

阅读量172

点赞数

文章标签： javascript数组

本文链接：https://blog.csdn.net/qq_35410309/article/details/89298347

版权

数组

定义
- 数组是值得有序集合,每个值叫做元素,每个元素有个固定的位置,叫做索引
- 数组继承自Array.prototype中的属性,数组的方法
创建数组
- var a = new Array(10) 限制长度10
- 数组是特定的对象, 索引类似特殊的属性名
- 查找的时候不存在就是undefine 类似对象
- 数组是对象,就可以在原型中找元素
数组元素的读和写
稀疏数组 length属性长度大于元素的个数
- js中很少稀疏数组,和平常数组一样对待,只是会多几个undefine
数组长度
- 每个数组都有一个length属性
- 数组的length属性值设置为大于当前的长度,实际不会向数组中添加新的元素,只是在数组末尾创建一个空的区域
数组元素的添加和删除
- 添加
- 删除 delete 不会修改数组的length属性

数组的遍历(for)

for

 ```js
     var keys = Object.key(o) //获取o对象属性名组成的数组
     var values = [];
     for(var i=0;i<keys.length;i++){
         var key =keys[i];   //获得索引处的键值
       values[i] = o[key] //在values数组中保存属性值
     }
 
 ```

for in

   for(var i in a) {
     if(!a.hasOwnProperty(i) continue)  //跳过继承的属性
   }

forEach

```js
    var data =[1,2,3,4,5]   //这是需要遍历的数组
    var sumSq = 0           //要得到数据的平方和
    data.forEach(function(x)){
        sumSq +=x*x        //平法相加
    }
    sumSq                   //55:1+4+9+16+25
    
```

多维数组

js不支持多维数组,可以用数组的数组来近视

   //表格有10行
   var table = new Array(10);   
   for(var i = 0;i<table.length;i++)
          table[i] = new Array(10) //每行有10列
   //初始化数组
   for (var row = 0;row<table.length;row++){
        for(var col=0; col<table[row].lenth;col++){
            table[row][col] = row*col
        }
   }
   //使用多维的数来计算 (查询)  5*7
   var product = table[5][7]   //35

数组的方法

join() 将数组中的所有元素转化成字符串并连接在一起

Array.join()是String.split()方法的逆向操作,后者是将字符串分成若干块来创建一个数组

    var a = [1,2,3];
    a.join();    //"1,2,3"
    a.join(' ');   //"1 2 3"
    var b = new Array(10)
    b.join('-')    //'---------' 9个连子号组成的字符串

reverse() 数组中的元素跌倒顺序,返回逆序的数组

    var a = [1,2,3]
    a.reverse()     //a数组变成[3,2,1]

sort() 将数组中的元素排序并返回排序后的数组
-数组包含undefine元素,它们会被排放到数组的尾部

    var a = new Array('banner','cherry','apple')
    a.sort();   //字母排序
    var s = a.join(',')     //s ='apple,banner,cherry'

其他方式,非字母排序,里面可以传一个比较函数

    var a = [33,4,111,2222]
    a.sort();   // 字母表顺序 111,2222,33,4
    a.sort(function(a,b){  //从小到大   负数 0 正数
        return a-b
    })
    a.sort(function(a,b){
        return b-a      //从大到小
    })

//区分大小写
a = ['aut','Bug','cat','Dog']
a.sort()    //区分大小写  ['Bug','Dog','aut','cat']
//不去分大小写
a.sort(function(s,t){
    var a = s.toLowercase();
    var b = t.toLowerCase();
    if(a<b) return -1;
    if(a>b) return 1;
    return 0;
})  //=>['aut','Bug','cat','DOg']

concat() 创建并返回一个新的数组,它的元素包括调用的concat()的原始数组的元素和concat的每个参数

var a = [1,2,3]
a.concat(4,5)   //返回[1,2,3,4,5]
a.concat([4,5]) //返回[1,2,3,4,5]
a.concat([4,5],[6,7])   //返回[1,2,3,4,5,6,7]
a.concat(4,[5,[6,7]])   //返回[1,2,3,4,5,[6,7]

slice(start,end) 方法返回指定数组的一个片段或者子数组.不包含end位置的元素,不会改变原来的数组
- 只有一个参数,参数位置开始到改数组结束
- -1指定了最后一个元素 -3指定倒数第三个元素

splice(位置,个数,插入的元素一,插入的元素二,) 数组中插入和删除元素的通用方法改变原来的数组返回的是一个删除后的新数组

删除

var a = [1,2,3,4,5,6,7,8]
a.splice(4);    //返回[5,6,7,8]  第二个参数省略 表示到结尾
a.splice(1,2)   //返回[2,3]    a是[1,4]
a.splice(1,1)   //返回[4]    删除指定的元素

添加前两个参数指定删除数组元素.后面指点插入的元素,第一个参数指定的位置开始插入

var a = [1,2,3,4,5]
a.splice(2,0,'a','b')  //返回[]  a是[1,2,'a','b',3,4,5]
a.splice(2,2,[1,2],3)  //返回['a','b']  a是[1,2,[1,2],3,3,4,5]

push()和pop() push末尾添加 pop末尾删除
unshift()和shift() unshift首位置添加 shift首位置删除

toString() 将每个元素转化为字符串并且用逗号分隔

[1,2,3].toString()   //'1,2,3'
["a","b","c"].toString()    //'a,b,c'
[1,[2,'c']].toString()      //'1,2,c'

toLocaleString() 是toString()的本地化版本,调用该方法将每个数组元素转化为字符串,并且使用本地化的分隔符连接起来

ECMAScript5方法

概要: 参数:函数(数组元素,数组索引,数组本身)

forEach() 从头到尾遍历数组,每个元素指定调用的函数

var data = [1,2,3,4,5]  //要求和的数组
var sum = 0 //计算数组和的值
data.forEach(function(value){
   sum+=value  //将每个值累加到sum上
})
sum //15

var data = [1,2,3,4,5]  //要求和的数组
//每个元素加一
data.forEach(function(v,i,a){
    a[i]=v+i
})
data    //[2,3,4,5,6]

forEach 无法在所有元素遍历完终止无法使用break中只可以放到一个try快中,抛出异常,若forEach() 调用的函数抛出forEach.break异常,循环会提前终止

 function forEach(a,f,t){
    try {a.forEach(f,t);}   //尝试执行的代码块
    catch(e){
        if(e===foreach.break)  return;  //捕获错误的代码块
        else throw e;   //
    }
}
foreach.break = new Error('StopIteration')

map() 将调用的数组的每个元素传递给指定的函数,并返回一个数组,它包含该函数的返回值
- map返回的是一个新数组,不修改调用的数组
```
     a = [1,2,3]
     b = a.map(function(x){retrun x*x})  //b是[1,4,9] a是[1,2,3]
```

filter() 返回的数组元素是调用的数组的一个子元素.传递的函数用来逻辑判断.

    a = [5,4,3,2,1]
    smallvalue = a.filter(function(x){return x<3})  //[2,1]
    everyother = a.filter(function(x,i){return i%2==0})   //索引和2取余0 [5,3,1]

every() 当且仅当针对数组中的所有元素调用判定函数都返回true,他它才返回true

    a = [1,2,3,4]
    a.every(function(x){return x<10})   //true 所有的值<10
    a.every(function(x){return x%2==0}) //false 不是所有的值都是偶数

some() 数组中至少有一个元素调用判定返回true,它就返回true

    a =[1,2,3,4]
    a.some(function(x){return x%2===0}) //true a含有偶数值
    a.some(isNaN)   //false:a不包含非数值元素

reduce() 使用指定的函数将数组元素进行组合,生成单个值

第二参数,初始化该数组,并参数第一次运算,下面的例可以省略

    var a = [1,2,3,4,5]
    var sum = a.reduce(function(x,y){retrun x+y},0)  //数组求和
    var pro = a.reduce(function(x,y){retrun x*y},1)  //数组求积

reduceRight() 参考上面,只是从右面开始处理数组

indexof() 搜索整个数组中具有给定指定的元素,返回找到第一个元素的索引或者没有找到返回-1

参数一:要查找的元素
参数二:从哪个位置开始查找

    //在数组中查找所有出现的x,并且返回一个包含匹配索引的数组
    function findall (a,x){
        var res = []    //将会返回的数组
        len = a.length  //待搜索数组的长度
        pos = 0     //开始搜索的位置
        while(pos<len){ //循环搜索多个元素
            pos = a.indexof(x,pos); //搜索
            if(pos ===-1) break;    //未找到完成搜索
            result.push(pos);   //否则 在数组中存储索引
            pos++   //并从下一个索引开始索引
            
            
        }
        return res  //返回包含索引的数组
    }

lastIndexof() 从数组的右面开始查找和indexof用法一样

数组的类型
- 判断是否是数组的方法:Object.prototype.toString()
- 类数组对象
- 作为数组的字符串
- 注意字符串是不可以变的值,把他们当字符串看待的时候,它们是只读的
```js
```
        s = 'javascript'
        Array.prototype.join.call(s,'') //j a v a S c r i p t
        
  ```
```

子非鱼@ma

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
es6数组总结

数组定义数组是值得有序集合,每个值叫做元素,每个元素有个固定的位置,叫做索引数组继承自Array.prototype中的属性,数组的方法创建数组var a = new Array(10) 限制长度10数组是特定的对象, 索引类似特殊的属性名查找的时候不存在就是undefine 类似对象数组是对象,就可以在原型中找元素数组元素的读和写稀疏数组 ...
复制链接

扫一扫