类
类
class
是面向对象编程思想的实现方式。
类的语法
定义类
使用 class
关键字可以定义一个类。
/**
* 创建类
*/
class Person {
//类的共有成员变量
name
//类的私有成员变量
#age
/**
* 类的构造方法。
*/
constructor(name, age) {
this.name = name; // 实例属性
this.#age = age; // 实例属性
}
/**
* 类的成员方法
*/
getName() {
return this.name;
}
/**
* 类的成员方法
*/
setName(newName) {
this.name = newName;
}
}
类的使用
可以使用 new 关键字来创建类的实例。
const person1 = new Person('张三', 30);
console.log(person1);
继承
类可以通过 extends 关键字来继承另一个类。
/**
* Student 继承自 Person 类。
*/
class Student extends Person {
//子类的成员变量
major
//初始化一个默认值
phone = "无"
/**
* 子类的构造方法
*/
constructor(name, age, major) {
super(name, age); // 调用父类的构造函数
this.major = major; // 学生的专业
}
/**
* toJSON用于自定义类实例的json序列化
*/
toJSON() {
return {
name: this.name,
age: this.#age,
major: this.major,
phone: this.phone
}
}
}
总结
- 使用
class
关键字可以定义类。 constructor
方法是一个特殊的方法,它是类的构造方法,用于创建和初始化类对象。- 类的成员方法可以使用普通的函数语法定义,不需要 function 关键字。
extends
关键字用于创建一个子类,该子类继承了父类的所有方法和属性。- 在类的成员方法或成员变量前面加上
#
,表示是一个私有成员。 - 可以使用
=
给类成员变量初始化默认值。 - 可以为成员变量创建
getter
方法,它会在JSON.stringify
方法执行时会被调用。 - 可以为类创建
toJSON
方法,它会在JSON.stringify
方法执行时会被调用。
内置类
vino
提供了以下几个内置类
名称 | 类型 | 说明 |
---|---|---|
Buffer | 类 | 字节数组 |
BufferReader | 类 | 带缓存的Buffer输入流 |
Date | 类 | 日期类 |
ThreadPool | 类 | 线程池类 |
Map | 类 | Map集合类 |
Set | 类 | Set集合类 |
Cache | 类 | 缓存类 |
RegExp | 类 | 正则表达式 |
Buffer
Buffer表示一个内存缓冲区,底层是一个可变长度的字节数组。buffer
对象实现了Reader
和Writer
接口,即可以作为字节数组使用,也具备输入\输出流的特性。
//创建一个初始长度为0个字节的buffer
let buffer = new Buffer();
//创建一个初始长度为10个字节的buffer
let buffer = new Buffer(10);
属性与方法
名称 | 类型 | 参数 | 返回值 | 说明 |
---|---|---|---|---|
size | 方法 | int | 获取buffer的字节大小 | |
reset | 方法 | void | 清空buffer内容 | |
writeByte | 方法 | value:int[],offset?:int | void | 写入字节数组到Buffer的末尾或指定位置 |
toString | 方法 | encoding?:string | string | 将buffer转为字符串,默认使用UTF-8编码 |
toByteString | 方法 | string | 返回字节表示的字符串,主要用于调试 |
size
获取Buffer的字节大小
let buf = new Buffer();
console.log(buf.size());
reset
reset()
方法用于清空Buffer中的内容。
示例
let buffer = new Buffer();
buffer.write("abc");
buffer.reset();
writeByte
writeByte()
写入字节数组到Buffer的末尾或指定位置。
重要说明
vino
中并没有byte
类型,所以这里的字节数组其实就是int
数组。- 由于字节的取值范围是0-255的整数,所以传入的
int
数组中元素的值必须是0-255之间的整数。 - 如果传入的
int
值不是0-255范围内的整数,程序并不会抛异常,但存入的数据会产生非预期的结果。请查看错误数据处理方式 - 如果传入的数据类型不是
int
,则会抛出异常。
示例1
let buffer = new Buffer();
//取值范围0-255
buffer.writeByte([0xff, 0xff]);
//结果[255 255]
console.log(buffer.toByteString())
示例2
let buffer = new Buffer(5);
//写入buffer中下标为2的位置
buffer.writeByte([0x01, 0x02], 2);
//结果:[0 0 1 2 0]
console.log(buffer.toByteString())
示例3
当写入的位置超过了buffer的长度时,会抛异常
let buffer = new Buffer();
//写入buffer中下标为2的位置,这里会抛异常
buffer.writeByte([0x01, 0x02], 2);
console.log(buffer.toByteString())
错误数据处理方式
当尝试将不在0-255之间的整数(即非字节)写入buffer时,vino
会尝试将其转为一个字节(即无符号8位整数),转换规则如下:
- 负数: 当传入负数时,由于
无符号8位整数
是一个无符号类型,负数会首先被转换为对应的无符号整数。在vino
中,整数类型使用二进制补码表示,因此负数的无符号表示实际上是它的二进制补码形式。转换结果是这个无符号整数对字节最大值(255)加1后的值取模的结果。
例如,-1在内存中通常表示为所有位都是1(对于8位来说就是0xFF),所以-1转换为字节时结果是255。
let buffer = new Buffer();
buffer.writeByte([-1]);
//结果:[255]
console.log(buffer.toByteString())
- 浮点数: 当传入浮点数时会首先被舍入到最接近的整数,然后这个整数会被转换为
无符号8位整数
。如果浮点数的整数部分超出了范围(0-255),则会发生溢出,并舍弃小数部分,结果是这个整数对256取模的值。
例如,345.67会首先被舍弃小数为345,然后由于345超出了byte的范围,所以结果是345 % 256 = 89
let buffer = new Buffer();
buffer.writeByte([345.67]);
//结果:[89]
console.log(buffer.toByteString())
- 非数字: 当传入的类型不是
int
或float
时,会抛异常。
toString
toString()
方法用于将buffer转换为字符串。默认使用utf8编码
示例
let buffer = new Buffer();
buffer.write("abc");
console.log(buffer.toString());
可以通过一个可选参数来指定编码方式:
let buffer = new Buffer();
buffer.write("你好中国", "gbk");
console.log(buffer.toString("gbk"));
- 支持的可选编码方式(不区分大小写)
utf8
gbk
gb1312
gb18030
base64
hex
16进制字符串
toByteString
toByteString()
返回一个用uint8表示的字节数组的字符串表示形式,主要用于调试
let buffer = new Buffer();
buffer.write("abc");
console.log(buffer.toByteString());
//打印结果:[97 98 99]
案例
- 写文件
将buffer输出到文件对象中。
数据流向: 内存(buffer) -> 硬盘(file)
import {fs} from 'core';
let buffer = new Buffer();
buffer.write("abc");
let file = fs.openFile("/Users/xx/Desktop/xx.txt", "readWrite");
file.write(buffer);
file.close();
- 读文件
将文件内容输入到buffer中.
数据流向: 硬盘(file) -> 内存(buffer)
import {fs} from 'core';
let file = fs.openFile("/Users/xx/Desktop/xx.txt", "readWrite");
//读取文件内所有数据到buffer
let buffer = file.read();
file.close();
BufferReader
属性与方法
BufferReader实现了Reader
接口
名称 | 类型 | 参数 | 返回值 | 说明 |
---|---|---|---|---|
readString | 方法 | delim?:string | string | 从reader中读取文本字符 |
readChar | 方法 | void | string | 从reader中读取一个字符 |
readString
readString
从reader
中读取数据,直到遇到指定的分隔符delim
,然后返回一个字符串,这个字符串包含从当前位置到(并包括)分隔符的所有数据。如果在找到分隔符之前遇到错误(包括文件结束EOF),则返回已读取的数据或undefiend
。这使得ReadString
成为处理文本数据的强大工具,特别是当你需要按行(使用换行符作为分隔符)读取数据时。
示例1
import {fs} from "core"
//打开文件
let file = fs.open("./test.txt")
let bufReader = new BufferReader(file);
//读取文件内所有数据
let line1 = bufReader.readString();
示例2
import {fs} from "core"
//打开文件
let file = fs.open("./test.txt")
let bufReader = new BufferReader(file);
//读取第一行数据
let line1 = bufReader.readString("\n");
//读取第二行数据
let line2 = bufReader.readString("\n");
readChar
readChar
从reader
每次读取一个字符。
let bufReader = new BufferReader(reader:Reader);
//第一个字符
let char = bufReader.readChar();
Date
Date
表示一个日期。
创建当前时间的对象
let date = new Date();
创建指定日期的对象
// 指定时间和格式化方式
let date = new Date('2024-04-05 06:07:08', 'yyyy-MM-dd HH:mm:ss');
console.log(date); // 输出:[object date]2024-04-05 06:07:08
// 指定Unix时间戳
let date2 = new Date(1712268428);
console.log(date2); // 输出:[object date]2024-04-05 06:07:08
// 指定Unix时间戳(毫秒级)
let date3 = new Date(1712268428000);
console.log(date3); // 输出:[object date]2024-04-05 06:07:08
属性与方法
名称 | 类型 | 参数 | 返回值 | 说明 |
---|---|---|---|---|
format | 方法 | format:string | string | 用于进行日期格式化 |
getFullYear | 方法 | int | 获取日期的年份 | |
getMonth | 方法 | int | 获取日期的月份 | |
getDate | 方法 | int | 获取日期是当月的几号 | |
getDay | 方法 | int | 获取星期中的第几天 | |
getHours | 方法 | int | 获取小时数 | |
getMinutes | 方法 | int | 获取分钟数 | |
getSeconds | 方法 | int | 获取秒数 | |
getMilliseconds | 方法 | int | 获取毫秒数 | |
getTime | 方法 | int | 获取Unix时间戳 | |
add | 方法 | time:int,unit:string | Date | 时间计算 |
getAgo | 方法 | string | 返回相对时间 | |
after | 方法 | date:Date | boolean | 当前时间是否在给定时间之后 |
before | 方法 | date:Date | boolean | 当前时间是否在给定时间之前 |
format
format()
方法用于进行日期格式化。返回格式化后的日期字符串。
语法
date.format(format);
- format:日期格式字符串
符号 | 描述 |
---|---|
G | 纪元,表示公元前或公元后,例如:BC(公元前),AD(公元后) |
C | 世纪,表示当前纪元的世纪部分,例如:20(表示20世纪) |
Y | 周年,表示按照ISO-8601标准的周年份,例如:1996(ISO-8601标准的周年)。 |
w | 周年中的第几周,表示当前年份的第几周,例如:27(表示一年中的第27周) |
e | 星期几(数字表示),星期的数字表示,0-6表示星期日到星期六。 |
E | 星期几(文本表示),表示当前日期是星期几,例如:周二,星期二 |
y | 年,表示实际的公历年份,例如:1996(表示公历年份1996年) |
D | 一年中的第几天,表示当前日期是当前年份的第几天,例如:189(表示一年中的第189天) |
M | 一年中的月份,表示当前日期是当前年份的第几月,例如:7月; 七月; 07 |
d | 一月中的第几天,表示当前日期是当前月份的第几天,例如:10(表示一个月中的第10天) |
a | 上下午,表示当前时间是上午还是下午 |
K | 半天中的小时,表示当前时间是上午或下午的第几小时(0到11),例如:0(表示半天中的第0小时) |
k | 一天中的钟点,表示当前时间是一天中的第几钟点(1到24),例如:24(表示一天中的第24小时) |
H | 一天中的小时,表示当前时间是一天中的第几小时(0到23),例如:0(表示一天中的第0小时) |
h | 半天中的钟点,表示当前时间是上午或下午的第几钟点(1到12),例如:12(表示半天中的第12小时) |
m | 小时中的分钟,表示当前时间是一个小时中的第几分钟,例如:30(表示一个小时中的第30分钟) |
s | 分钟中的秒,表示当前时间是一分钟中的第几秒,例如:55(表示一分钟中的第55秒) |
S | 秒的小数部分,表示当前时间的毫秒数,例如:978(表示秒的小数部分,毫秒) |
z | 时区,表示当前时间的时区,例如:Pacific Standard Time; PST(表示时区) |
Z | 时区偏移/标识符,表示当前时间的时区偏移或标识符,例如:-0800; -08:00; America/Los_Angeles(表示时区偏移或标识符) |
示例
let date = new Date("2024-07-23 18:47:21.789", "yyyy-MM-dd HH:mm:ss.SSS");
console.log(date.format("G"))//打印:AD
console.log(date.format("C"))//打印:20
console.log(date.format("YY"))//打印:24
console.log(date.format("YYYY"))//打印:2024
console.log(date.format("w"))//打印:30,如果周数小于10则不补0,例如:6
console.log(date.format("ww"))//打印:30,如果周数小于10则前面补0,例如:06
console.log(date.format("e"))//打印:2
console.log(date.format("ee"))//打印:02
console.log(date.format("EE"))//打印:周二
console.log(date.format("EEE"))//打印:星期二
console.log(date.format("yy"))//打印:24
console.log(date.format("yyyy"))//打印:2024
console.log(date.format("D"))//打印:205,如果小于10则前面不补0,最终输出1位数
console.log(date.format("DD"))//打印:205,如果小于10则前面补0,最终输出2位数
console.log(date.format("M"))//打印:7
console.log(date.format("MM"))//打印:07
console.log(date.format("d"))//打印:23
console.log(date.format("dd"))//打印:23
console.log(date.format("a"))//打印:下午
console.log(date.format("K"))//打印:6
console.log(date.format("KK"))//打印:06
console.log(date.format("k"))//打印:18
console.log(date.format("kk"))//打印:18
console.log(date.format("H"))//打印:18
console.log(date.format("HH"))//打印:18
console.log(date.format("h"))//打印:6
console.log(date.format("hh"))//打印:06
console.log(date.format("m"))//打印:47
console.log(date.format("mm"))//打印:47
console.log(date.format("s"))//打印:21
console.log(date.format("ss"))//打印:21
console.log(date.format("S"))//打印:7,百位
console.log(date.format("SS"))//打印:78,百位和十位
console.log(date.format("SSS"))//打印:789,全部
console.log(date.format("z"))//打印:CST
console.log(date.format("Z"))//打印:+0800
console.log(date.format("ZZ"))//打印:+08:00
getFullYear
getFullYear()
方法用于获取当前时间的日期的年份
语法
date.getFullYear();
示例
let date = new Date();
console.log(date.getFullYear());
getMonth
getMonth()
方法用于获取当前时间的日期的月份
语法
date.getMonth();
示例
let date = new Date();
console.log(date.getMonth());
getDate
getDate()
方法用于获取当前时间的日期是当月的几号
语法
date.getDate();
示例
let date = new Date();
console.log(date.getDate());
getDay
getDay()
方法用于获取当前时间的星期中的第几天,返回一个介于0到6之间的整数,其中0代表星期日,1代表星期一,依此类推,直到6代表星期六。
语法
date.getDay();
示例
let date = new Date();
console.log(date.getDay());
getHours
getHours()
方法用于获取当前时间的小时数。
语法
date.getHours();
示例
let date = new Date();
console.log(date.getHours());
getMinutes
getMinutes()
方法用于获取当前时间的分钟数
语法
date.getMinutes();
示例
let date = new Date();
console.log(date.getMinutes());
getSeconds
getSeconds()
方法用于获取当前时间的秒数
语法
date.getSeconds();
示例
let date = new Date();
console.log(date.getSeconds());
getMilliseconds
getMilliseconds()
方法用于获取当前时间的毫秒部分,返回值范围是 0 到 999,表示当前时间的毫秒数。
语法
date.getMilliseconds();
示例
let date = new Date();
console.log(date.getMilliseconds());
getTime
getTime()
方法用于获取当前时间的Unix毫秒数时间戳。
语法
date.getTime();
示例
let date = new Date();
console.log(date.getTime());
add
add()
方法用于时间计算。
语法
date.add(time, unit);
time
:时间值,做减法运算时,传负值unit
:时间单位,可选值:year
、month
、day
、hour
、minute
、second
、millisecond
。
示例
let data = new Date();
console.log(data); // 输出: [object date]2024-06-28 17:05:05
// 将时间往后推10天,再往前推1小时,再往前推15秒
let newDate = data.add(10, 'day').add(-1, 'hour').add(-15, "second");
console.log(data); // 输出: [object date]2024-06-28 17:05:05
console.log(newDate); // 输出: [object date]2024-07-08 16:04:50
getAgo
getAgo()
方法返回相对时间字符串,格式为:刚刚、几分钟前、几小时前、几天前、几月前、几年前
语法
date.getAgo();
示例
let date = new Date("2024-07-23 10:10:10", "yyyy-MM-dd HH:mm:ss");
//打印:12小时前。具体时间以执行时为准
console.log(date.getAgo());
after
after()
当前时间对象是否在给定时间对象之后
语法
date.after(date:Date);
参数
- date 给定日期对象
示例
let date1 = new Date("2024-07-23 10:10:10", "yyyy-MM-dd HH:mm:ss");
let date2 = new Date("2024-07-22 10:10:10", "yyyy-MM-dd HH:mm:ss");
//打印:true
console.log(date1.after(date2));
before
before()
当前时间对象是否在给定时间对象之前
语法
date.before(date:Date);
参数
- date 给定日期对象
示例
let date1 = new Date("2024-07-23 10:10:10", "yyyy-MM-dd HH:mm:ss");
let date2 = new Date("2024-07-22 10:10:10", "yyyy-MM-dd HH:mm:ss");
//打印:false
console.log(date1.before(date2));
ThreadPool
ThreadPool
是一个线程池类。
示例
//创建一个线程池,该线程池的最大工作线程是5,等待队列最大10
let pool = new ThreadPool(5, 10)
function a() {
console.log("test")
}
//将函数a放入线程池中
pool.submit(a)
//等待所有线程执行结束
pool.stopAndWait()
构造函数
用来实例化一个ThreadPool对象
语法
new ThreadPool(maxWorkers:int, maxCapacity:int,error?:(e:Error,f:Function,args:...any[])=>{})
参数
- maxWorkers:int 线程池中的最大工作线程数
- maxCapacity:int 线程池中等待队列容量
- error: (可选) 错误处理回调函数,当线程执行报错时,会调用该函数
- e: 错误Error对象
- f: 线程池调用的函数对象
- args: submit时传递的参数
示例
let pool = new ThreadPool(5, 100, (e, f, i) => {
//e:new Error("抛出了错误")
//f: work
//i: 200
console.log("执行失败:", e, f, i)
})
//工作函数
function work(i) {
console.log(i)
throw new Error("抛出了错误")
}
//将函数放入线程池
pool.submit(work, 200)
sleep()
对象属性与方法
名称 | 类型 | 参数 | 返回值 | 说明 |
---|---|---|---|---|
submit | 方法 | task:()=>void,...args:any[] | void | 添加一个任务函数到线程池 |
stop | 方法 | void | 停止接受新任务,并等待当前正在执行的任务结束,等待队列中的任务将不再执行 | |
stopAndWait | 方法 | void | 停止接受新任务,并等待当前正在执行的任务及等待队列中的任务全部执行结束 | |
stopAndWaitFor | 方法 | deadline:int | void | 类似stopAndWait,但可以设置一个最大等待时间,以防止无限期地等待。 |
runningWorkers | 方法 | int | 当前正在运行的线程数量 | |
idleWorkers | 方法 | int | 当前空闲的线程数量 | |
minWorkers | 方法 | int | 线程池中最小线程数 | |
maxWorkers | 方法 | int | 线程池中最大线程数 | |
maxCapacity | 方法 | int | 线程池中等待队列的容量 | |
submittedTasks | 方法 | int | 自线程池创建以来提交的任务总数 | |
waitingTasks | 方法 | int | 队列中当前等待执行的任务数 | |
successfulTasks | 方法 | int | 自池创建以来已成功完成执行的任务总数 | |
failedTasks | 方法 | int | 自池创建以来执行失败的任务总数 |
submit
从线程池中添加一个任务
语法
pool.submit(task:()=>void,...args:any[]);
参数
- task: 任务函数
- args: 给函数传递的参数
示例1
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
示例2
let pool = new ThreadPool(5, 10);
let i = 10;
//添加任务时传递一个参数
pool.submit((i) => {
//任务要执行的代码
}, i);
示例3
let pool = new ThreadPool(5, 10);
let i = 10;
let j = "abc";
//定义一个任务函数,该函数有2个形参
function task(a, b) {
console.log(a, b)
}
//将task函数加入线程池,并给它传递2个参数
pool.submit(task, i, j);
stop
停止接受新任务,并等待当前正在执行的任务结束,等待队列中的任务将不再执行
语法
pool.stop();
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
pool.stop();
stopAndWait
停止接受新任务,并等待当前正在执行的任务及等待队列中的任务全部执行结束
语法
pool.stopAndWait();
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
pool.stopAndWait();
stopAndWaitFor
类似stopAndWait
,但可以设置一个最大等待时间,以防止无限期地等待。
语法
pool.stopAndWaitFor(deadline:int)
参数
- deadline:int 最大等待时间,(单位:毫秒)
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
//等待1秒钟,如果还没有结束,则强制停止
pool.stopAndWaitFor(1000);
runningWorkers
当前正在运行的线程数量
语法
pool.runningWorkers();
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
let c = pool.runningWorkers();
console.log(c);
idleWorkers
当前空闲的线程数量
语法
pool.idleWorkers();
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
let c = pool.idleWorkers();
console.log(c);
minWorkers
线程池中最小线程数
语法
pool.minWorkers();
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
let c = pool.minWorkers();
console.log(c);
maxWorkers
线程池中最大线程数
语法
pool.maxWorkers();
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
let c = pool.maxWorkers();
console.log(c);
maxCapacity
线程池中等待队列的容量
语法
pool.maxCapacity();
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
let c = pool.maxCapacity();
console.log(c);
submittedTasks
自线程池创建以来提交的任务总数
语法
pool.submittedTasks();
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
let c = pool.submittedTasks();
console.log(c);
waitingTasks
队列中当前等待执行的任务数
语法
pool.waitingTasks();
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
let c = pool.waitingTasks();
console.log(c);
successfulTasks
自池创建以来已成功完成执行的任务总数
语法
pool.successfulTasks();
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
let c = pool.successfulTasks();
console.log(c);
failedTasks
自池创建以来执行失败的任务总数
语法
pool.failedTasks();
示例
let pool = new ThreadPool(5, 10);
pool.submit(() => {
//任务要执行的代码
});
let c = pool.failedTasks();
console.log(c);
Map
Map
是一种集合类型,提供了键值对的存储机制。
创建Map对象
let map = new Map();
map.set('a', 'alpha');
map.set('b', 'beta');
map.set('g', 'gamma');
for (let [key, value] of map) {
console.log(`key:${key}, value:${value}`);
}
// 输出:
// key:a, value:alpha
// key:b, value:beta
// key:g, value:gamma
属性与方法
名称 | 类型 | 参数 | 返回值 | 说明 |
---|---|---|---|---|
size | 属性 | - | int | 返回Map对象中元素的数量 |
set | 方法 | key:string, value:any | this | 添加元素到Map中 |
get | 方法 | key: string | any | 根据键获取元素 |
delete | 方法 | key: string | boolean | 删除指定的元素 |
clear | 方法 | void | 清空Map | |
has | 方法 | key: string | boolean | 判断Map中是否包含指定的键 |
keys | 方法 | []string | 返回一个包含Map中所有键的迭代器 | |
values | 方法 | []any | 返回一个包含Map中所有值的迭代器 |
size
size
属性返回Map对象中元素的数量。
语法
map.size;
返回值
返回Map对象中元素的数量,为一个整数。
示例
let map = new Map();
map.set('a', 'alpha');
map.set('b', 'beta');
map.set('g', 'gamma');
console.log(map.size); // 输出: 3
set
set()
方法用于设置Map对象中键的值。返回该Map对象。
语法
map.set(key, value);
key
:要添加到Map中的键。value
:与指定键相关联的值。
返回值
返回Map对象本身,允许链式调用。
示例
let map = new Map();
// 添加新的键值对
map.set('a', 'alpha');
map.set('b', 'beta');
map.set('g', 'gamma');
console.log(map);
// Map(3) {"a" => "alpha", "b" => "beta", "g" => "gamma"}
// 更新现有的键值对
map.set('a', 'updated alpha');
console.log(map.get('a'));
// 输出: "updated alpha"
// 链式调用
map.set('d', 'delta').set('e', 'epsilon');
console.log(map);
// Map(5) {"a" => "updated alpha", "b" => "beta", "g" => "gamma", "d" => "delta", "e" => "epsilon"}
get
get()
方法用于获取指定键(key)对应的值。如果Map对象中存在这个键,则返回键对应的值;如果不存在,则返回undefined
。
语法
map.get(key);
- key:要获取值的键。
返回值
返回键对应的值,如果没有这个键,则返回undefined
。
示例
// 获取存在的键的值
let map = new Map();
map.set('a', 100);
map.set('b', 200);
console.log(map.get('a')); // 输出: 100
console.log(map.get('b')); // 输出: 200
// 尝试获取不存在的键的值
console.log(map.get('c')); // 输出: undefined
delete
delete()
方法用于删除Map中的指定元素。如果Map中存在该元素,则该元素会被删除,且方法返回true
;如果Map中不存在该元素,则Map保持不变,方法返回false
。
语法
map.delete(key);
key
:要删除的元素的键。
返回值
true
:如果Map对象中存在该元素,且成功删除。false
:如果Map对象中不存在该元素。
示例
// 删除存在的键
let map = new Map();
map.set('a', 'alpha');
map.set('b', 'beta');
map.set('g', 'gamma');
console.log(map.delete('a')); // 输出: true
console.log(map.has('a')); // 输出: false
// 尝试删除不存在的键
console.log(map.delete('z')); // 输出: false
clear
clear()
方法用于移除Map对象中的所有元素,使其变为空Map。该方法没有参数,并且也不返回任何值(undefined
)。
语法
map.clear();
示例
let map = new Map();
map.set('a', 'alpha');
map.set('b', 'beta');
map.set('g', 'gamma');
console.log(map.size); // 输出: 3
map.clear();
console.log(map.size); // 输出: 0
has
has()
方法用于判断Map对象是否含有指定的键。如果Map中存在该键,则返回true
;否则,返回false
。
语法
map.has(key);
key
:要检查是否存在的键。
返回值
true
:Map对象中存在指定的键。false
:Map对象中不存在指定的键。
示例
// 检查Map中是否存在某键
let map = new Map();
map.set('a', 'alpha');
map.set('b', 'beta');
console.log(map.has('a')); // 输出: true
console.log(map.has('b')); // 输出: true
console.log(map.has('c')); // 输出: false
keys
keys()
方法用于返回一个新的迭代器对象,它按插入顺序包含了Map对象中每个元素的键。
语法
map.keys();
返回值
返回一个新的Map迭代器对象,它按插入顺序包含了Map对象中每个元素的键。
示例
// 获取Map中所有的键
let map = new Map();
map.set('a', 'alpha');
map.set('b', 'beta');
map.set('g', 'gamma');
let keys = map.keys();
for (let [_, key] of keys) {
console.log(key);
}
// 或:
for (let key of keys) {
console.log(key);
}
// 输出:
// a
// b
// g
values
values()
方法用于返回一个新的迭代器对象,它按插入顺序包含了Map对象中每个元素的值。
语法
map.values();
返回值
返回一个新的Map迭代器对象,它按插入顺序包含了Map对象中每个元素的值。
示例
// 获取Map中所有的值
let map = new Map();
map.set('a', 'alpha');
map.set('b', 'beta');
map.set('g', 'gamma');
let values = map.values();
for (let [_, value] of values) {
console.log(value);
}
// 或:
for (let value of values) {
console.log(value);
}
// 输出:
// alpha
// beta
// gamma
Set
Set
对象是一种特殊的数据结构,它允许你存储任何类型的唯一值,无论是原始值还是对象引用。主要特点是元素的唯一性。
创建Set对象
let set = new Set();
你也可以在创建Set对象时初始化它,包含任意类型的值:
let mySet = new Set([1, 2, 3, 4, 4, 5]);
// 由于Set对象中的值唯一,数字4只会被添加一次
属性与方法
set对象的所有方法和属性
名称 | 类型 | 参数 | 返回值 | 说明 |
---|---|---|---|---|
size | 属性 | int | 返回Set对象中元素的数量 | |
add | 方法 | value:any | this | 向Set中添加一个新元素 |
delete | 方法 | value:any | boolean | 从Set中删除指定的元素 |
clear | 方法 | void | 清空Set | |
has | 方法 | value:any | boolean | 检查Set中是否存在某个元素 |
size
size
属性返回Set对象中元素的数量。
语法
set.size;
返回值
返回一个表示Set对象中唯一元素数量的整数。
示例
let mySet = new Set();
mySet.add(1);
mySet.add("text");
mySet.add(true);
console.log(mySet.size); // 输出: 3
add
add()
方法用于向Set添加一个新元素。如果该元素已经存在于Set中,则不会再次添加,因为Set内的元素必须是唯一的。
语法
set.add(value);
value
:要添加到Set中的元素。
返回值
返回Set对象本身,因此可以链式调用。
示例
// 添加单个元素
let mySet = new Set();
mySet.add(1);
console.log(mySet); // Set(1) { 1 }
// 链式添加多个元素
let mySet = new Set();
mySet.add(2).add(3).add(4);
console.log(mySet); // Set(4) { 1, 2, 3, 4 }
// 尝试添加重复元素
mySet.add(2);
console.log(mySet); // Set(4) { 1, 2, 3, 4 }
delete
delete()
方法用于从Set中删除指定的元素。如果元素在Set中存在,则删除该元素并返回true
,表示成功删除;如果元素不存在,则返回false
。
语法
set.delete(value);
value
: 要从Set中删除的元素的值。
返回值
返回一个布尔值,如果Set中存在该元素并成功删除,则返回true
;如果该元素不存在,则返回false
。
示例
// 删除存在的元素
let mySet = new Set();
mySet.add(1);
mySet.add(2);
console.log(mySet); // Set(2) { 1, 2 }
let result = mySet.delete(1);
console.log(result); // true
console.log(mySet); // Set(1) { 2 }
// 尝试删除不存在的元素
result = mySet.delete(3);
console.log(result); // false
console.log(mySet); // Set(1) { 2 }
clear
clear()
方法用于移除Set内的所有元素,使其变为空Set。
语法
set.clear();
示例
let mySet = new Set();
mySet.add(1);
mySet.add(2);
mySet.add(3);
console.log(mySet); // Set(3) { 1, 2, 3 }
mySet.clear();
console.log(mySet); // Set(0) {}
has
has()
方法用于检查Set中是否存在某个元素。如果该元素存在于Set中,则返回true
;否则,返回false
。
语法
set.has(value);
value
:要检查是否存在于Set中的元素的值。
返回值
返回一个布尔值,表示Set中是否存在指定的元素。
示例
// 检查元素是否存在
let mySet = new Set();
mySet.add(1);
mySet.add("text");
mySet.add({a: 1, b: 2});
console.log(mySet.has(1)); // true
console.log(mySet.has(3)); // false
console.log(mySet.has("text")); // true
console.log(mySet.has("Text")); // false
let obj = {a: 1, b: 2};
console.log(mySet.has(obj)); // false
Cache
cache提供了一个高性能的本地缓存对象
//创建一个缓存对象
let cache = new Cache();
属性与方法
函数 | 参数 | 返回值 | 说明 |
---|---|---|---|
get | key:string | string | 获取指定key的值 |
set | key:string,value:string,expiration:int | string | 设置指定key的值,并设置过期时间(秒) |
del | key:string | int | 删除指定key |
has | key:string | boolean | 检查是否存在某个key |
set
//写入缓存,过期10秒
cache.set("key", "1111", 10);
get
//获取缓存数据
cache.get("key");
del
//删除缓存
cache.del("key");
has
//检查缓存是否存在
cache.has("key");