@whitesev/utils
Version:
一个常用的工具库
512 lines (502 loc) • 13.3 kB
text/typescript
declare interface UtilsIDBOpenErrorResult {
code: number;
msg: string;
event: {
srcElement: IDBRequest;
target: IDBRequest;
} & Event;
}
class indexedDB {
#dbName: string;
#storeName: string;
#dbVersion: number;
/* websql的版本号，由于ios的问题，版本号的写法不一样 */
// @ts-ignore
#slqVersion = "1";
/* 监听IndexDB */
#indexedDB =
window.indexedDB ||
(window as any).mozIndexedDB ||
(window as any).webkitIndexedDB ||
(window as any).msIndexedDB;
/* 缓存数据库，避免同一个页面重复创建和销毁 */
#db: {
[key: string]: IDBDatabase;
} = {};
// @ts-ignore
#store: IDBObjectStore = null as any;
/** 状态码 */
#statusCode = {
operationSuccess: {
code: 200,
msg: "操作成功",
},
operationFailed: {
code: 401,
msg: "操作失败",
},
empty: {
code: 201,
msg: "操作成功，但是没有数据",
},
openFailed: { code: 91001, msg: "打开数据库失败" },
saveFailed: { code: 91002, msg: "保存数据失败" },
getFailed: { code: 91003, msg: "获取数据失败" },
deleteFailed: { code: 91004, msg: "删除数据失败" },
deleteAllFailed: { code: 91005, msg: "清空数据库失败" },
regexpGetFailed: { code: 91006, msg: "正则获取数据失败" },
};
/**
* @param dbName 数据存储名，默认为：default_db
* @param storeName 表名，默认为：default_form
* @param dbVersion indexDB的版本号，默认为：1
*/
constructor(
dbName = "default_db",
storeName = "default_form",
dbVersion = 1
) {
this.#dbName = dbName;
this.#storeName = storeName;
this.#dbVersion = dbVersion;
if (!this.#indexedDB) {
alert("很抱歉，您的浏览器不支持indexedDB");
throw new TypeError("很抱歉，您的浏览器不支持indexedDB");
}
}
/**
* 创建 “表”
* @param dbName 表名
*/
createStore(dbName: string) {
let txn, store;
txn = this.#db[dbName].transaction(
this.#storeName,
"readwrite"
) as IDBTransaction;
/* IndexDB的读写权限 */
store = txn.objectStore(this.#storeName) as IDBObjectStore;
this.#store = store;
return store;
}
/**
* 打开数据库
* @param callback 回调
* @param dbName 数据库名
*/
private open(
callback: (
/** 数据库实例 */
idbStore: IDBObjectStore | null,
error?: UtilsIDBOpenErrorResult
) => void,
dbName: string
) {
let that = this;
/* 打开数据库 */
/* 如果支持IndexDB */
if (!that.#db[dbName]) {
/* 如果缓存中没有，则进行数据库的创建或打开，提高效率 */
let request = that.#indexedDB.open(dbName, that.#dbVersion);
request.onerror = function (event: any) {
callback(null, {
code: that.#statusCode.openFailed.code,
msg: that.#statusCode.openFailed.msg,
event: event,
});
};
request.onsuccess = function (event: Event) {
if (!that.#db[dbName]) {
let target = event.target as IDBRequest;
that.#db[dbName] = target.result;
}
let store = that.createStore(dbName);
callback(store);
};
request.onupgradeneeded = function (event: Event) {
let target = event.target as IDBRequest;
that.#db[dbName] = target.result;
let store = that.#db[dbName].createObjectStore(that.#storeName, {
keyPath: "key",
});
store.transaction.oncomplete = function (event: Event) {
callback(store);
};
};
} else {
/* 如果缓存中已经打开了数据库，就直接使用 */
let store = this.createStore(dbName);
callback(store);
}
}
/**
* 保存数据到数据库
* @param key 数据key
* @param value 数据值
*/
async save<T extends any>(
key: string,
value: T
): Promise<{
/** 本操作是否成功 */
success: boolean;
/** 状态码 */
code: number;
/** 状态码对应的消息 */
msg: string;
/** 执行操作触发的事件，如果是在open阶段失败的话该值为空 */
event?: {
srcElement: IDBRequest<T>;
target: IDBRequest<T>;
} & Event;
}> {
let that = this;
return new Promise((resolve) => {
let dbName = this.#dbName;
let inData = {
key: key,
value: value,
};
this.open(function (idbStore) {
if (idbStore == null) {
resolve({
success: false,
code: that.#statusCode.saveFailed.code,
msg: that.#statusCode.saveFailed.msg,
});
} else {
let request = idbStore.put(inData);
request.onsuccess = function (event: any) {
/* 保存成功有success 字段 */
resolve({
success: true,
code: that.#statusCode.operationSuccess.code,
msg: that.#statusCode.operationSuccess.msg,
event: event,
});
};
request.onerror = function (event: any) {
resolve({
success: false,
code: that.#statusCode.saveFailed.code,
msg: that.#statusCode.saveFailed.msg,
event: event,
});
};
}
}, dbName);
});
}
/**
* 判断是否存在该数据
* @param key 数据key
*/
async has(key: string): Promise<{
/** 本操作是否成功 */
success: boolean;
/** 状态码 */
code: number;
/** 状态码对应的消息 */
msg: string;
/** 执行操作触发的事件，如果是在open阶段失败的话该值为空 */
event?: {
srcElement: IDBRequest;
target: IDBRequest;
} & Event;
}> {
let that = this;
return new Promise((resolve) => {
let dbName = this.#dbName;
this.open(function (idbStore) {
/* 判断返回的数据中是否有error字段 */
if (idbStore == null) {
resolve({
success: false,
code: that.#statusCode.getFailed.code,
msg: that.#statusCode.getFailed.msg,
});
} else {
let request = idbStore.get(key);
request.onsuccess = function (event: any) {
/* result 返回的是 {key: string, value: any} */
/* 键值对存储 */
resolve({
success: true,
code: that.#statusCode.operationSuccess.code,
msg: that.#statusCode.operationSuccess.msg,
event: event,
});
};
request.onerror = function (event: any) {
resolve({
success: false,
code: that.#statusCode.getFailed.code,
msg: that.#statusCode.getFailed.msg,
event: event,
});
};
}
}, dbName);
});
}
/**
* 根据key获取值
* @param key 数据key
*/
async get<T extends any>(
key: string
): Promise<{
/** 本操作是否成功 */
success: boolean;
/** 状态码 */
code: number;
/** 状态码对应的消息 */
msg: string;
/** 获取的数据 */
data: T;
/** 执行操作触发的事件，如果是在open阶段失败的话该值为空 */
event?: {
srcElement: IDBRequest<T>;
target: IDBRequest<T>;
} & Event;
/** 获取的结果，里面的数据提取为data */
result?: {
key: string;
value: T;
};
}> {
let that = this;
return new Promise((resolve) => {
let dbName = this.#dbName;
this.open(function (idbStore) {
/* 判断返回的数据中是否有error字段 */
if (idbStore == null) {
resolve({
success: false,
code: that.#statusCode.getFailed.code,
msg: that.#statusCode.getFailed.msg,
data: void 0 as any,
});
} else {
let request = idbStore.get(key);
request.onsuccess = function (event: any) {
let target = event.target as IDBRequest;
let result = target.result as
| {
key: string;
value: T;
}
| undefined;
/* result 返回的是 {key: string, value: any} */
/* 键值对存储 */
let data = result ? result.value : void 0;
if (data == null) {
resolve({
success: true,
code: that.#statusCode.empty.code,
msg: that.#statusCode.empty.msg,
data: data!,
event: event,
result: result,
});
} else {
resolve({
success: true,
code: that.#statusCode.operationSuccess.code,
msg: that.#statusCode.operationSuccess.msg,
data: data,
event: event,
result: result,
});
}
};
request.onerror = function (event: any) {
resolve({
success: false,
code: that.#statusCode.getFailed.code,
msg: that.#statusCode.getFailed.msg,
data: void 0 as any,
event: event,
});
};
}
}, dbName);
});
}
/**
* 正则获取数据
* @param key 数据key，可以是正则
*/
async regexpGet<T extends any>(
key: string | RegExp
): Promise<{
/** 本操作是否成功 */
success: boolean;
/** 状态码 */
code: number;
/** 状态码对应的消息 */
msg: string;
/** 获取到的数据列表 */
data: T[];
/** 执行操作触发的事件，如果是在open阶段失败的话该值为空 */
event?: {
srcElement: IDBRequest<T>;
target: IDBRequest<T>;
} & Event;
}> {
let list: T[] = [];
let that = this;
return new Promise((resolve) => {
/* 正则查询 */
let dbName = that.#dbName;
this.open(function (idbStore) {
/* 判断返回的数据中是否有error字段 */
if (idbStore == null) {
resolve({
success: false,
code: that.#statusCode.regexpGetFailed.code,
msg: that.#statusCode.regexpGetFailed.msg,
data: [],
});
} else {
let request = idbStore.getAll();
request.onsuccess = function (event: any) {
let target = event.target as IDBRequest<
{ key: string; value: T }[]
>;
let result = target.result;
if (result.length !== 0) {
result.forEach((dataItem, index) => {
// 当前项的key
let __key = dataItem["key"];
// 当前项的value
let __value = dataItem["value"];
if (__key.match(key)) {
list = list.concat(__value);
}
});
}
resolve({
success: true,
code: that.#statusCode.operationSuccess.code,
msg: that.#statusCode.operationSuccess.msg,
data: list,
event: event,
});
};
request.onerror = function (event: any) {
resolve({
success: false,
code: that.#statusCode.getFailed.code,
msg: that.#statusCode.getFailed.msg,
data: [],
event: event,
});
};
}
}, dbName);
});
}
/**
* 删除数据
* @param key 数据key
*/
async delete(key: string): Promise<{
/** 本操作是否成功 */
success: boolean;
/** 状态码 */
code: number;
/** 状态码对应的消息 */
msg: string;
/** 执行操作触发的事件，如果是在open阶段失败的话该值为空 */
event?: {
srcElement: IDBRequest;
target: IDBRequest;
} & Event;
}> {
let that = this;
return new Promise((resolve) => {
/* 根据key删除某条数据 */
let dbName = that.#dbName;
this.open(function (idbStore) {
if (idbStore == null) {
resolve({
success: false,
code: that.#statusCode.deleteFailed.code,
msg: that.#statusCode.deleteFailed.msg,
});
} else {
// 删除键
let request = idbStore.delete(key);
request.onsuccess = function (event: any) {
resolve({
success: true,
code: that.#statusCode.operationSuccess.code,
msg: that.#statusCode.operationSuccess.msg,
event: event,
});
};
request.onerror = function (event: any) {
resolve({
success: false,
code: that.#statusCode.deleteFailed.code,
msg: that.#statusCode.deleteFailed.msg,
event: event,
});
};
}
}, dbName);
});
}
/**
* 删除所有数据
*/
async deleteAll(): Promise<{
/** 本操作是否成功 */
success: boolean;
/** 状态码 */
code: number;
/** 状态码对应的消息 */
msg: string;
/** 执行操作触发的事件，如果是在open阶段失败的话该值为空 */
event?: {
srcElement: IDBRequest;
target: IDBRequest;
} & Event;
}> {
let that = this;
return new Promise((resolve) => {
/* 清空数据库 */
let dbName = that.#dbName;
this.open(function (idbStore) {
if (idbStore == null) {
resolve({
success: false,
code: that.#statusCode.deleteAllFailed.code,
msg: that.#statusCode.deleteAllFailed.msg,
});
} else {
// 清空
let operateResult = idbStore.clear();
operateResult.onsuccess = function (event: any) {
resolve({
success: true,
code: that.#statusCode.operationSuccess.code,
msg: that.#statusCode.operationSuccess.msg,
event: event,
});
};
operateResult.onerror = function (event: any) {
resolve({
success: false,
code: that.#statusCode.deleteAllFailed.code,
msg: that.#statusCode.deleteAllFailed.msg,
event: event,
});
};
}
}, dbName);
});
}
}
export { indexedDB };