/**
 * 创建类
 */
class Person {

	//类的共有成员变量
	name
	//类的私有成员变量
	#age

	/**
	 * 类的构造方法。
	 */
	constructor(name, age) {
		this.name = name; // 实例属性
		this.#age = age;   // 实例属性
	}

	/**
	 * 类的成员方法
	 */
	getName() {
		return this.name;
	}

	/**
	 * 类的成员方法
	 */
	setName(newName) {
		this.name = newName;
	}
}

const person1 = new Person('张三', 30);
console.log(person1);

/**
 * 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
		}
	}
}

//创建一个初始长度为0个字节的buffer
let buffer = new Buffer();

//创建一个初始长度为10个字节的buffer
let buffer = new Buffer(10);

let buf = new Buffer();
console.log(buf.size());

let buffer = new Buffer();
buffer.write("abc");
buffer.reset();

let buffer = new Buffer();
//取值范围0-255
buffer.writeByte([0xff, 0xff]);
//结果[255 255]
console.log(buffer.toByteString())

let buffer = new Buffer(5);
//写入buffer中下标为2的位置
buffer.writeByte([0x01, 0x02], 2);
//结果:[0 0 1 2 0]
console.log(buffer.toByteString())

let buffer = new Buffer();
//写入buffer中下标为2的位置,这里会抛异常
buffer.writeByte([0x01, 0x02], 2);
console.log(buffer.toByteString())

let buffer = new Buffer();
buffer.writeByte([-1]);
//结果:[255]
console.log(buffer.toByteString())

let buffer = new Buffer();
buffer.writeByte([345.67]);
//结果:[89]
console.log(buffer.toByteString())

let buffer = new Buffer();
buffer.write("abc");
console.log(buffer.toString());

let buffer = new Buffer();
buffer.write("你好中国", "gbk");
console.log(buffer.toString("gbk"));

let buffer = new Buffer();
buffer.write("abc");
console.log(buffer.toByteString());
//打印结果：[97 98 99] 

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();

import {fs} from 'core';

let file = fs.openFile("/Users/xx/Desktop/xx.txt", "readWrite");
//读取文件内所有数据到buffer
let buffer = file.read();
file.close();

import {fs} from "core"
//打开文件
let file = fs.open("./test.txt")
let bufReader = new BufferReader(file);
//读取文件内所有数据
let line1 = bufReader.readString();

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");

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

date.format(format);

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

date.getFullYear();

let date = new Date();
console.log(date.getFullYear());

date.getMonth();

let date = new Date();
console.log(date.getMonth());

date.getDate();

let date = new Date();
console.log(date.getDate());

date.getDay();

let date = new Date();
console.log(date.getDay());

date.getHours();

let date = new Date();
console.log(date.getHours());

date.getMinutes();

let date = new Date();
console.log(date.getMinutes());

date.getSeconds();

let date = new Date();
console.log(date.getSeconds());

date.getMilliseconds();

let date = new Date();
console.log(date.getMilliseconds());

date.getTime();

let date = new Date();
console.log(date.getTime());

date.add(time, unit);

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

date.getAgo();

let date = new Date("2024-07-23 10:10:10", "yyyy-MM-dd HH:mm:ss");
//打印:12小时前。具体时间以执行时为准
console.log(date.getAgo());

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));

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));

//创建一个线程池，该线程池的最大工作线程是5,等待队列最大10
let pool = new ThreadPool(5, 10)

function a() {
	console.log("test")
}

//将函数a放入线程池中
pool.submit(a)
//等待所有线程执行结束
pool.stopAndWait()

new ThreadPool(maxWorkers:int, maxCapacity:int,error?:(e:Error,f:Function,args:...any[])=>{})

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()

pool.submit(task:()=>void,...args:any[]);

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});

let pool = new ThreadPool(5, 10);
let i = 10;
//添加任务时传递一个参数
pool.submit((i) => {
	//任务要执行的代码
}, i);

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);

pool.stop();

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
pool.stop();

pool.stopAndWait();

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
pool.stopAndWait();

pool.stopAndWaitFor(deadline:int)

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
//等待1秒钟,如果还没有结束，则强制停止
pool.stopAndWaitFor(1000);

pool.runningWorkers();

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
let c = pool.runningWorkers();
console.log(c);

pool.idleWorkers();

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
let c = pool.idleWorkers();
console.log(c);

pool.minWorkers();

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
let c = pool.minWorkers();
console.log(c);

pool.maxWorkers();

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
let c = pool.maxWorkers();
console.log(c);

pool.maxCapacity();

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
let c = pool.maxCapacity();
console.log(c);

pool.submittedTasks();

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
let c = pool.submittedTasks();
console.log(c);

pool.waitingTasks();

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
let c = pool.waitingTasks();
console.log(c);

pool.successfulTasks();

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
let c = pool.successfulTasks();
console.log(c);

pool.failedTasks();

let pool = new ThreadPool(5, 10);
pool.submit(() => {
	//任务要执行的代码
});
let c = pool.failedTasks();
console.log(c);

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 

map.size;

let map = new Map();

map.set('a', 'alpha');
map.set('b', 'beta');
map.set('g', 'gamma');

console.log(map.size); // 输出: 3

map.set(key, value);

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"}

map.get(key);

// 获取存在的键的值
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

map.delete(key);

// 删除存在的键
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

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

map.has(key);

// 检查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

map.keys();

// 获取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

map.values();

// 获取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

let set = new Set();

let mySet = new Set([1, 2, 3, 4, 4, 5]);
// 由于Set对象中的值唯一，数字4只会被添加一次

set.size;

let mySet = new Set();
mySet.add(1);
mySet.add("text");
mySet.add(true);

console.log(mySet.size); // 输出: 3

set.add(value);

// 添加单个元素
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 }

set.delete(value);

// 删除存在的元素
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 }

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) {}

set.has(value);

// 检查元素是否存在
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

//创建一个缓存对象
let cache = new Cache();

//写入缓存,过期10秒
cache.set("key", "1111", 10);

//获取缓存数据
cache.get("key");

//删除缓存
cache.del("key");

//检查缓存是否存在
cache.has("key");