1.0.0 • Published 5 months ago
nw-test v1.0.0
使用说明
仅适用于 1.0 版本的 Laf
Laf 云函数使用
添加最新版 nw-lafjs 依赖后，在云函数引入
import nw from 'nw-lafjs'
export async function main(ctx: FunctionContext) {
...数据库
1.新增单条数据 (add)
支持自定义_id
/**
* add(单条记录)
* @description 将单条对象数据插入到集合中
* 注意：使用此函数添加的数据会自动加上_add_time(添加当前时间戳) 和 _add_time_str(当前时间字符串格式)
* event 请求参数 说明
* @param {string} dbName 表名
* @param {object} dataJson 需要添加的数据 (json 格式)
* @param {boolean} cancelAddTime 取消自动生成 _add_time 和 _add_time_str 字段
* @returns {string|null} res 返回值为添加数据的 id，添加失败，则返回 null
* @example
res.id = await nw.db.add({
dbName:dbName,
dataJson:{
"_id": "1",
"money": 1,
"kehuid": "001"
},
cancelAddTime : true
});
console.log(JSON.stringify(res))
*/2.批量新增多条数据 (adds)
支持自定义_id
/**
* adds(多条记录)
* @description 将数组对象插入到集合中
* @param {string} dbName 表名
* @param {Array.<object>} dataJson 需要添加的数据 (json 数组格式)
* @param {boolean} cancelAddTime 取消自动生成 _add_time 和 _add_time_str 字段
* @returns {string|null} res 返回值为添加数据的 id，添加失败，则返回 null
* @example
res.id = await nw.db.adds({
dbName:dbName,
dataJson:[]
});
*/3.根据条件删除记录 (del)
/**
* del(根据条件删除记录)
* @description 批量删除符合条件的记录，可批量删除
* @param {string} dbName 表名
* @param {object} whereJson 条件
* @returns {number} res 返回值为删除的记录数量
* @example
res.num = await nw.db.del({
dbName:dbName,
whereJson:{
_id:"1"
}
});
*/4.根据条件批量修改记录 (update)
/**
* update(根据条件修改记录)
* @description 批量修改符合条件的记录，可批量修改
* @param {string} dbName 表名
* @param {object} whereJson 条件
* @param {object} dataJson 需要修改的数据 (json 格式)
* @returns {number} res 返回值为修改的记录数量
* @example
res.num = await nw.db.update({
dbName:dbName,
whereJson:{
_add_time: _.gte(time).lte(time + 1000),
},
dataJson:{
kehuid:"001"
}
});
*/5.根据条件分页查询记录 (select)
/**
* select(根据条件查询记录)
* @description 根据条件查询记录
* @param {string} dbName 表名
* @param {boolean} getCount 是否获取符合条件的总数量，默认不获取
* @param {number} pageIndex 第几页，默认第 1 页
* @param {number} pageSize 每页显示数量，默认 10 条
* @param {object} whereJson 条件
* @param {object} fieldJson 字段显示规则，要么都为 0，要么都为 1
* @param {Array.<object>} sortArr 排序规则 asc 升序 desc 降序
* @returns {object} res 返回值
* @returns {Array.<object>} res.rows 列表
* @returns {boolean} res.hasMore 分页需要 true 还有下一页 false 无下一页
* @returns {number} res.pageIndex 当前所在页数
* @returns {number} res.pageSize 每页显示数量
* @example
res = await nw.db.select({
dbName:dbName,
getCount:true,
pageIndex:1,
pageSize:100,
whereJson:{
_add_time: _.gte(time).lte(time + 1000),
},
fieldJson:{
_id:1,
kehuid:1,
},
sortArr:[{
_add_time: asc
}]
});
*/6.万能联表查询 (selects)
/**
* selects(万能联表，多表连查)
* @params {Object} event 请求参数
* event 请求参数 说明
* @params {esm} cloud (必填)lafjs-cloud
* @params {String} dbName (必填) 表名
* @params {Object} whereJson (可选) 主表 where 条件
* @params {Number} pageIndex (可选，默认 1) 第几页
* @params {Number} pageSize (可选，默认 10) 每页显示数量
* @params {Number} getCount (可选，默认 false)true 返回关联查询前主表查询总数量，false 返回 rows 的数量
* @params {Object} fieldJson (可选) 主表字段显示规则，只能指定要返回的字段或者不要返回的字段
* @params {Array(Object)} sortArr (可选) 主表排序规则
* @params {Array(Object)} foreignDB (可选) 连表规则
* foreignDB 参数说明 数组内每一个对象代表一个连表规则
* @params {String} dbName (必填) 副表表名
* @params {String} localKey (必填) 主表外键名
* @params {String} foreignKey (必填) 副表外键名
* @params {Number} limit (可选) 关联查询的数量，1 时为对象，大于 1 为数组
* @params {String} as (必填) 副表连表结果的别名
* @params {Object} whereJson (可选) 副表 where 条件
* @params {Object} fieldJson (可选) 副表字段显示规则
* @params {Array(Object)} sortArr (可选) 副表排序规则
* res 返回值
* @params {Number} code 0 代表查询成功
* @params {Number} total getCount 为 true 返回关联查询前主表查询总数量，false 返回 rows 的数量
* @params {Array(Object)} rows 列表
* @params {Boolean} hasMore 分页需要 true 还有下一页 false 无下一页
* @params {Number} pageIndex 当前所在页数
* @params {Number} pageSize 每页显示数量
* 调用示例：
res = await nw.db.selects({
cloud:cloud,
dbName: "users",
getCount: false,
pageIndex: 1,
pageSize: 10,
// 主表 where 条件
whereJson: {
},
// 主表字段显示规则
fieldJson: {
token: false,
password: false,
},
// 主表排序规则
sortArr: [{ "name": "_id","type": "desc" }],
// 副表列表
foreignDB: [
{
dbName: "order",//副表 order
localKey:"_id",
foreignKey: "user_id",
as: "orderList",
limit: 10,
// 副表 where 条件
whereJson: {},
// 副表字段显示规则
fieldJson: {},
// 副表排序规则
sortArr: [{ "name": "time","type": "desc" }],
},
{
dbName: "vip",//副表 vip
localKey:"_id",
foreignKey: "user_id",
as: "vipInfo",
limit: 1,
}
]
});
*/7、根据 whereJson 查询对象 (findByWhereJson)
不能分页，分页请用 select
/**
* findByWhereJson
* @description 根据 whereJson 查询对象
* @param {string} dbName 表名
* @param {object} fieldJson 字段显示规则
* @param {object} whereJson 查询条件
* @param {Array.<object>} sortArr 排序规则 asc 升序 desc 降序
* @returns res 返回值为单行记录
* @example
res = await nw.db.findByWhereJson({
dbName:"users",
fieldJson:{
token:0,
password:0,
},
whereJson:{
nickname:"nw"
},
sortArr:[{
_add_time: asc
}]
});
*/8、根据 whereJson 查询多条记录（不分页）
/**
* findListByWhereJson
* @description 根据 whereJson 查询多条记录（不分页）
* @param {string} dbName 表名
* @param {object} fieldJson 字段显示规则
* @param {object} whereJson 查询条件
* @param {Array.<object>} sortArr 排序规则 asc 升序 desc 降序
* @returns res 返回值为多行记录
* @example
res = await nw.db.findListByWhereJson({
dbName:"users",
fieldJson:{
token:0,
password:0,
},
whereJson:{
nickname:"nw"
}
});
*/9、根据 _id 查询记录 (findById)
/**
* findById
* @description 根据 _id 查询记录
* @params {String} dbName 表名
* @params {String} id id
* @params {Object} fieldJson 字段显示规则 只能指定要返回的字段或者不要返回的字段
* @returns res 返回值为单行记录
* @example
res = await nw.db.findById({
dbName:dbName,
id:_id,
fieldJson: {
_id: 0,
name: 0,
},
});
*/10、根据条件查询记录数量 (count)
/**
* count(根据条件查询记录数量)
* @description 根据条件查询记录数量
* @param {string} dbName 表名
* @param {object} whereJson 条件
* @returns {number|null} res 返回值，失败返回 null
* @example
res = await nw.db.count({
dbName:dbName,
whereJson:{
_add_time: _.gte(time).lte(time + 1000),
}
});
*/11、根据条件求和 (sum)
/**
* sum(根据条件求和)
* @description 根据条件求和
* 注意：
* 1.字段必须是数值类型
* 2.若数据条数大于 10 万以上，可能会有问题
* @param {string} dbName 表名
* @param {string} fieldName 需求和的字段名 (必须是数值类型的字段)
* @param {object} whereJson 条件
* @returns {number|null} res 返回值，失败返回 null
* @example
res = await nw.db.sum({
dbName:dbName,
fieldName:"money",
whereJson:{
_add_time: _.gte(time).lte(time + 1000),
}
});
*/12、根据条件求平均值 (avg)
/**
* avg(根据条件求平均值)
* @description 根据条件求平均值
* 注意：
* 1.字段必须是数值类型
* 2.若数据条数大于 10 万以上，可能会有问题
* @param {string} dbName 表名
* @param {string} fieldName 需求平均值的字段名 (必须是数值类型的字段)
* @param {object} whereJson 条件
* @returns {number|null} res 返回值，失败返回 null
* @example
res = await nw.db.avg({
dbName:dbName,
fieldName:"money",
whereJson:{
_add_time: _.gte(time).lte(time + 1000),
}
});
*/13、根据条件求最大值 (max)
/**
* max(根据条件求最大值)
* @description 根据条件求最大值
* 注意：
* 1.字段必须是数值类型
* 2.若数据条数大于 10 万以上，可能会有问题
* @param {string} dbName 表名
* @param {string} fieldName 需求最大值的字段名 (必须是数值类型的字段)
* @param {object} whereJson 条件
* @returns {number|null} res 返回值，失败返回 null
* @example
res = await nw.db.max({
dbName:dbName,
fieldName:"money",
whereJson:{
_add_time: _.gte(time).lte(time + 1000),
}
});
*/14、根据条件求最小值 (min)
/**
* min(根据条件求最小值)
* @description 根据条件求最小值
* 注意：
* 1.字段必须是数值类型
* 2.若数据条数大于 10 万以上，可能会有问题
* @param {string} dbName 表名
* @param {string} fieldName 需求最小值的字段名 (必须是数值类型的字段)
* @param {object} whereJson 条件
* @returns {number|null} res 返回值，失败返回 null
* @example
res = await nw.db.min({
dbName:dbName,
fieldName:"money",
whereJson:{
_add_time: _.gte(time).lte(time + 1000),
}
});
*/15、根据数组对象批量更新表 (updateMany)
/**
* 根据根据数组对象批量更新
* @description 根据 根据数组对象批量更新
* @param {string} dbName 表名
* @param {array} dataArr 需要更新的数据数组
* @param {boolean} upsert 没找到符合条件的是否自动插入一条新数据
* @param {string} id 查询条件
* @returns res 更新结果
* @example
res = await nw.db.updateMany({
dbName:dbName,
dataArr: [
{
_id: "5f7b9b9b5f9b9b0001e8b1a1",
name: "nw",
},
{
_id: "5f7b9b9b5f9b9b0001e8b1a2",
name: "nw",
},
],
id: "_id", // 如果是别的字段，可以自己指定，如 id: "name"
upsert: true, //默认为 false
});
*/工具库
1、对象删除指定的字段，返回新的对象
/**
* 对象删除指定的字段，返回新的对象
* @param {Object} data 操作对象
* @param {Array<String>} deleteKeys 需要删除的键名 (数组形式)
* @returns {Object} 返回新的对象
* @example
* nw.util.deleteObjectKeys({ name: "张三", age: 18 }, ["age"]);
// { name: "张三" }
*/2、日期对象转字符串
/**
* 日期对象转字符串
* @param {Date | number | string} date 需要转换的时间
* @param {number} type 为 0 时格式为：2020-08-01 12:12:12，为 1 时格式为:20200801121212
* @returns {string} 返回字符串
* @example
nw.util.getFullTime(new Date(), 0);
// 2020-08-01 12:12:12
nw.util.getFullTime(new Date(), 1);
// 20200801121212
nw.util.getFullTime(1596278400000, 0);
// 2020-08-01 12:12:12
nw.util.getFullTime(1596278400000, 1);
// 20200801121212
nw.util.getFullTime("2020-08", 0);
// 2020-08-01 12:12:12
nw.util.getFullTime("2020-08", 1);
// 20200801121212
nw.util.getFullTime("2020-08-24", 0);
// 2020-08-24 12:12:12
nw.util.getFullTime("2020-08-24", 1);
// 20200824121212
nw.util.getFullTime("2020-08-24 12:12:12", 0);
// 2020-08-24 12:12:12
nw.util.getFullTime("2020-08-24 12:12:12", 1);
// 20200824121212
*/3、正则校验字符串类型
/**
* 正则校验字符串类型
* @param {string} str 需要校验的字符串
* @param {string} type 校验类型
* @param {string} type mobile 手机号码
* @param {string} type tel 座机
* @param {string} type card 身份证
* @param {string} type mobileCode 6 位数字验证码
* @param {string} type username 账号以字母开头，长度在 6~18 之间，只能包含字母、数字和下划线
* @param {string} type pwd 密码以字母开头，长度在 6~18 之间，只能包含字母、数字和下划线
* @param {string} type payPwd 6 位数字支付密码
* @param {string} type postal 邮政编码
* @param {string} type QQ QQ 号
* @param {string} type money 金额 (小数点 2 位)
* @param {string} type email 邮箱
* @param {string} type URL 网址
* @param {string} type IP IP 地址
* @param {string} type date 格式为：2019-10-10 年 - 月 - 日的时间
* @param {string} type time 格式为：12:00:00 小时：分钟：秒的时间
* @param {string} type dateTime 格式为：2019-10-10 12:00:00 年 - 月 - 日 小时：分钟：秒的时间
* @param {string} type number 数字
* @param {string} type english 英文
* @param {string} type chinese 中文
* @param {string} type lower 小写
* @param {string} type upper 大写
* @param {string} type HTML HTML 标记
* @returns {boolean} 返回布尔值
* @example
nw.util.checkStr("123456", "mobile");
// false
*/4、金额转换器
/**
* 金额转换器
* @description 分转换为元
* @param n 金额
* @returns 转换后的金额
* @example
nw.util.priceFilter(100)
*/5、对象属性拷贝 (浅拷贝)
/**
* 对象属性拷贝 (浅拷贝)
* @description 将 obj2 的属性赋值给 obj1 (如果 obj1 中有对应的属性，则会被 obj2 的属性值覆盖)
* @param {object} obj1
* @param {object} obj2
* @returns {object} 返回一个新的对象
* @example
nw.util.objectAssign({a:1,b:2},{b:3,c:4})
// {a:1,b:3,c:4}
nw.util.objectAssign({a:1,b:2},{b:3,c:4}) === {a:1,b:3,c:4}
// false
*/6、复制一份对象
/**
* 复制一份对象 - 没有映射关系
* @description 主要用于解除映射关系
* @param {object} obj
* @returns {object} 返回一个新的对象
* @example
nw.util.copyObject({a:1,b:2})
// {a:1,b:2}
nw.util.copyObject({a:1,b:2}) === {a:1,b:2}
// false
nw.util.copyObject({a:1,b:2}) == {a:1,b:2}
// false
nw.util.copyObject({a:1,b:2}) === nw.util.copyObject({a:1,b:2})
// false
*/7、将字符串格式的时间转为时间戳
/**
* 将字符串格式的时间转为时间戳
* @description 传入的时间格式为:2020-08-08 12:12:12
* @param {string} dateString
* @returns {number} 返回一个时间戳
* @example
nw.util.toTimeLong("2020-08-08 12:12:12")
// 1596862732000
*/8、两个 (元素为对象) 的数组合并，并去除重复的数据
/**
* 两个 (元素为对象) 的数组合并，并去除重复的数据
* @description 两个数组合并，并去除重复的数据
* @param {Array} arr1 第一个数组 (arr1 和 aar2 没有顺序要求)
* @param {Array} aar2 第二个数组
* @param {String} flag 判断标识，默认用 id 来判断，若 flag 传 -1，代表不去除重复数据
* @returns {Array} 返回一个新的数组
* @example
nw.util.arr_concat([{id:1,name:"张三"},{id:2,name:"李四"}],[{id:2,name:"李四"},{id:3,name:"王五"}])
// [{id:1,name:"张三"},{id:2,name:"李四"},{id:3,name:"王五"}]
*/9、字符串路径找对象的属性值
/**
* 字符串路径找对象的属性值
* @description 自动根据字符串路径获取对象中的值支持。和 [] , 且任意一个值为 undefined 时，不会报错，会直接返回 undefined
* @param {object} dataObj
* @param {string} name
* @returns {any} 返回一个新的数组
* @example
nw.util.getData({a:{b:{c:1}}},"a.b.c")
// 1
*/10、字符串路径设置对象的属性值
/**
* 字符串路径设置对象的属性值
* @description 自动根据字符串路径设置对象中的值 支持。和 []
* @param {object} dataObj
* @param {string} name
* @param {any} object
* @example
nw.util.setData({a:{b:{c:1}}},"a.b.c",2)
// {a:{b:{c:2}}}
nw.util.setData({a:{b:{c:1}}},"a.b.c[0]",2)
// {a:{b:{c:[2]}}}
*/11、检测任意参数是否为空
/**
* 检测任意参数是否为空
* @description 检测参数是否为空 其中 undefined、null、{}、[]、"" 均为空值 ,不要传布尔值
* @param {any} value
* @example
nw.util.isNull(value);
*/12、检测任意参数是否无值
/**
* 检测任意参数是否无值
* @description 检测参数是否无值 结果与 nw.util.isNull 相反
* @param {any} value
* @returns {boolean}
* @example
nw.util.isNotNull(value);
// true
nw.util.isNotNull(undefined);
// false
*/13、检测所有参数 - 是否全部不为空
/**
* 检测所有参数 - 是否全部不为空
* @param {any} strS 传多个参数
* @returns {boolean}
* @example
nw.util.isNotNullAll(value1,value2,value3);
// true
nw.util.isNotNullAll(value1,value2,undefined);
// false
nw.util.isNotNullAll(value1,value2,"");
// false
nw.util.isNotNullAll(value1,value2,[]);
// false
nw.util.isNotNullAll(value1,value2,{});
// false
nw.util.isNotNullAll(value1,value2,null);
// false
*/14、检测所有参数 - 是否全部为空
/**
* 检测所有参数 - 是否全部为空
* @param {any} strS 传多个参数
* @returns {boolean}
* @example
nw.util.isNullAll(value1,value2,value3);
// false
nw.util.isNullAll(value1,value2,undefined);
// true
nw.util.isNullAll(value1,value2,"");
// true
nw.util.isNullAll(value1,value2,[]);
// true
nw.util.isNullAll(value1,value2,{});
// true
nw.util.isNullAll(value1,value2,null);
// true
*/15、检测所有参数 - 是否全部都不为空
/**
* 检测所有参数 - 是否全部都不为空
* @param {any} strS 传多个参数
* @returns {boolean}
* @example
nw.util.isNotNullAll(value1,value2,value3);
// true
nw.util.isNotNullAll(value1,value2,undefined);
// false
nw.util.isNotNullAll(value1,value2,"");
// false
nw.util.isNotNullAll(value1,value2,[]);
// false
nw.util.isNotNullAll(value1,value2,{});
// false
nw.util.isNotNullAll(value1,value2,null);
// false
*/16、获取对象数组中的某一个 item，根据指定的键值
/**
* 获取对象数组中的某一个 item，根据指定的键值
* @param {Array} list 对象数组
* @param {string} key 键
* @param {string} value 值
* @returns {Object} item
* @example
nw.util.getListItem([{"_id": "001"},{"_id": "002"}], "_id", "001");
// {"_id": "001"}
*/17、数组操作 - 将对象数组转成 json
/**
* 数组操作 - 将对象数组转成 json
* @param {Array} list 对象数组
* @param {string} key 键
* @returns {Object} json
* @example
如 [{"_id":"001","name":"name1","sex":1},{"_id":"002","name":"name2","sex":2}]
转成
{"001",{"_id":"001","name":"name1","sex":1},"002":{"_id":"002","name":"name2","sex":2}}
nw.util.listToJson(list, "_id");
*/18、产生指定位数的随机数
/**
* 产生指定位数的随机数
* @param {number} length 长度
* @param {string} str 随机数的字符集 "a-z,A-Z,0-9"
* @returns {string} 随机数
* @example
nw.util.random(6);
nw.util.random(6, "a-z,0-9");
nw.util.random(6, "A-Z,0-9");
nw.util.random(6, "a-z,A-Z,0-9");
*/19、将字符串 id 转化为指定位数的纯数字字符串 id(会重复)
/**
* 将字符串 id 转化为指定位数的纯数字字符串 id(会重复)
* @param {string} str 字符串 id
* @param {number} length 长度
* @returns {string} 纯数字字符串 id
* @example
nw.util.stringIdToNumberId(uid,6);
*/20、计算运费
/**
* 计算运费
* @param {Object} freightsItem 运费模板
* @param {number} weight 重量
* @returns {number} 运费
* @example
freightsItem 运费模板
{
first_weight Integer 首重 单位 KG,
first_weight_price Integer 首重 首重价格
continuous_weight Integer 续重 单位 KG
continuous_weight_price Integer 续重价格 单位分 100 = 1 元
max_weight Integer 重量达到此值时，会多计算首重的价格，并少一次续重的价格 倍乘 (相当于拆分多个包裹)
}
weight 运费重量
nw.util.calcFreights(freightsItem, weight);
*/21、判断 B 常量数组是否至少有一个元素在 A 常量数组中存在 (两数组有交集)
/**
* 判断 B 常量数组是否至少有一个元素在 A 常量数组中存在 (两数组有交集)
* @param {Array} arr1 常量数组
* @param {Array} arr2 常量数组
* @returns {boolean} 是否有交集
* @example
nw.util.checkArrayIntersection(arr1, arr2);
*/22、判断 arr 是否为一个数组，返回一个 bool 值
/**
* 判断 arr 是否为一个数组，返回一个 bool 值
* @param {Array} arr
* @returns {boolean} 是否为数组
* @example
nw.util.isArray(arr);
*/23、深度克隆
/**
* 深度克隆
* @param {object} obj
* @returns {object} 克隆后的对象
* @example
nw.util.deepClone(obj);
*/24、数组结构转树形结构
/**
* 数组结构转树形结构
* @param {Array} originalArrayData 原始数组
* @param {Object} treeProps 转换树形结构的属性
* @returns {Array} 转换后的树形结构
* @example
nw.util.arrayToTree(arrayData,{
id: "id", // 自己的 id 字段，必填
parent_id: "pid", // 父级 id 字段，必填
children : "children", // 转换树形结构后的子级的属性值，可选，不填默认 children
need_field : ["title"] // 除 id、parent_id、children 外显示的属性，可选，不填默认全部显示
});
*/25、最简单数组去重法
/**
* 最简单数组去重法
* @param {Array} array
* @returns {Array} 去重后的数组
* @example
nw.util.uniqueArr(array);
*/26、将树形结构转成数组结构
/**
* 将树形结构转成数组结构
* @param {Array} treeData 数据源
* @param {Object} treeProps 树结构配置 { id : "menu_id", children : "children" }
* @returns {Array} 转换后的数组
* @example
nw.util.treeToArray(treeData,{
id : "menu_id", // 自己的 id 字段，必填
parent_id : "parent_id", // 父级 id 字段，必填
children : "children", // 转换树形结构后的子级的属性值，可选，不填默认 children
});
*/1.0.0
5 months ago