node.js-数组

创建

构造

  • 对象

直接创建

var arr = new Array() // 作为对象创建

可以省略new

var arr = Array()     // 作为方法执行

省略括号

var arr = new Array   // 作为对象创建
  • 参数

无参

var arr = new Array() // 长度0, 无内容

定长

var arr = new Array(3) // 初始容量为3的数组 

元素

var arr = new Array('a', 'b', 'c') //['a', 'b', 'c'], 直接按照元素构造

类型

var arr = new Array('string', false, 3) // 类型不要求单一

如果是int的元素,必须至少两个,否则会认为是长度声明

字面

  • 空参
var arr = []
  • 元素
var arr = [3, 4, 5] //没有长度声明,内部都是元素

检查

  • typeof
var arr = []
typeof arr // object

类型没有array,显示的是object, 不能通过类型判断是否是数组。

  • instanceof
var arr = []
arr instanceof Array // true

判断是否是Array类型

  • Arrays.isArray
var arr = []
Array.isArray(arr) // true

静态方法判断是否是Array

转换

  • Object
var obj = {a:1,b:2,c:3}
var arr = Object.keys(obj)  // [ 'a', 'b', 'c' ]
arr.length                  // 3
Object.values(obj)          // [ 1, 2, 3 ]

keys:属性名称列表

values:属性数值列表

  • String
var s = 'string';
var arr = s.split(''); // [ 's', 't', 'r', 'i', 'n', 'g' ]

split:分割字符串为数组,支持单字符和字符串。

  • 2String
var arr = 'array'.split(''); // [ 'a', 'r', 'r', 'a', 'y' ]

toString

arr.toString(); // 'a,r,r,a,y'

元素之间用逗号进行分隔

join

arr.join();    // 'a,r,r,a,y'
arr.join('-'); // 'a-r-r-a-y'
arr.join('');  // 'array'

可以指定元素间拼接字符,无参时同toString

排序

var arr = [11,2,333,44,5]; // [ 11, 2, 333, 44, 5 ]
  • sort
  • 字符串排序
arr.sort(); //[ 11, 2, 333, 44, 5 ]

默认是字符串排序

  • 排序办法
arr.sort(function(a,b){
    return a - b;
});    //  [ 2, 5, 11, 44, 333 ]
arr.sort(function(a,b){
    return b - a;
});   //   [ 333, 44, 11, 5, 2 ]

传入匿名函数可以指定排序规则

  • reverse
arr.reverse(); // [ 5, 44, 333, 2, 11 ]

没有其他作用,简单的就是把原来的字符串进行反转。

arr.reverse(); // [ 11, 2, 333, 44, 5 ]

除了反转没啥,如果是升序队列,反转就成了降序,但是本身无排序操作,只是简单的反转。

  • 拷贝

排序方法并非是substring的操作结果返回,这种排序会从根源让数组顺序发生改变。

  • 简单引用
var arr = [11,2,333,44,5];
var arr2 = arr; 
arr.reverse();  //  [ 5, 44, 333, 2, 11 ]
arr2            //  [ 5, 44, 333, 2, 11 ]

如果不想扰乱原本数组的顺序的话,就必须要进行拷贝操作。

  • 复制
var arr = [11,2,333,44,5]var arr2 = [...arr]
arr.reverse();    //  [ 5, 44, 333, 2, 11 ]
arr2              //  [ 11, 2, 333, 44, 5 ]

[...arr],相当于python中的*args**kwargs的遍历枚举方式;

  • 切片
var arr = [11,2,333,44,5]var arr2 = arr.slice()
arr.reverse();    //  [ 5, 44, 333, 2, 11 ]
arr2              //  [ 11, 2, 333, 44, 5 ]

slice,和String中的slice一致,从指定位置截取到指定结束。

单参数:从指定位置截取到末尾

双参数:从起始位置截取到结束位置

无参 : 从头截取到尾,相当于元素复制

一般的对象引用被称为浅拷贝,只是对象的引用,引用实体是单一的。

元素复制为深拷贝,实体为新建对象,只是元素和位置一致,实体为复数。

栈和队列

  • stack
  • push
var arr = [];
arr.push(3);  // 1
arr.push(4);  // 2
arr           // [3, 4]

returnpush的返回值是栈的长度

入口push的入口是从末尾开始

  • pop
var arr = [7,8,9];
arr.pop()  // 9
arr.pop()  // 8
arr.pop()  // 7

return:返回栈顶的元素

出口pop的出后是末尾,同push

  • queue
  • push

stack方式的push,从末尾插入,返回队列长度

  • shift
var arr = [7,8,9];
arr.shift()  // 7
arr.shift()  // 8
arr.shift()  // 9

pop的弹出方式,但是方向不同,从头开始弹出

相较于stack的单向,queue具有双向。

  • unshift
