uniapp使用plus.sqlite
·
操作步骤
注：plus.sqlite是只允许app使用的跟sqlite3不一样
这些只是操作方法还有简单进行二次封装如果觉得麻烦可以直接使用https://www.html5plus.org/doc/zh_cn/sqlite.html 进行配置使用
- 在manifest.json找到 安卓/ios模块配置 在打包模块配置里面找到 SQlite(数据库) 把他勾选
- 因为是扩展模块所以你需要重新打包自定义基座
- 这里使用云打包流程
- 打开云打包选择自定义打包
- 打包完成会出现
6. 然后现在开始写sqlite的代码
import { isString, isObject, isNumber, map, pick } from 'lodash-es';
/**
* 生成 SQL 查询条件字符串
* @param {object} conditions - 查询条件对象，其中键为字段名，值为对应的条件值
* @param {Boolean} isFuzzy - 是否进行模糊查询，默认为 false
* @returns {string} - 返回生成的 SQL 查询条件字符串
*/
const getConditionsSql = (conditions: object, isFuzzy: Boolean = false): string => {
return Object.entries(conditions)
.map(([key, value]) => {
/* if (key.endsWith('_min')) {
const columnName = key.replace('_min', '');
return `${columnName} >= ${value}`;
} else if (key.endsWith('_max')) {
const columnName = key.replace('_max', '');
return `${columnName} <= ${value}`;
} */
if (typeof value === 'string')
return `${key} ${isFuzzy ? 'LIKE' : '='} '${isFuzzy ? '%' : ''}${value.replace(/'/g, "''")}${
isFuzzy ? '%' : ''
}'`;
return `${key} ${isFuzzy ? 'LIKE' : '='} ''${isFuzzy ? '%' : ''}${value}${isFuzzy ? '%' : ''}'`;
})
.join(' AND ');
};
export class Sqlite {
private dbName: string;
private dbPath: string;
private sqlite: PlusSqlite = plus.sqlite;
/**
* @param dbName "h5db" 数据库名称
* @param dbPath "_doc/h5.db" 数据库路径
*/
constructor(dbName: string, dbPath: string) {
this.dbName = dbName;
this.dbPath = dbPath;
}
/** @function isOpen
* 检查数据库是否已打开
* @returns {boolean} 返回数据库是否已打开的布尔值
*/
isOpen(): boolean {
return this.sqlite.isOpenDatabase({ name: this.dbName, path: this.dbPath });
}
/** @function openSqlite
* 打开数据库
* @returns {Promise<void|Error>} 成功无返回值 ，失败时返回错误
*/
async openSqlite(): Promise<void | Error> {
try {
if (this.isOpen()) return;
return await new Promise<void>((resolve, reject) => {
this.sqlite.openDatabase({
name: this.dbName,
path: this.dbPath,
success: () => resolve(), // 只需要 resolve()，不需要参数
fail: (error) => reject(error),
});
});
} catch (error) {
return error;
}
}
/** @function closeSqlite
* 关闭数据库
* @returns {Promise<void|Error>} 成功无返回值 ，失败时返回错误
*/
async closeSqlite(): Promise<void | Error> {
try {
if (!this.isOpen()) return;
return await new Promise<void>((resolve, reject) => {
this.sqlite.closeDatabase({
name: this.dbName,
success: () => resolve(), // 只需要 resolve()，不需要参数
fail: (error) => reject(error),
});
});
} catch (error) {
return error;
}
}
/** @function executeSql
* 执行 SQL 语句
* @param {string| Array<string>} sql 要执行的 SQL 语句
* @returns {Promise<void|Error>} 成功无返回值 ，失败时返回错误
*/
async executeSql(sql: string | Array<string>, dbName = this.dbName): Promise<void | Error> {
try {
return await new Promise<void>((resolve, reject) => {
this.sqlite.executeSql({
name: dbName,
sql,
success: () => resolve(),
fail: (error) => reject(error),
});
});
} catch (error) {
return error;
}
}
/** @function selectSql
* 执行 SELECT SQL 语句
* @param {string} sql 要执行的 SELECT SQL 语句
* @returns {Promise<any>} 返回查询结果，失败时抛出错误
*/
async selectSql(sql: string): Promise<any> {
try {
return await new Promise<any>((resolve, reject) => {
this.sqlite.selectSql({
name: this.dbName,
sql: sql,
success: (result) => resolve(result),
fail: (error) => {
console.error('Error selecting SQL:', error);
reject();
},
});
});
} catch (error) {
console.error('Error selecting SQL:', error);
throw error;
}
}
/** @function checkTableExists
* 查询有没有这个表格
* @param {string} tableName 表名
* @returns {Promise<Array<string> | void>} 成功返回数据 没有查询就是空
*/
async checkTableExists(tableName: string): Promise<Array<string> | void> {
const sql = `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName}'`;
return await this.selectSql(sql);
}
/** @function selectAllTable
* 查询所有表
* @returns {boolean} 返回查询的所有表数据
*/
async selectAllTable(): Promise<boolean> {
return await this.selectSql('SELECT * FROM sqlite_master');
}
/** @function selectPragma
* 查询表 字段
* @param {string} tableName 表名
* @returns {any} 返回查询的所有表数据
*/
async selectPragma(tableName: string): Promise<any[]> {
return await this.selectSql('PRAGMA table_info(' + tableName + ')');
}
/** @function createTable
* 创建数据表
* @param {string} tableName 表名
* @param {Record<string, string>} schema 表结构定义
* @param key 主键
* @returns {Promise<void|Error>} 成功无返回值 ，失败时返回错误
*/
async createTable(tableName: string, schema: Record<string, string>, key?: string): Promise<void | Error> {
const columns = Object.entries(schema)
.map(([key, value]) => `${key} ${value}`)
.join(',');
const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${
key ? `"${key}" INTEGER PRIMARY KEY AUTOINCREMENT, ` : ''
}${columns})`;
return await this.executeSql(sql);
}
/**
* 根据数据类型创建数据表
* @param {string} tableName 表名
* @param {Record<string, any>} data 数据对象，用于定义表结构
* @returns {Promise<void|Error>} 成功无返回值 ，失败时返回错误
*/
async createTableWithTypes(tableName: string, data: Record<string, any>, key?: string): Promise<void | Error> {
const columns = Object.entries(data)
.map(([key, value]) => {
let typeName = '';
switch (typeof value) {
case 'number':
typeName = Number.isInteger(value) ? 'INTEGER' : 'REAL';
break;
case 'string':
typeName = 'TEXT';
break;
case 'boolean':
typeName = 'BOOLEAN';
break;
case 'object':
if (value instanceof Date) typeName = 'TEXT';
break;
default:
typeName = 'TEXT';
break;
}
return `${key} ${typeName}`;
})
.join(',');
const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${
key ? `"${key}" INTEGER PRIMARY KEY AUTOINCREMENT, ` : ''
}${columns})`;
console.log(sql, 'sqlte');
return await this.executeSql(sql);
}
/**
* 插入数据
* @param {string} tableName 表名
* @param {Record<string, any>} data 要插入的数据对象 或sql 语句
* @returns {Promise<void|Error>} 成功无返回值 ，失败时返回错误
*/
async insert(tableName: string, data: Record<string, any> | string): Promise<void | Error> {
let sql = `INSERT INTO ${tableName} `;
if (isString(data)) sql += data;
else {
const columns = Object.keys(data).join(',');
const values = Object.values(data)
.map((value) => {
if (value === null || value === undefined) return 'NULL';
if (typeof value === 'string') return `'${value.replace(/'/g, "''")}'`;
if (value instanceof Date) return `'${value.toISOString()}'`;
return value;
})
.join(',');
sql += `(${columns}) VALUES (${values})`;
}
return await this.executeSql(sql);
}
/**
* 查询数据
* @param {string} tableName 表名
* @param {Partial<Record<string, any>>} [conditions] 可选的查询条件 或直接sql语句
* @param {boolean} isFuzzy - 是否进行模糊查询，默认为 false
* @returns {Promise<any>} 返回查询结果
*/
async select(
tableName: string,
conditions?: Partial<Record<string, any>> | string,
isFuzzy: Boolean = false,
): Promise<any> {
let sql = `SELECT * FROM ${tableName}`;
if (conditions) {
if (isString(conditions)) sql += ` WHERE ${conditions}`;
else {
const conditionStrings = getConditionsSql(conditions as Partial<Record<string, any>>, isFuzzy);
sql += ` WHERE ${conditionStrings}`;
}
}
return await this.selectSql(sql);
}
/**
* 分页查询数据
*
* @param {string} tableName - 要查询的表名
* @param {number|string} pageNumber - 当前页码（可以是数字或字符串）
* @param {number|string} pageSize - 每页的记录条数（可以是数字或字符串）
* @param { Partial<Record<string, any>> } conditions 查询条件
* @param {boolean} isFuzzy - 是否进行模糊查询，默认为 false
* @param {string} [orderBy] - 可选的排序字段（如 "column_name ASC" 或 "column_name DESC"）
* @param {Boolean} desc 是否需要降序
* @returns {Promise<any>} 返回查询结果的数据
*/
async selectPage(
tableName: string,
pageNumber: number | string,
pageSize: number | string,
conditions?: Partial<Record<string, any>>,
isFuzzy?: Boolean,
orderBy?: string,
desc?: Boolean,
): Promise<any> {
let where = '';
if (conditions && isObject(conditions) && Object.keys(conditions).length !== 0) {
const conditionStrings = getConditionsSql(conditions, isFuzzy);
where = ` WHERE ${conditionStrings}`;
}
const offset = (Number(pageNumber) - 1) * Number(pageSize);
let sql = `SELECT * FROM ${tableName}${where}${
orderBy ? ` ORDER BY ${orderBy} ${desc ? 'desc' : ''}` : ''
} LIMIT ${pageSize} OFFSET ${offset}`;
return await this.selectSql(sql);
}
/**
* 更新指定表中的数据
* @param {string} tableName - 表名
* @param {Record<string, any>} data - 包含更新字段及其新值的对象，必须包含 id 字段作为条件
* @param {string|Record<string, string>} {id:'1'} - 作为唯一标识的字段名，可以是字符串或字符串数组，默认值为 'id'
* @returns {Promise<void|Error>} 成功无返回值 ，失败时返回错误
*/
async update(
tableName: string,
data: Record<string, any>,
fieldKey: string | Record<string, string> = 'id',
): Promise<void | Error> {
/* if (typeof fieldKey == 'string') {
delete data[fieldKey];
} */
const updates = Object.entries(data)
.map(([key, value]) => {
if (typeof isString(value)) return `${key} = '${value}'`;
return `${key} = ${value}`;
})
.join(',');
// 构建 WHERE 子句
let whereClause: string;
if (isString(fieldKey))
// 如果 fieldKey 是字符串
whereClause = `${fieldKey} = '${data[fieldKey as string]}'`;
else {
// 如果 fieldKey 是对象
whereClause = Object.entries(fieldKey)
.map(([key, value]) => {
return `${key} = '${value}'`;
})
.join(' AND ');
}
const sql = `UPDATE ${tableName} SET ${updates} WHERE ${whereClause}`;
return await this.executeSql(sql);
}
/** @function dealUpdateBatch
* 批量更新记录，如果记录不存在则插入新记录
* @param {string} tbName - 表名
* @param {any[]} fieldList - 需要更新或插入的记录列表，每条记录是一个对象，包含待操作的数据
* @param {string| Record<string, string> } [fieldKey='id'] - 作为唯一标识的字段名，默认值为 'id'
* @returns {Promise<{ success: any[]; error: any[] }>} - 返回一个对象，其中：
* - `success` 是一个数组，包含成功更新或插入的记录的结果
* - `error` 是一个数组，包含在处理过程中发生的错误
*/
async dealUpdateBatch(
tbName: string,
fieldList: any,
fieldKey: string | Record<string, string> = 'id',
): Promise<{ success: any[]; error: any[] }> {
const result = { success: [], error: [] };
for (const record of fieldList) {
// 根据 fieldKey 的类型提取值
let keyValue: any;
if (typeof fieldKey === 'string') {
keyValue = record[fieldKey];
} else if (typeof fieldKey === 'object') {
keyValue = pick(record, Object.keys(fieldKey));
}
// console.log(keyValue, '231321Vja');
if (keyValue) {
const count = await this.getCountByKey(tbName, fieldKey, keyValue);
if (count) {
// 记录已存在，执行更新
const error = await this.update(tbName, record, fieldKey);
if (error) result.error.push(error);
else result.success.push(record);
} else {
// 记录不存在，执行插入
const error = await this.insert(tbName, record);
if (error) result.error.push(error);
else result.success.push(record);
}
} else {
const error = await this.insert(tbName, record);
if (error) result.error.push(error);
else result.success.push(record);
}
}
return result;
}
/**
* 根据条件查询记录数
* @param {string} tbName 表名
* @param {string} condition 查询条件，例如 "name = 'zxl' AND loginTime > 10 AND sal IN (5000, 3000, 1500)"
* @returns {Promise<number>} 返回符合条件的记录数
*/
async countRecords(tbName: string, condition: string | Object): Promise<number> {
let sql = `SELECT COUNT(*) AS count FROM ${tbName}`;
if (isString(condition)) sql += ` WHERE ${condition}`;
else {
const conditionStrings = getConditionsSql(condition as object);
sql += ` WHERE ${conditionStrings}`;
}
const result = await this.selectSql(sql);
return result[0]?.count || 0;
}
/**
* 根据指定的键和值查询表中符合条件的记录数
* @param {string} tbName - 表名
* @param {string|Record<string, string>} key - 用于查询的字段名，默认为 'id'
* @param {any} value - 查询条件的值，例如特定的 ID 或其他字段值
* @returns {Promise<number>} - 返回符合条件的记录数
*/
async getCountByKey(tbName: string, key: string | Record<string, string> = 'id', value: any): Promise<number> {
let sql = `SELECT COUNT(*) AS count FROM ${tbName}`;
if (key) {
if (isString(key) && value) {
sql += ` WHERE ${key} = '${value}'`;
} else if (isObject(key))
sql += ` WHERE ${map(key, (v, k) => `${k} = ${JSON.stringify(v)}`).join(' AND ')}`;
}
const ret = await this.selectSql(sql);
return ret.length && ret[0] && ret[0].count ? ret[0].count : 0;
}
/**
* 根据条件获取统计数
* @param {*} tbName 表名
* @param {*} condition 条件：name = 'zxl' and loginTime > 10 and sal in (5000,3000,1500)
* @returns Promise
*/
async getCountByCondition(tbName: string, condition: string): Promise<number> {
let sql = `SELECT COUNT(*) AS count FROM ${tbName}`;
if (condition) sql += ` WHERE ${condition}`;
const ret = await this.selectSql(sql);
return ret.length && ret[0] && ret[0].count ? ret[0].count : 0;
}
/**
* 删除数据记录
* @param {string} tableName - 表名
* @param {Partial<Record<string, any>>} [conditions] - 删除条件，键值对形式，默认删除表中所有记录 或者直接sql插入
* @returns {Promise<void|Error>} 成功无返回值 ，失败时返回错误
*/
async delete(tableName: string, conditions?: Partial<Record<string, any>> | string): Promise<void | Error> {
let sql = `DELETE FROM ${tableName}`;
if (conditions) {
if (isString(conditions)) sql += ` WHERE ${conditions}`;
else {
const conditionStrings = getConditionsSql(conditions);
sql += ` WHERE ${conditionStrings}`;
}
}
// console.log(sql);
return await this.executeSql(sql);
}
/**
* 批量删除数据记录
* @param {string} tableName - 表名
* @param {Partial<Record<string, any>>[]} conditionsList - 删除条件列表，每个条件是一个对象
* @returns {Promise<void[]>} - 返回每个删除操作的结果
* @throws {Error} - 当执行 SQL 删除操作时出现错误
*/
async deleteBatch(tableName: string, conditionsList: Partial<Record<string, any>>[]): Promise<void[] | Error[]> {
const results = [];
for (const conditions of conditionsList) {
const result = await this.delete(tableName, conditions);
results.push(result);
}
return Promise.all(results);
}
/**
* 删除数据库表
* @param {string} tableName - 要删除的表名
* @returns {Promise<void>} - 无返回值
* @throws {Error} - 当执行 SQL 删除表操作时出现错误
*
* @description
* 执行 SQL 命令 `DROP TABLE IF EXISTS` 来删除指定的表。如果表不存在，会报error
*/
async dropTable(tableName: string): Promise<void | Error> {
return await this.executeSql(`DROP TABLE IF EXISTS ${tableName}`);
}
/**
* 清空数据库表中的所有数据
* @param {string} tableName - 要清空数据的表名
* @param {Boolean} is 判断是否需要使用 TRUNCATE TABLE来清除
* @returns {Promise<void>} - 无返回值
* @throws {Error} - 当执行 SQL 清空表数据操作时出现错误
*
* @description
* 执行 SQL 命令 `DELETE FROM` 来删除指定表中的所有记录。此操作不会删除表结构，只会清空表中的数据。
* 如果表非常大，考虑使用 `TRUNCATE TABLE` 代替 `DELETE FROM` 以提高性能，具体取决于数据库系统。
*/
async truncateTable(tableName: string, is: boolean = false): Promise<void | Error> {
return await this.executeSql(`${is ? 'TRUNCATE TABLE' : 'DELETE FROM'} ${tableName}`);
}
}
export type SqliteInstance = InstanceType<typeof Sqlite>;
export const sqlite: SqliteInstance = new Sqlite('h5db', '_doc/h5.db'); //_doc相当于 plus.io.PRIVATE_DOC 即私人文档目录。
然后运行在app
- 这里会有一个包是来源于你打包的自定义 如果没有的话参考上面的步骤打包
- 然后运行如果看不到手机的话是因为你的手机没有打开开发者模式
- 需要打开手机调试 允许电脑进行调试 允许电脑运行手机文件 这些
- 运行完就可以直接使用这个创建好的sqlite运行方法了
这里嫌麻烦所以我写了一个hook
/**
* @param {string} table 表名
* @param {Record<string, string>} schema
* @param key 主键
* @key
*/
export const useSqlite = (table?: string, schema?: Record<string, string>, key?: string) => {
const init = async () => {
// sqlite.dropTable(table);
/** 判断有没有打开数据库 没有就打开 */
if (!sqlite.isOpen()) await sqlite.openSqlite();
/** 判断有没有传数据类型 有的话就 判断有没有表格 有的话 就频道 当前字段对不对 没有的话 创建表 */
if (schema) await sqlite.createTable(table, schema, key);
await updateTable();
};
// sqlite.dropTable(table);
/**
* 插入数据
* @param {Record<string, any>} conditions 要插入的数据对象 或sql 语句
* @returns {Promise<void|Error>} 成功无返回值 ，失败时返回错误
*/
const insert = async (conditions: Record<string, any> | string): Promise<void | Error> =>
await sqlite.insert(table, conditions);
/**
* 更新数据
* @param {Record<string, any>} conditions 要插入的数据对象 或sql 语句
* @param {string} [fieldKey='id'] - 作为唯一标识的字段名，默认值为 'id'
* @returns {Promise<void|Error>} 成功无返回值 ，失败时返回错误
*/
const update = async (
conditions: Record<string, any>,
fieldKey: string | Record<string, string> = 'id',
): Promise<void | Error> => await sqlite.update(table, conditions, fieldKey);
/** @function insertBatch
* 批量更新记录，如果记录不存在则插入新记录
* @param {any[]} fieldList - 需要更新或插入的记录列表，每条记录是一个对象，包含待操作的数据
* @param {string} [fieldKey='id'] - 作为唯一标识的字段名，默认值为 'id'
* @returns {Promise<{ success: any[]; error: any[] }>} - 返回一个对象，其中：
* - `success` 是一个数组，包含成功更新或插入的记录的结果
* - `error` 是一个数组，包含在处理过程中发生的错误
*/
const insertBatch = async (
fieldList: any[],
fieldKey: string | Record<string, string> = 'id',
): Promise<{ success: any[]; error: any[] }> => sqlite.dealUpdateBatch(table, fieldList, fieldKey);
/**
* 查询表单数据
*/
const select = async (filter?: Partial<Record<string, any>> | string, isFuzzy?: Boolean) =>
sqlite.select(table, filter, isFuzzy);
/**
* 分页查询数据
*
* @param {number|string} pageNumber - 当前页码（可以是数字或字符串）
* @param {number|string} pageSize - 每页的记录条数（可以是数字或字符串）
* @param { Partial<Record<string, any>> } conditions 查询条件
* @param {Boolean} isFuzzy - 是否进行模糊查询，默认为 false
* @param {string} [orderBy] - 可选的排序字段（如 "column_name ASC" 或 "column_name DESC"）
* @param {Boolean} desc 是否降序
* @returns {Promise<any>} 返回查询结果的数据
*/
const selectPage = async (
pageNumber: string | number = 1,
pageSize: string | number = 10,
conditions?: Partial<Record<string, any>>,
isFuzzy?: Boolean,
orderBy?: string,
desc?: Boolean,
): Promise<any> => sqlite.selectPage(table, pageNumber, pageSize, conditions, isFuzzy, orderBy, desc);
/**
* 根据条件删除表单数据
* @param
*/
const sqldelete = async (conditions?: any) => await sqlite.delete(table, conditions);
/**
* 如果更新字段要调用这个方法 sqlite的版本比较低只能新增不能删字段
* @param
*/
const updateTable = async () => {
let res = await sqlite.checkTableExists(table);
if (res && res.length > 0) {
let re = await sqlite.selectPragma(table);
const ar = Object.keys(schema);
/**取新字段 */
const ac = ar.filter((d) => !re.some((i) => i.name === d));
/**取多于的字段 需要删除的 */
// const arp = re.filter((d) => !ar.some((i) => i === d.name));
/** 需要执行的sql */
/* const sqlArr = [
...arp.map(({ name }) => `ALTER TABLE silk_cart_db DROP ${name}`),
...ac.map((a) => `ALTER TABLE silk_cart_db ADD COLUMN ${a} ${schema[a]}`),
]; */
const sqlArr = ac.map((a) => `ALTER TABLE ${table} ADD COLUMN ${a} ${schema[a]}`);
if (sqlArr.length > 0) {
let reE = await sqlite.executeSql(sqlArr);
console.log(`column:${sqlArr} 结果：${JSON.stringify(reE)}`);
return reE;
}
}
};
/**关闭数据库
* @returns {Promise<void|Error>} 成功无返回值 ，失败时返回错误
减少了sqlite 而已 */
const closeSqlite = (): Promise<void | Error> => sqlite.closeSqlite();
init();
return { sqlite, insert, update, insertBatch, select, sqldelete, selectPage, updateTable, closeSqlite };
};
//测试文件
// #ifdef APP
import { useSqlite } from '@/useSqlite';
export const { insertBatch, select, sqldelete, sqlite, selectPage ,insert} = useSqlite(
'logs_table',
{
data: 'TXEXT',
header: 'TXEXT',
cookies: 'TXEXT',
errMsg: 'TXEXT',
config: 'TEXT',
statusCode: 'INTEGER',
date: 'TEXT',
title: 'TEXT',
userName:"TEXT"
},
'logs_table_id',
);
//查询数据
select().then(a=>console.log(a))
//新增数据
insert({
data:"",
header:"",
cookies: '',
errMsg: '',
config: '',
statusCode: '200',
date: '',
title: 'cs1',
userName:"cs1"
})
// #endif
如果你需要查询这个db文件可以通过在这个手机找到对应的文件 例如：手机\内部共享存储空间\Android\data\uni.文件\apps\uni.文件\doc\h5.db （为啥是doc参考 plus.io.PRIVATE_DOC）
还有一个方法·是通过代码进行查找 这里我写了一个把db文件发给本地nodejs的方法
/**
* 上传文件到服务器并返回下载链接。
*
* @param url - 上传目标的 URL，默认为 '/js/a/file/upload'。
* 如果传入的 URL 是完整的（以 'http' 开头），直接使用传入的 URL。
* 否则，使用 `baseUrl` 和传入的 URL 拼接形成完整的 URL。
* @param fileName - 需要上传的文件名，默认为 '_doc/h5.db'，即目标文件的名称。
* @param formDataval - 附加的表单数据，默认是一个空对象，可以用于传递额外的上传参数。
* @param pll - 文件系统的根目录，默认为 `plus.io.PRIVATE_DOC`，即私人文档目录。
*/
export const uploadFileTo = (
url : string = '/js/a/file/upload',
fileName : string = '_doc/h5.db',
formDataval : object = {
fileMd5: '42', // 假设这里传递的是文件的 MD5 值
},
pll = plus.io.PRIVATE_DOC,
) =>
new Promise((resolve, reject) => {
// 请求文件系统的根目录，获取文件系统对象 fs
plus.io.requestFileSystem(
pll, // 文件系统的根目录，默认为私人文档目录
(fs) => {
// 获取指定文件名的文件条目
fs.root.getFile(fileName, {}, (fileEntry) => {
// 获取文件对象
fileEntry.file((file) => {
// 调用 uni.uploadFile 进行文件上传
uni.uploadFile({
// 设置上传目标的 URL，判断传入的 URL 是否是完整的 HTTP 地址
// 如果是 HTTP 地址，直接使用它；否则，拼接 baseUrl 和 url 构成完整路径
url: url.startsWith('http') ? url : baseUrl + url,
name: 'file', // 文件字段名，通常用于服务器端获取文件的键名
filePath: file.fullPath, // 上传文件的完整路径，file.fullPath 是文件在本地设备的路径
formData: {
// 附加的表单数据，除了文件名，还可以传递自定义的数据
fileName: file.name, // 文件的名称
...formDataval, // 扩展表单数据，可以传递其他需要的字段
},
header: {
// 设置请求头，通常用于携带认证信息
'token':token, //你的 token 可以不添加
},
success: (uploadFileRes) => {
// 上传成功后的回调，返回上传后的文件 ID，构造下载链接 baseUrl + '/js/a/file/download/' + JSON.parse(uploadFileRes.data).fileUpload.id
let { result, message, fileUpload } = JSON.parse(uploadFileRes.data);
if (result == 'true') resolve(`${message}文件名称: ${fileUpload?.id}`);
else reject(message);
},
fail: (err) => {
// 上传失败的回调，返回错误信息给调用者
reject(`上传失败: ${err.errMsg}`);
},
});
});
});
},
// 错误处理：如果文件系统操作失败，输出错误信息
(e) => {
reject(`文件系统错误: ${e.message}`);
},
);
});
// #endif
更多推荐
19
0- 0
已为社区贡献1条内容
所有评论(0)