var arr = [];
arr.unshift(7); // 1
arr.unshift(8); // 2
arr.unshift(9); // 3
arr             // [ 9, 8, 7 ]

return:返回队列长度

action:把指定元素压入队列

direction:方向和push相反,和shift相同,从头开始插入

  • 插入
var arr = [];
arr.push([9, 99])
arr.push(...[8, 88])
arr.push(7, 77)
arr // [ [ 9, 99 ], 8, 88, 7, 77 ]
  • 元素

Array不要求类型统一,因此直接插入[]时当做对象进行插入。

如果想要插入数组内部数据时,需要...[]进行数据的遍历枚举。

同时,push()中可以传入多个需要插入的元素,可以一次性进行多个元素的插入。

  • 顺序

集体顺序按照方法的一般顺序进行插入。

部分范围内按照插入时的枚举顺序进行排列

  • 其他

pushunshift都遵循上述规律。

其他

  • concat
var a = [1];
var b = [2];
var c = a.concat(b);  // [ 1, 2 ]
var d = b.concat(a);  // [ 2, 1 ]
a  // [1]
b  // [2]
var e = a.concat(9, 5);
e   // [ 1, 9, 5 ]
  1. 数组元素拼接,返回元素拼接新数组
  2. 数组自身不变化
  3. 新数组顺序看调用顺序
  4. 可当push使用,直接拼接元素
  • slice
var arr = [1,2,3];
arr.slice()   // [ 1, 2, 3 ]
arr.slice(0)  // [ 1, 2, 3 ]
arr.slice(1)  // [ 2, 3 ]
arr.slice(-2) // [ 2, 3 ]
arr.slice(0,1)// [ 1 ]
  • 双参:从start截取到end,包头不包尾
  • 单参:从index截取到最后
  • 无参:从头到尾
  • 负数:支持倒数索引
  • splice
  • 删除(用空序列替换指定序列)
var arr = [1,2,3]
arr.splice(0,1)  // [ 1 ]
arr              // [2, 3]
  • start:第一个参数指定序列起始位置
  • length:第二个参数指定序列长度
  • sequence:之后的作为序列准备替换,空序列替换表现为删除
  • return:返回值为前两个参数指定的旧序列
  • 插入(用指定序列替换空序列)
var arr = [1,2,3]
arr.splice(1,0,88,99)  // []
arr                    // [ 1, 88, 99, 2, 3 ]   
  • 指定length0,无替换,相当于指定位置插入
  • seqence插入
  • 替换(用新序列替换指定序列)
var arr = [1,2,3]
arr.splice(1,1,9)  // [ 2 ]
arr                // [ 1, 9, 3 ]

所言不虚

  • index
  • indexOf
var arr = [1,1,1]
arr.indexOf(1) // 0
  • lastIndexOf
var arr = [1,1,1]
arr.lastIndexOf(1)  // 2

单检索,首或尾

  • each
  • every
var arr = [1,2,3]
arr.every(function(a){
    return a > 0;
})   // true
arr.every(function(a){
    return a > 1;
})  // false

检查是否所有元素都满足同一个条件,同python中的all

  • some
var arr = [1,2,3]
arr.some(function(a){
    return a > 2;
})   // true
arr.some(function(a){
    return a > 3;
})   // false

部分满足即可,同python中的any

  • forEach
var arr = [1,2,3]
arr.forEach(function(a){
    console.log(a);
})

无返回值,只是遍历执行数据操作

  • filter
var arr = [1,2,3]
var result = arr.filter(function(a){
    return a > 2;
})  // [ 3 ]

把满足条件的元素筛选出来

  • map
var arr = [7,8,9]
var result = arr.map(function(a){
    return a - 2; // 每个人扣两块钱班费
})  //[5, 6, 7] 

对每个元素都进行操作,并组织结果返回,原数组不变

  • reduce
  • reduce
var arr = [7,8,9]
var sum = arr.reduce(function(a,b){
    return a + b;
})  // 24 = 7 + 8 + 9

依次进行计算

参数详细

var arr = [7,8,9];
var sum = arr.reduce(function(previous, current, index, array){
    console.log('上一个元素是:',previous);
    console.log('当前元素是:', current);
    console.log('当前元素的索引为: ', index);
    console.log('数据的原集为: ',array);
    console.log("==========================")
    return previous + current;
});
  • prvious:上一个元素
  • current:当前元素
  • index:当前索引
  • array:总数据集
  • reduceRight
var arr = [7,8,9];
var sum = arr.reduceRight(function(previous, current, index, array){
    console.log('上一个元素是:',previous);
    console.log('当前元素是:', current);
    console.log('当前元素的索引为: ', index);
    console.log('数据的原集为: ',array);
    console.log("==========================")
    return previous + current;
});

看索引就知道,reduce从头到尾计算,rediceRight计算方向相反。

如果顺序对结果没有影响的话,两者计算结果都是相同的。

相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页