jinjiuxin-admin/uni_modules/vk-unicloud/vk_modules/vk-unicloud-page/libs/function/index.js

/**
 * 通用公共函数
 */
var pubfn = {};
// 防抖
import debounce from './debounce.js'
// 限流
import throttle from './throttle.js'
// url参数
import queryParams from './queryParams.js'
// H5版本的复制
import setClipboardData from './setClipboardData.js'
// 时间
import timeUtil from './timeUtil.js'
// 树形结构转换
import treeUtil from './treeUtil.js'

/**
 * 树形结构转换
 */
pubfn.treeUtil = treeUtil;
/**
 * 时间工具类
 */
pubfn.timeUtil = timeUtil;
/**
 * 防抖函数
 */
pubfn.debounce = debounce;
/**
 * 节流函数
 */
pubfn.throttle = throttle;
/**
 * 对象转url参数
 * @param {*} data,对象
 * @param {*} isPrefix,是否自动加上"?"
 * 此函数参考uView
 * vk.pubfn.queryParams(json);
 */
pubfn.queryParams = queryParams;
/**
 * 设置剪贴板
 */
pubfn.setClipboardData = setClipboardData;

/**
 * 休眠，等待（单位毫秒）
 * @param {Number} ms 毫秒
 * await vk.pubfn.sleep(1000);
 */
pubfn.sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

/**
 * 日期格式化
 * @param {Date || Number} date 需要格式化的时间
 * vk.pubfn.timeFormat(new Date(),"yyyy-MM-dd hh:mm:ss");
 */
pubfn.timeFormat = pubfn.timeUtil.timeFormat;
/**
 * 解析日期对象属性
 * @param {Date || Number} date 需要转换的时间
 * vk.pubfn.getDateInfo(new Date());
 */
pubfn.getDateInfo = pubfn.timeUtil.getDateInfo;

/**
 * 日期对象转换（此API已弃用，建议用vk.pubfn.timeFormat代替）
 * @param {Date || Number} date 需要转换的时间
 * @param {Number} type 转换方式
 * type = 0 返回 2020-08-03 12:12:12
 * type = 1 返回 20200803121212
 * type = 2 返回 { YYYY, MM, DD, hh, mm, ss }
 */
pubfn.getFullTime = pubfn.timeUtil.getFullTime;

/**
 * 获取时间范围
 * @param {Date} date 日期对象 可以指定时间计算节点，默认使用当前时间进行计算
 * 返回的是时间戳(防止时区问题)
 * 返回数据如下：
 {
   todayStart 今日开始时间
   todayEnd   今日结束时间
   today12End 今日上午结束时间
   monthStart 本月开始时间
   monthEnd   本月结束时间
   yearStart  本年开始时间
   yearEnd    本年结束时间
   weekStart  本周开始时间
   weekEnd    本周结束时间
   now        现在的时间点(含月年日时分秒)
   months     本年度每月的开始和结束时间 months[1] 代表1月
 }
 * vk.pubfn.getCommonTime();
 */
pubfn.getCommonTime = pubfn.timeUtil.getCommonTime;

/**
 * 获得指定时间偏移 year年 month月 day天 hours时 minutes分 seconds秒前或后的时间戳
 * 返回时间戳形式
vk.pubfn.getOffsetTime(new Date(), {
	year:0,
	month:0,
	day:0,
	hours:0,
	minutes:0,
	seconds:0,
	mode:"after", // after 之后 before 之前
});
 */
pubfn.getOffsetTime = pubfn.timeUtil.getOffsetTime;

/**
 * 获得相对当前时间的偏移 count 小时的起止日期(小时的开始和结束)
 * @param {Number} count  默认0 (0代表当前小时 为-1代表上一个小时 为1代表下一个小时以此类推)
 * @param {Date || Number} date 指定从哪个时间节点开始计算
 * vk.pubfn.getHourOffsetStartAndEnd(0);
 */
pubfn.getHourOffsetStartAndEnd = pubfn.timeUtil.getHourOffsetStartAndEnd;


/**
 * 获得相对当前时间的偏移 count 天的起止日期(日的开始和结束)
 * @param {Number} count  默认0 (0代表今日 为-1代表昨日 为1代表明日以此类推)
 * @param {Date || Number} date 指定从那天开始计算
 * vk.pubfn.getDayOffsetStartAndEnd(0);
 */
pubfn.getDayOffsetStartAndEnd = pubfn.timeUtil.getDayOffsetStartAndEnd;

/**
 * 获得相对当前周addWeekCount个周的起止日期
 * @param {Number} addWeekCount  默认0 (0代表本周 为-1代表上周 为1代表下周以此类推 为2代表下下周)
 * vk.pubfn.getWeekOffsetStartAndEnd(0);
 */
pubfn.getWeekOffsetStartAndEnd = pubfn.timeUtil.getWeekOffsetStartAndEnd; // 新版写法
pubfn.getWeekStartAndEnd = pubfn.timeUtil.getWeekOffsetStartAndEnd; // 兼容老版本写法

/**
 * 获得相对当前时间的偏移 count 月的起止日期(月的开始和结束)
 * @param {Number} count  默认0 (0代表本月 为-1代表上月 为1代表下月以此类推)
 * @param {Date || Number} date 指定从那天开始计算
 * vk.pubfn.getMonthOffsetStartAndEnd(0);
 */
pubfn.getMonthOffsetStartAndEnd = pubfn.timeUtil.getMonthOffsetStartAndEnd;

/**
 * 获得相对当前时间的偏移 count 个季度的起止日期（季度的开始和结束时间戳）
 * @param {Number} count  默认0（0代表本季度 -1代表上个季度 1代表下个季度以此类推）
 * @param {Date || Number} date 指定从哪个时间节点开始计算
 * vk.pubfn.getQuarterOffsetStartAndEnd(0);
 */
pubfn.getQuarterOffsetStartAndEnd = pubfn.timeUtil.getQuarterOffsetStartAndEnd;


/**
 * 获得相对当前时间的偏移 count 年的起止日期(年的开始和结束)
 * @param {Number} count  默认0 (0代表今年 为-1代表去年 为1代表明年以此类推)
 * @param {Date || Number} date 指定从那天开始计算
 * vk.pubfn.getYearOffsetStartAndEnd(0);
 */
pubfn.getYearOffsetStartAndEnd = pubfn.timeUtil.getYearOffsetStartAndEnd;

/**
 * 获得指定年份和月份后的该月的开始时间和结束时间
 * 返回数据如下：(时间戳形式)
 {
   startTime 该月开始时间
   endTime   该月结束时间
 }
vk.pubfn.getMonthStartAndEnd({
	year:2021
	month:1
});
 */
pubfn.getMonthStartAndEnd = pubfn.timeUtil.getMonthStartAndEnd;

/**
 * Vue 全局表单验证器扩展
rules: {
  receiver_mobile:[
    { validator:vk.pubfn.validator("mobile"), message: '手机号格式错误', trigger: 'blur' }
  ],
},
 */
pubfn.validator = function(type) {
	return function(rule, value, callback) {
		let key = pubfn.test(value, type);
		if (typeof callback === "function") {
			if (key || !value) {
				callback();
			} else {
				return callback(false);
			}
		} else {
			return callback(false);
		}
	}
};

/**
 * 检测文本是否满足指定格式
 * @param {String} str 需要检测的文本
 * @param {String} type 检测类型（忽略大小写）
 * @param {Boolean} allowEmpty 是否允许为空
 * 包含
 * mobile 手机号码
 * tel 座机
 * card 身份证
 * mobileCode 6位数字验证码
 * username 账号以字母开头，长度在3~32之间，只能包含字母、数字和下划线
 * pwd 密码长度在6~18之间，只能包含字母、数字和下划线
 * password 与pwd效果一致，密码长度在6~18之间，只能包含字母、数字和下划线
 * paypwd 支付密码 6位纯数字
 * postal 邮政编码
 * qq QQ号
 * email 邮箱
 * money 金额(小数点只允许2位)
 * url 网址
 * ip IP地址
 * date 日期 2020-08-03
 * time 时间 12:12:12
 * dateTime 日期+时间 2020-08-03 12:12:12
 * number 纯数字
 * english 纯英文
 * chinese 纯中文
 * english+number 英文+数字
 * english+number+_ 英文+数字+_
 * english+number+_- 英文+数字+_-
 * lower 小写
 * upper 大写
 * version 版本号 xx.xx.xx (xx必须是数字)
 * html html格式
 * image 图片
 * video 视频
 * audio 音频
 * vk.pubfn.test(str, type, allowEmpty);
 */
pubfn.test = function(str, type = "", allowEmpty=false) {
	type = type.toLowerCase();
	let newStr;
	if (allowEmpty && (str === "" || str === null || str === undefined)) {
		return true;
	}
	switch (type) {
		case 'mobile': //手机号码
			return new RegExp(/^1[3|4|5|6|7|8|9][0-9]{9}$/).test(str);
		case 'tel': //座机
			return new RegExp(/^(0\d{2,3}-\d{7,8})(-\d{1,4})?$/).test(str);
		case 'card': //身份证
			return new RegExp(/(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/).test(str);
		case 'mobilecode': //6位数字验证码
			return new RegExp(/^[0-9]{6}$/).test(str);
		case 'username': //账号以字母开头，长度在3~32之间，只能包含字母、数字和下划线
			return new RegExp(/^[a-zA-Z]([-_a-zA-Z0-9]{2,31})$/).test(str)
		case 'pwd': //密码长度在6~18之间，只能包含字母、数字和下划线和@
			return new RegExp(/^([a-zA-Z0-9_@]){6,18}$/).test(str)
		case 'password': //密码长度在6~18之间，只能包含字母、数字和下划线和@
			return new RegExp(/^([a-zA-Z0-9_@]){6,18}$/).test(str)
		case 'paypwd': //支付密码 6位纯数字
			return new RegExp(/^[0-9]{6}$/).test(str)
		case 'postal': //邮政编码
			return new RegExp(/[1-9]\d{5}(?!\d)/).test(str);
		case 'qq': //QQ号
			return new RegExp(/^[1-9][0-9]{4,9}$/).test(str);
		case 'email': //邮箱
			return new RegExp(/^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/).test(str);
		case 'money': //金额(小数点2位)
			return new RegExp(/^\d*(?:\.\d{0,2})?$/).test(str);
		case 'url': //网址
			return new RegExp(/^(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/).test(str);
		case 'ip': //IP
			return new RegExp(/^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/).test(
				str);
		case 'date': //日期 2014-01-01
			return new RegExp(/^[1-9]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])$/).test(str);
		case 'time': //时间 12:00:00
			return new RegExp(/^(20|21|22|23|[0-1]\d):[0-5]\d:[0-5]\d$/).test(str);
		case 'datetime': //日期+时间 2014-01-01 12:00:00
			return new RegExp(/^[1-9]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])\s+(20|21|22|23|[0-1]\d):[0-5]\d:[0-5]\d$/).test(str);
		case 'english+number': //英文+数字（空字符串算通过）
			return new RegExp(/^[a-zA-Z0-9]+$/).test(str);
		case 'english+number+_': //英文+数字+_（空字符串算通过）
			return new RegExp(/^[a-zA-Z0-9_]+$/).test(str);
		case 'english+number+_-': //英文+数字+_-（空字符串算通过）
			return new RegExp(/^[a-zA-Z0-9_-]+$/).test(str);
		case 'version': //版本号 xx.xx.xx（xx必须是数字）
			return new RegExp(/^([1-9]\d|[1-9])(.([1-9]\d|\d)){2}$/).test(str);
		case 'number': //数字（空字符串算通过）
			return new RegExp(/^[0-9]+$/).test(str);
		case 'english': //英文（空字符串算通过）
			return new RegExp(/^[a-zA-Z]+$/).test(str);
		case 'chinese': //中文（空字符串算通过）
			return new RegExp(/^[\u4e00-\u9fa5]+$/gi).test(str);
		case 'lower': //小写（空字符串算通过）
			return new RegExp(/^[a-z]+$/).test(str);
		case 'upper': //大写（空字符串算通过）
			return new RegExp(/^[A-Z]+$/).test(str);
		case 'html': //HTML标记
			return new RegExp(/<("[^"]*"|'[^']*'|[^'">])*>/).test(str);
		case 'image': //是否图片格式
			newStr = str.split("?")[0];
			return new RegExp(/\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg)$/).test(newStr);
		case 'video': //是否视频格式
			newStr = str.split("?")[0];
			return new RegExp(/\.(mp4|mpg|mpeg|dat|asf|avi|rm|rmvb|mov|wmv|flv|mkv|m3u8|3gp)$/).test(newStr);
		case 'audio': //是否音频格式
			newStr = str.split("?")[0];
			return new RegExp(/\.(mp3)$/).test(newStr);
		default:
			return true;
	}
};
// 保留之前的函数名
pubfn.checkStr = pubfn.test;
/**
 * 删除对象中所有值为无效值的属性（如：undefined）
 * @param {Object} obj
 * vk.pubfn.objectDeleteInvalid(obj);
 */
pubfn.objectDeleteInvalid = function(obj = {}) {
	Object.keys(obj).forEach(item => {
		if (obj[item] === undefined) {
			delete obj[item];
		}
	});
	return obj;
};
/**
 * 对象属性拷贝（浅拷贝）
 * @description 将 obj2 的属性赋值给 obj1（如果obj1中有对应的属性，则会被obj2的属性值覆盖）
 * @param {Object} 	obj1
 * @param {Object} 	obj2
 * vk.pubfn.objectAssign(obj1, obj2);
 * vk.pubfn.objectAssign(obj1, obj2, true);
 * vk.pubfn.objectAssign(obj1, obj2, false);
 */
pubfn.objectAssign = function(obj1, obj2, deleteInvalid = true) {
	if (deleteInvalid) pubfn.objectDeleteInvalid(obj2);
	return Object.assign(obj1, obj2);
};
/**
 * 复制一份对象-没有映射关系
 * @description 主要用于解除映射关系（不支持克隆函数）
 * @param {Object} 	obj
 * let newObj = vk.pubfn.copyObject(obj);
 */
pubfn.copyObject = function(obj) {
	if (typeof obj !== "undefined") {
		return JSON.parse(JSON.stringify(obj));
	} else {
		return obj;
	}
};
/**
 * 深度克隆一个对象-没有映射关系
 * @description 主要用于解除映射关系（支持克隆函数）
 * @param {Object} 	obj
 * let newObj = vk.pubfn.deepClone(obj);
 */
pubfn.deepClone = function(obj) {
	// 对常见的“非”值，直接返回原来值
	if ([null, undefined, NaN, false].includes(obj)) return obj;
	if (typeof obj !== "object" && typeof obj !== 'function') {
		//原始类型直接返回
		return obj;
	}
	let o = Object.prototype.toString.call(obj) === '[object Array]' ? [] : {};
	for (let i in obj) {
		if (obj.hasOwnProperty(i)) {
			o[i] = typeof obj[i] === "object" ? pubfn.deepClone(obj[i]) : obj[i];
		}
	}
	return o;
};
/**
 * 表单自动填充数据
 * @description 主要用于表单修改时,数据库没有默认字段会报错的问题
 * @param {Object} 	defaultData 默认数据
 * @param {Object} 	itemData		当前数据
 * that.form1 = vk.pubfn.formAssign(defaultData,itemData);
 */
pubfn.formAssign = function(defaultData, itemData) {
	let newDefaultData = pubfn.copyObject(defaultData);
	return pubfn.objectAssign(newDefaultData, itemData);
};


/**
 * 两个(元素为对象)的数组合并,并去除重复的数据
 * @param	{Array} 	arr1 	第一个数组(arr1和aar2没有顺序要求)
 * @param	{Array} 	aar2 	第二个数组
 * @param	{String} 	flag 	判断标识,默认用id来判断,若flag传-1,代表不去除重复数据
 * let arr = vk.pubfn.arr_concat(arr1, arr2, "_id");
 */
pubfn.arr_concat = function(arr1, arr2, flag) {
	if (!flag) flag = "id"; // 默认用id来判断是否是同一个对象元素
	if (!arr1) arr1 = [];
	if (!arr2) arr2 = [];
	let arr3 = arr1.concat(arr2); // 新旧数据合并
	let arr = []; // 定义一个临时数组 存放对象
	if (flag != -1) {
		let arr_id = []; // 定义一个临时数组 存放id
		for (let i in arr3) { // 循环遍历当前数组
			// 判断当前数组下标为i的元素是否已经保存到临时数组
			// 如果已保存，则跳过，否则将此元素保存到临时数组中
			if (arr_id.indexOf(arr3[i][flag]) == -1) {
				arr_id.push(arr3[i][flag]); // 添加id到数组
				arr.push(arr3[i]); // 添加对象到数组
			}
		}
	} else {
		arr = arr3;
	}
	return arr;
};
/**
 * 自动根据字符串路径获取对象中的值支持.和[] , 且任意一个值为undefined时,不会报错,会直接返回undefined
 * @param	{Object} dataObj 数据源
 * @param	{String} name 支持a.b 和 a[b]
 * @param	{String} defaultValue undefined时的默认值
 * vk.pubfn.getData(dataObj, name);
 */
pubfn.getData = function(dataObj, name, defaultValue) {
	let newDataObj;
	if (pubfn.isNotNull(dataObj)) {
		newDataObj = JSON.parse(JSON.stringify(dataObj));
		let k = "",
			d = ".",
			l = "[",
			r = "]";
		name = name.replace(/\s+/g, k) + d;
		let tstr = k;
		for (let i = 0; i < name.length; i++) {
			let theChar = name.charAt(i);
			if (theChar != d && theChar != l && theChar != r) {
				tstr += theChar;
			} else if (newDataObj) {
				if (tstr != k) newDataObj = newDataObj[tstr];
				tstr = k;
			}
		}
	}
	if (typeof newDataObj === "undefined" && typeof defaultValue !== "undefined") newDataObj = defaultValue;
	return newDataObj;
};
/**
 * 自动根据字符串路径设置对象中的值 支持.和[]
 * @param	{Object} dataObj 数据源
 * @param	{String} name 支持a.b 和 a[b]
 * @param	{String} value 值
 * vk.pubfn.setData(dataObj, name, value);
 */
pubfn.setData = function(dataObj, name, value) {
	// 通过正则表达式  查找路径数据
	let dataValue;
	if (typeof value === "object") {
		dataValue = pubfn.copyObject(value);
	} else {
		dataValue = value;
	}
	let regExp = new RegExp("([\\w$-]+)|\\[(:\\d)\\]", "g");
	const patten = name.match(regExp);
	// 遍历路径  逐级查找  最后一级用于直接赋值
	for (let i = 0; i < patten.length - 1; i++) {
		let keyName = patten[i];
		if (typeof dataObj[keyName] !== "object") dataObj[keyName] = {};
		dataObj = dataObj[keyName];
	}
	// 最后一级
	dataObj[patten[patten.length - 1]] = dataValue;
};

/**
 * 检测参数是否为空 其中 undefined、null、{}、[]、"" 均为空值  true 空值  false 有值
 * vk.pubfn.isNull(value);
 */
pubfn.isNull = function(value) {
	let key = false;
	if (
		typeof value == "undefined" ||
		Object.prototype.toString.call(value) == "[object Null]" ||
		JSON.stringify(value) == "{}" ||
		JSON.stringify(value) == "[]" ||
		value === "" ||
		JSON.stringify(value) === undefined
	) {
		key = true;
	}
	return key;
};
/**
 * 检测参数是否不为空 结果与 vk.pubfn.isNull 相反
 * vk.pubfn.isNotNull(value);
 */
pubfn.isNotNull = function(value) {
	return !pubfn.isNull(value);
};
/**
 * 检测所有参数 - 是否至少有一个为空
 * vk.pubfn.isNullOne(value1,value2,value3);
 */
pubfn.isNullOne = function(...strS) {
	let key = false;
	for (let i = 0; i < strS.length; i++) {
		let str = strS[i];
		if (pubfn.isNull(str)) {
			key = true;
			break;
		}
	}

	return key;
};
/**
 * 检测整个对象是否没有一个属性是空值,如果有空值,则返回首个是空值的属性名
 let nullKey = vk.pubfn.isNullOneByObject({ value1,value2,value3 });
 if(nullKey) return { code : -1, msg : `${nullKey}不能为空` };
 */
pubfn.isNullOneByObject = function(obj) {
	let key;
	for (let name in obj) {
		let val = obj[name];
		if (pubfn.isNull(val)) {
			key = name;
			break;
		}
	}
	return key;
};
/**
 * 检测所有参数 - 是否全部为空
 * vk.pubfn.isNullAll(value1,value2,value3);
 */
pubfn.isNullAll = function(...strS) {
	let key = true;
	for (let i = 0; i < strS.length; i++) {
		let str = strS[i];
		if (pubfn.isNotNull(str)) {
			key = false;
			break;
		}
	}
	return key;
};

/**
 * 检测所有参数 - 是否全部都不为空
 * vk.pubfn.isNotNullAll(value1,value2,value3);
 */
pubfn.isNotNullAll = function(...strS) {
	return !pubfn.isNullOne(...strS);
};
/**
 * 获取对象数组中的某一个item,根据指定的键名和键值
 * @description 主要用于在一个对象数组中快速获取 _id = 1 的对象
 * @param	{Array} list 数据源
 * @param	{String} key 键名(不可为空)
 * @param	{String} value 键值 (不可为空)
 * vk.pubfn.getListItem(list, key, value);
 */
pubfn.getListItem = function(list, key, value) {
	let item;
	for (let i = 0; i < list.length; i++) {
		if (list[i][key] === value) {
			item = list[i];
			break;
		}
	}
	return item;
};
/**
 * 获取对象数组中某个元素的index,根据指定的键名和键值
 * @description 主要用于在一个对象数组中快速获取 _id = 1 的index
 * @param	{Array} list 数据源
 * @param	{String} key 键名
 * @param	{String} value 键值
 * vk.pubfn.getListIndex(list, key, value);
 */
pubfn.getListIndex = function(list, key, value) {
	let index = -1;
	for (let i = 0; i < list.length; i++) {
		if (list[i][key] === value) {
			index = i;
			break;
		}
	}
	return index;
};
/**
 * 获取对象数组中某个元素的index,根据指定的键名和键值
 * @description 主要用于在一个对象数组中快速获取 _id = 1 的index
 * @param	{Array} list 数据源
 * @param	{String} key 键名
 * @param	{String} value 键值
 * vk.pubfn.getListItemIndex(list, key, value);
 */
pubfn.getListItemIndex = function(list, key, value) {
	let obj = {};
	let item;
	let index = -1;
	for (let i = 0; i < list.length; i++) {
		if (list[i][key] === value) {
			index = i;
			item = list[i];
			break;
		}
	}
	obj = {
		item,
		index
	}
	return obj;
};
/**
 * 数组转对象 - 将对象数组转成json
 * 如[{"_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}}
 * vk.pubfn.arrayToJson(list, "_id");
 */
pubfn.arrayToJson = function(list, key) {
	let json = {};
	for (let i in list) {
		let item = list[i];
		json[item[key]] = item;
	}
	return json;
};
pubfn.listToJson = pubfn.arrayToJson;

/**
 * 从数组中提取指定字段形式成为新的数组
 * 如[{"_id":"001","name":"name1","sex":1},{"_id":"002","name":"name2","sex":2}]
 * 提取_id字段转成
 * ["001","002"]
 * let idArr = vk.pubfn.arrayObjectGetArray(list, "_id");
 */
pubfn.arrayObjectGetArray = function(list, key) {
	return list.map(obj => { return obj[key] });
};

/**
 * 产生指定位数的随机数(支持任意字符,默认纯数字)
 * @param	{Number} length 随机数固定位数
 * @param	{String} range 指定的字符串中随机范围
 * @param	{Array} arr 产生的随机数不会和此数组的任意一项重复
 * vk.pubfn.random(6);
 * vk.pubfn.random(6, "abcdefghijklmnopqrstuvwxyz0123456789");
 * vk.pubfn.random(1,"12",["1","2"]);
 */
pubfn.random = function(length, range, arr) {
	let s;
	if (pubfn.isNull(arr)) {
		s = pubfn.randomFn(length, range);
	} else {
		let i = 0;
		let maxForCount = 100000;
		do {
			i++;
			s = pubfn.randomFn(length, range);
		} while (arr.indexOf(s) > -1 && i < maxForCount);
		if (i === maxForCount) {
			s = undefined;
		}
	}
	return s;
};
/**
 * 产生指定位数的随机数(支持任意字符,默认纯数字)
 * @param	{Number} length 随机数固定位数
 * @param	{String} range 指定的字符串中随机范围
 * vk.pubfn.random(6);
 * vk.pubfn.random(6, "abcdefghijklmnopqrstuvwxyz0123456789");
 */
pubfn.randomFn = function(length, range) {
	let s = "";
	let list = "123456789";
	//0123456789QWERTYUIPASDFGHJKLZXCVBNM
	if (pubfn.isNotNull(range)) {
		if (range == "a-z,0-9") {
			range = "abcdefghijklmnopqrstuvwxyz0123456789";
		} else if (range == "A-Z,0-9") {
			range = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
		} else if (range == "a-z,A-Z,0-9" || range == "A-Z,a-z,0-9") {
			range = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
		}
		list = range;
	}
	for (let i = 0; i < length; i++) {
		let code = list[Math.floor(Math.random() * list.length)];
		s += code;
	}
	return s;
};

/**
 * 将字符串id转化为指定位数的纯数字字符串id(会重复)
 * vk.pubfn.stringIdToNumberId(uid,8);
 */
pubfn.stringIdToNumberId = function(str, length) {
	let s = "";
	let list = "0123456789";
	for (let i = 0; i < length; i++) {
		if (str.length > i) {
			let index = str[i].charCodeAt() % 10;
			s += list[index];
		} else {
			s = "0" + s;
		}
	}
	return s;
};

/**
 * 将手机号,账号等隐藏中间字段
 * @param {String} str   需要转换的字符串
 * @param {Number} first 前面显示的字符数量
 * @param {Number} last  后面显示的字符数量
 * vk.pubfn.hidden(str, first, last);
 */
pubfn.hidden = function(str = "", first = 0, last = 0) {
	let len = str.length - first - last;
	let xing = '';
	for (let i = 0; i < len; i++) {
		xing += '*';
	}
	return str.substring(0, first) + xing + str.substring(str.length - last);
};
/**
 * 判断常量数组A是否至少有一个元素在常量数组B中存在(两数组有交集)
 * @param {Array} arr1 数组A
 * @param {Array} arr2 数组B
 * vk.pubfn.checkArrayIntersection(arr1, arr2);
 */
pubfn.checkArrayIntersection = function(arr1 = [], arr2 = []) {
	let checkKey = false;
	for (let i = 0; i < arr2.length; i++) {
		if (arr1.indexOf(arr2[i]) > -1) {
			checkKey = true;
		}
	}
	return checkKey;
};
/**
 * 检测数据源是否满足表达式规则
 * @param {Object} data 数据源
 * @param {String} expText 表达式文本
 * vk.pubfn.checkDataExpText(data, expText);
 */
pubfn.checkDataExpText = function(data = {}, expText) {
	expText = expText.replace(new RegExp("\\s", "g"), "");
	//console.log("expText:",expText);
	let orArr = expText.split("||");
	//console.log("orArr",orArr);
	let checkKey = false;
	for (let index1 = 0; index1 < orArr.length; index1++) {
		let orItem = orArr[index1];
		let andArr = orItem.split("&&");
		//console.log("andArr",andArr);
		let itemKey = true;
		for (let index2 = 0; index2 < andArr.length; index2++) {
			let andItem = andArr[index2];
			//console.log("andItem",andItem);
			if (andItem.indexOf("!=") > -1) {
				let andItemArr = andItem.split("!=");
				let key = andItemArr[0];
				let value = andItemArr[1];
				let formValue = pubfn.getData(data,key);
				
				itemKey = String(formValue) !== value ? true : false;
				
			} else if (andItem.indexOf("==") > -1) {
				let andItemArr = andItem.split("==");
				let key = andItemArr[0];
				let value = andItemArr[1];
				let formValue = pubfn.getData(data,key);
				
				itemKey = String(formValue) == value ? true : false;
				
			} else if (andItem.indexOf(">=") > -1) {
				let andItemArr = andItem.split(">=");
				let key = andItemArr[0];
				let value = andItemArr[1];
				let formValue = pubfn.getData(data,key);
				if (isNaN(value)) {
					if (typeof formValue !== "undefined") itemKey = String(formValue) >= value ? true : false;
					if (typeof formValue === "undefined" || formValue === null) itemKey = false;
				} else {
					if (typeof formValue !== "undefined") itemKey = formValue >= Number(value) ? true : false;
					if (typeof formValue === "undefined" || formValue === null) itemKey = false;
				}
			} else if (andItem.indexOf(">") > -1) {
				let andItemArr = andItem.split(">");
				let key = andItemArr[0];
				let value = andItemArr[1];
				let formValue = pubfn.getData(data,key);
				if (isNaN(value)) {
					if (typeof formValue !== "undefined") itemKey = String(formValue) > value ? true : false;
					if (typeof formValue === "undefined" || formValue === null) itemKey = false;
				} else {
					if (typeof formValue !== "undefined") itemKey = formValue > Number(value) ? true : false;
					if (typeof formValue === "undefined" || formValue === null) itemKey = false;
				}
			} else if (andItem.indexOf("<=") > -1) {
				let andItemArr = andItem.split("<=");
				let key = andItemArr[0];
				let value = andItemArr[1];
				if (isNaN(value)) {
					if (typeof data[key] !== "undefined") itemKey = String(data[key]) <= value ? true : false;
					if (typeof data[key] === "undefined" || data[key] === null) itemKey = false;
				} else {
					if (typeof data[key] !== "undefined") itemKey = data[key] <= Number(value) ? true : false;
					if (typeof data[key] === "undefined" || data[key] === null) itemKey = false;
				}
			} else if (andItem.indexOf("<") > -1) {
				let andItemArr = andItem.split("<");
				let key = andItemArr[0];
				let value = andItemArr[1];
				let formValue = pubfn.getData(data,key);
				if (isNaN(value)) {
					if (typeof formValue !== "undefined") itemKey = String(formValue) < value ? true : false;
					if (typeof formValue === "undefined" || formValue === null) itemKey = false;
				} else {
					if (typeof formValue !== "undefined") itemKey = formValue < Number(value) ? true : false;
					if (typeof formValue === "undefined" || formValue === null) itemKey = false;
				}
			} else if (andItem.indexOf("{in}") > -1) {
				let andItemArr = andItem.split("{in}");
				let key = andItemArr[0];
				let value = andItemArr[1];
				let formValue = pubfn.getData(data,key);
				if (Array.isArray(formValue)) {
					let index = formValue.findIndex(item => {
						return item.toString() === value.toString();
					});
					itemKey = index > -1 ? true : false;
				} else {
					itemKey = false;
				}
				//itemKey = (Array.isArray(formValue) && formValue.indexOf(value) > -1 ) ? true : false;
			} else if (andItem.indexOf("{nin}") > -1) {
				let andItemArr = andItem.split("{nin}");
				let key = andItemArr[0];
				let value = andItemArr[1];
				let formValue = pubfn.getData(data,key);
				if (Array.isArray(formValue)) {
					let index = formValue.findIndex(item => {
						return item.toString() === value.toString();
					});
					itemKey = index < 0 ? true : false;
				} else {
					itemKey = false;
				}
				//itemKey = (Array.isArray(formValue) && formValue.indexOf(value) < 0 ) ? true : false;
			} else {
				let andItemArr = andItem.split("=");
				let key = andItemArr[0];
				let value = andItemArr[1];
				let formValue = pubfn.getData(data,key);
				
				itemKey = String(formValue) == value ? true : false;
				
				//console.log("key:",key,"value:",value,"formValue",formValue.toString(),"itemKey:",itemKey);
			}
			if (!itemKey) {
				break;
			}
		}
		if (itemKey) {
			checkKey = true;
			break;
		}
	}
	return checkKey;
};

/**
 * 判断变量是否是数组
 * vk.pubfn.isArray(value);
 */
pubfn.isArray = function(value) {
	return Object.prototype.toString.call(value) === "[object Array]" ? true : false;
};
/**
 * 判断变量是否是对象
 * vk.pubfn.isObject(value);
 */
pubfn.isObject = function(value) {
	return Object.prototype.toString.call(value) === "[object Object]" ? true : false;
};



/**
 * 计算运费
 *  @param {Object} freightItem 运费模板
 {
   first_weight             Number 首重（KG）
   first_weight_price       Number 首重 首重价格（100=1元）
   continuous_weight        Number 续重（KG）
   continuous_weight_price  Number 续重价格（100=1元）
   max_weight               Number 重量达到此值时（KG），会多计算首重的价格，并少一次续重的价格 倍乘（相当于拆分多个包裹）
 }
 * @param {Number} weight 运费重量
 * 返回值
 * @return {Number} 最终运费金额（100=1元）
 * vk.pubfn.calcFreights(freightItem, weight);
 */
pubfn.calcFreights = function(freightItem, weight) {
	let freightRes = vk.pubfn.calcFreightDetail(freightItem, weight);
	return freightRes.total_amount;
};

/**
 * 计算运费，返回细节
 * @param {Object} freightItem 运费模板
 {
   first_weight             Number 首重（KG）
   first_weight_price       Number 首重 首重价格（100=1元）
   continuous_weight        Number 续重（KG）
   continuous_weight_price  Number 续重价格（100=1元）
   max_weight               Number 重量达到此值时（KG），会多计算首重的价格，并少一次续重的价格 倍乘（相当于拆分多个包裹）
 }
 * @param {Number} weight 需要计算的商品重量
 * 返回值
 * @return {Number} weight 运费重量（KG）
 * @return {Number} first_weight_price 首重金额（100=1元）
 * @return {Number} continuous_weight_price 续重金额（100=1元）
 * @return {Number} total_amount 最终运费金额（100=1元）
 * @return {String} formula 运费计算公式字符串
 * let freightRes = vk.pubfn.calcFreightDetail(freightItem, weight);
 */
pubfn.calcFreightDetail = function(freightItem, weight) {
	let {
		first_weight, // 首重（KG）
		first_weight_price, // 首重价格（元）
		continuous_weight, // 续重（KG）
		continuous_weight_price, // 续重价格（元）
		max_weight, // 拆包裹，每个包裹最大重量（KG）
	} = freightItem;
	if (!max_weight) max_weight = 1000000000;
	let originalWeight = weight;
	let money = 0; // 运费
	let first_weight_count = 0; // 包裹数量
	let packagesSurplusWeight = max_weight; // 包裹剩余重量
	let first_weight_key = false; // 是否已减过首重
	let continuous_weight_count = 0; // 续重次数
	let logArr = [];
	let logRun = false;
	while (weight > 0) {
		if (!first_weight_key) {
			// 首重
			first_weight_key = true;
			first_weight_count++;
			packagesSurplusWeight = max_weight; // 还原包裹剩余重量
			weight -= first_weight;
			packagesSurplusWeight -= first_weight;
		} else {
			// 续重
			continuous_weight_count++;
			weight -= continuous_weight;
			packagesSurplusWeight -= continuous_weight;
		}
		if (logRun) logArr.push({
			"总重量剩余": weight,
			"当前包裹重量剩余": packagesSurplusWeight,
			"当前第几个包裹": first_weight_count,
			"续重计算次数": continuous_weight_count
		});

		if (packagesSurplusWeight <= 0) {
			// 需要增加一个新的包裹
			first_weight_key = false; // 新包裹设置没有减过首重
		}
	}
	if (logRun) console.log(JSON.stringify(logArr));
	let total_amount = first_weight_price * first_weight_count + continuous_weight_price * continuous_weight_count;
	let res = {
		weight: originalWeight, // 商品重量（KG）
		first_weight, // 首重步长
		first_weight_price, // 首重单价
		first_weight_count, // 首重计算次数
		continuous_weight, // 续重步长
		continuous_weight_price, // 续重单价
		continuous_weight_count, // 续重计算次数
		first_weight_amount: first_weight_count * first_weight_price, // 首重总金额
		continuous_weight_amount: continuous_weight_price * continuous_weight_count, // 续重总金额
		total_amount, // 最终运费金额
		formula: `${first_weight_price} * ${first_weight_count} + ${continuous_weight_price} * ${continuous_weight_count} = ${total_amount}`, // 运费计算公式
	};
	return res;
};


/**
 * 从一个对象中取多个属性,并生成一个全新的对象,会过滤空字符串,空数组,空对象
 * @param {Object} obj 对象
 * @param {Array<String>} keys 键名数组
 * vk.pubfn.getNewObject(obj, keys);
 */
pubfn.getNewObject = function(obj, keys) {
	let selectedObj = pubfn.copyObject(obj);
	let newObject = {};
	if (keys && keys.length > 0) {
		for (let i in keys) {
			let key = keys[i];
			if (pubfn.isNotNull(selectedObj[key])) {
				newObject[key] = selectedObj[key];
			}
		}
	} else {
		newObject = selectedObj;
	}
	return newObject;
};

/**
 * 对象删除指定的字段,返回新的对象
 * @param {Object} data  操作对象
 * @param {Array<String>} deleteKeys 需要删除的键名(数组形式)
 * vk.pubfn.deleteObjectKeys(data, deleteKeys);
 */
pubfn.deleteObjectKeys = function(data, deleteKeys = []) {
	let newData = {};
	if (data) {
		for (let key in data) {
			if (deleteKeys.indexOf(key) == -1) {
				newData[key] = data[key];
			}
		}
	}
	return newData;
}

/**
 * 数组结构转树形结构
 * @param {Array} treeData  数据源
 * @param {Object} treeProps 树结构配置
 * { id:"_id", parent_id:"parent_id", children:"children",need_field:["_id","name"],deleteParentId:true }
 * vk.pubfn.arrayToTree(treeData, treeProps);
 */
pubfn.arrayToTree = pubfn.treeUtil.arrayToTree;
/**
 * 树形结构转数组结构
 * @param {Array} treeData  数据源
 * @param {Object} treeProps 树结构配置
 * { id:"_id", parent_id:"parent_id", children:"children", deleteChildren:true }
 * vk.pubfn.treeToArray(treeData, treeProps);
 */
pubfn.treeToArray = pubfn.treeUtil.treeToArray;

/**
 * 通配符匹配
 * @param {String} text  被匹配的文本
 * @param {String} expText 通配符规则
 * vk.pubfn.wildcardTestOne(text, expText);
 */
pubfn.wildcardTestOne = function(text, expText) {
	if (!expText) return false;
	let regExpText = expText.replace(new RegExp("\\*"), "(.*)");
	let startText = expText.indexOf("*") !== 0 ? "^" : "";
	let endText = expText[expText.length - 1] !== "*" ? "$" : "";
	let regExp = new RegExp(startText + regExpText + endText);
	return regExp.test(text);
};
/**
 * 通配符匹配 expText支持数组
 * @param {String} text  被匹配的文本
 * @param {String | Array<String>} expText 通配符规则
 * vk.pubfn.wildcardTest(text, expText);
 */
pubfn.wildcardTest = function(text, expText) {
	let matchNum = 0; // 被匹配的次数
	let regExp1 = new RegExp("\\*");
	if (typeof expText === "string") {
		// 字符串
		if (pubfn.wildcardTestOne(text, expText)) {
			matchNum++;
		}
	} else if (typeof expText === "object") {
		// 数组
		for (let i = 0; i < expText.length; i++) {
			let expTextItem = expText[i];
			if (pubfn.wildcardTestOne(text, expTextItem)) {
				matchNum++;
			}
		}
	}
	return matchNum;
}

/**
 * 正则匹配
 * @param {String} text  被匹配的文本
 * @param {String} expText 正则表达式规则
 * vk.pubfn.regExpTestOne(text, expText);
 */
pubfn.regExpTestOne = function(text, expText) {
	if (!expText) return false;
	let regExp = new RegExp(expText);
	return regExp.test(text);
};

/**
 * 正则匹配
 * @param {String} text  被匹配的文本
 * @param {String || Array<String>} wildcardExp 正则表达式规则
 * vk.pubfn.regExpTest(text, regExp);
 */
pubfn.regExpTest = function(text, expText) {
	let matchNum = 0; // 被匹配的次数
	if (typeof expText === "string") {
		// 字符串
		if (pubfn.regExpTestOne(text, expText)) {
			matchNum++;
		}
	} else if (typeof expText === "object") {
		// 数组
		for (let i = 0; i < expText.length; i++) {
			let expTextItem = expText[i];
			if (pubfn.regExpTestOne(text, expTextItem)) {
				matchNum++;
			}
		}
	}
	return matchNum;
}

/**
 * 产生订单号，不依赖数据库，高并发时性能高（理论上会重复，但概率非常非常低）
 * @param {String} prefix 前缀
 * @param {Number} num 位数，建议在25-30之间，默认25
 * vk.pubfn.createOrderNo();
 */
pubfn.createOrderNo = function(prefix = "", num = 25) {
	// 获取当前时间字符串格式如20200803093000123
	let fullTime = vk.pubfn.timeFormat(new Date(), "yyyyMMddhhmmss");
	fullTime = fullTime.substring(2);
	let randomNum = num - (prefix + fullTime).length;
	return prefix + fullTime + pubfn.random(randomNum);
};

const isSnakeCase = new RegExp('_(\\w)', 'g');
const isCamelCase = new RegExp('[A-Z]', 'g');

function parseObjectKeys(obj, type) {
	let parserReg;
	let parser;
	switch (type) {
		case 'snake2camel':
			parser = pubfn.snake2camel
			parserReg = isSnakeCase
			break
		case 'camel2snake':
			parser = pubfn.camel2snake
			parserReg = isCamelCase
			break
	}
	for (const key in obj) {
		if (Object.prototype.hasOwnProperty.call(obj, key)) {
			if (parserReg.test(key)) {
				const keyCopy = parser(key)
				obj[keyCopy] = obj[key]
				delete obj[key]
				if (Object.prototype.toString.call((obj[keyCopy])) === '[object Object]') {
					obj[keyCopy] = parseObjectKeys(obj[keyCopy], type)
				} else if (Array.isArray(obj[keyCopy])) {
					obj[keyCopy] = obj[keyCopy].map((item) => {
						return parseObjectKeys(item, type)
					})
				}
			}
		}
	}
	return obj
}
/**
 * 字符串 - 蛇形转驼峰
 * @param {String} value
 * vk.pubfn.snake2camel(value);
 */
pubfn.snake2camel = function(value) {
	return value.replace(isSnakeCase, (_, c) => (c ? c.toUpperCase() : ''))
}
/**
 * 字符串 - 驼峰转蛇形
 * @param {String} value
 * vk.pubfn.camel2snake(value);
 */
pubfn.camel2snake = function(value) {
	return value.replace(isCamelCase, str => '_' + str.toLowerCase())
}

/**
 * 对象内的属性名 - 蛇形转驼峰
 * @param {Object} obj
 * vk.pubfn.snake2camelJson(obj);
 */
pubfn.snake2camelJson = function(obj) {
	return parseObjectKeys(obj, 'snake2camel');
};
/**
 * 对象内的属性名 - 驼峰转蛇形
 * @param {Object} obj
 * vk.pubfn.camel2snakeJson(obj);
 */
pubfn.camel2snakeJson = function(obj) {
	return parseObjectKeys(obj, 'camel2snake');
};

/**
 * 将能转成数字的字符串转数字（支持字符串、对象、数组）
 * @param {Any} obj
 * @param {Object} option 哪些格式需要排除
 * 默认排除
 * mobile:true 手机号，如 15200000001
 * idCard:true 身份证，如 330154202109301214
 * startFrom0:true 第一位是0，且长度大于1的，同时第二位不是.的字符串  如 01，057189101254
 * maxLength:14 超过此长度的字符串排除
 * vk.pubfn.string2Number(obj, option);
 */
pubfn.string2Number = function(obj, option = {}) {
	const type = Object.prototype.toString.call(obj).slice(8, -1).toLowerCase();
	switch (type) {
		case 'string':
			if (obj && !isNaN(obj)) {
				let {
					mobile = true,
						idCard = true,
						startFrom0 = true,
						maxLength = 14,
				} = option;
				if (obj.length > maxLength) {
					return obj;
				} else if (mobile && pubfn.test(obj, "mobile")) {
					return obj;
				} else if (idCard && pubfn.test(obj, "card")) {
					return obj;
				} else if (startFrom0 && obj.length > 1 && obj.indexOf("0") === 0 && obj.indexOf(".") !== 1) {
					return obj;
				}
				return Number(obj);
			} else {
				return obj;
			}
			case 'object':
				const keys = Object.keys(obj);
				for (let i = 0; i < keys.length; i++) {
					const key = keys[i];
					obj[key] = pubfn.string2Number(obj[key]);
				}
				return obj;
			case 'array':
				for (let i = 0; i < obj.length; i++) {
					obj[i] = pubfn.string2Number(obj[i]);
				}
				return obj;
			default:
				return obj;
	}
};

/**
 * 保留小数
 * @param {Number} val 原值
 * @param {Number} precision 精度
 * vk.pubfn.toDecimal(val, 2);
 */
pubfn.toDecimal = function(val, precision = 0) {
	if (typeof val === "string") val = Number(val);
	return parseFloat(val.toFixed(precision));
};

/**
 * 判断文件url的类型
 * @param {String} url 文件的url路径
 * vk.pubfn.getFileType(url);
 * 返回值为字符串
 * image 图片
 * video 视频
 * audio 音频
 * other 其他
 */
pubfn.getFileType = function(url) {
	let fileType;
	if (pubfn.checkFileSuffix(url, ["png", "jpg", "jpeg", "gif", "bmp", "svg"])) {
		fileType = "image";
	} else if (pubfn.checkFileSuffix(url, ["avi", "mp4", "3gp", "mov", "rmvb", "rm", "flv", "mkv"])) {
		fileType = "video";
	} else if (pubfn.checkFileSuffix(url, ["mp3"])) {
		fileType = "audio";
	} else {
		fileType = "other";
	}
	return fileType;
};
/**
 * 获取文件url的后缀名
 * @param {String} url 文件的url路径，必须带
 * vk.pubfn.getFileSuffix(url);
 */
pubfn.getFileSuffix = function(url) {
	let suffix;
	let index = url.lastIndexOf(".");
	if (index > -1) {
		suffix = url.substring(index + 1);
	}
	return suffix;
};

/**
 * 判断文件url是否在指定后缀名数组内
 * @param {String} url 文件的url路径
 * @param {Array<String>} list 后缀名列表
 * vk.pubfn.checkFileSuffix(url,["png", "jpg", "jpeg", "gif", "bmp", "svg"]);
 */
pubfn.checkFileSuffix = function(url, list) {
	let key = false;
	let suffix = pubfn.getFileSuffix(url);
	for (let i = 0; i < list.length; i++) {
		if (list.indexOf(suffix) > -1) {
			key = true;
			break;
		}
	}
	return key;
};
// 前端专属开始 -----------------------------------------------------------
/**
 * 将时间显示成1秒前、1天前
 * @description 主要用于 文章最后回复时间: 1分钟前
 * @param {String || Number} 	startTime	需要计算的时间 如文章最后回复时间
 * vk.pubfn.dateDiff(startTime);
 */
pubfn.dateDiff = function(startTime, suffix = "前") {
	if (!startTime) {
		return "";
	}
	if (typeof startTime === "string" && !isNaN(startTime)) startTime = Number(startTime);
	if (typeof startTime == "number") {
		if (startTime.toString().length == 10) startTime *= 1000;
		startTime = new Date(startTime);
		startTime = pubfn.timeFormat(startTime);
	}
	if (typeof startTime == "string") {
		startTime = startTime.replace("T", " ");
		startTime = startTime;
		startTime = new Date(startTime.replace(/-/g, "/")); //将-转化为/，使用new Date
	}
	let endTime = new Date(); //获取当前时间
	let nd = 1000 * 24 * 60 * 60; //一天的毫秒数
	let nh = 1000 * 60 * 60; //一小时的毫秒数
	let nm = 1000 * 60; //一分钟的毫秒数
	let ns = 1000; //一秒钟的毫秒数long diff;try {
	let diff = endTime.getTime() - startTime.getTime();
	let day = Math.floor(diff / nd); //计算差多少天
	let hour = Math.floor(diff % nd / nh); //计算差多少小时
	let min = Math.floor(diff % nd % nh / nm); //计算差多少分钟
	let sec = Math.round(diff % nd % nh % nm / ns); //计算差多少秒//输出结果
	let showStr = "1 秒";
	if (day > 0) {
		showStr = day + "天";
	} else if (hour > 0) {
		showStr = hour + "小时";
	} else if (min > 0) {
		showStr = min + "分钟";
	} else if (sec > 0) {
		showStr = sec + "秒";
	}
	showStr += suffix;
	return showStr;
}
/**
 * 将时间显示成1秒、1天
 * @description 主要用于 到期时间剩余 : 3天 这样的场景
 * @param {String || Number} endTime	需要计算的时间 如到期时间
 * vk.pubfn.dateDiff2(endTime);
 */
pubfn.dateDiff2 = function(startTime, str = "1秒") {
	if (!startTime) {
		return "";
	}
	if (typeof startTime === "string" && !isNaN(startTime)) startTime = Number(startTime);
	if (typeof startTime == "number") {
		if (startTime.toString().length == 10) startTime *= 1000;
		startTime = new Date(startTime);
		startTime = pubfn.timeFormat(startTime);
	}
	if (typeof startTime == "string") {
		startTime = startTime.replace("T", " ");
		startTime = startTime;
		startTime = new Date(startTime.replace(/-/g, "/")); //将-转化为/，使用new Date
	}
	let endTime = new Date(); //获取当前时间
	let nd = 1000 * 24 * 60 * 60; //一天的毫秒数
	let nh = 1000 * 60 * 60; //一小时的毫秒数
	let nm = 1000 * 60; //一分钟的毫秒数
	let ns = 1000; //一秒钟的毫秒数long diff;try {
	let diff = startTime.getTime() - endTime.getTime();
	let day = Math.floor(diff / nd);
	let hour = Math.floor(diff % nd / nh);
	let min = Math.floor(diff % nd % nh / nm);
	let sec = Math.round(diff % nd % nh % nm / ns);
	let showStr = str;
	if (day > 0) {
		showStr = day + "天";
	} else if (hour > 0) {
		showStr = hour + "小时";
	} else if (min > 0) {
		showStr = min + "分钟";
	} else if (sec > 0) {
		showStr = sec + "秒";
	}
	return showStr;
};
/**
 * 将大数字转中文
 * @description 主要用于展示浏览量等不需要非常精确显示的场景
 * 如:
 * 3210 -> 3千
 * 31210 -> 3万
 * 1523412 -> 1百万
 * 15234120 ->1千万
 * @param {Number} n 需要转换的数字
 * vk.pubfn.numStr(n);
 */
pubfn.numStr = function(n) {
	if (typeof n == "string") {
		n = parseFloat(n);
	}
	let str = n;
	if (n < 1000) {
		str = n;
	} else if (n < 10000) {
		let n1 = Math.floor(n / 100);
		str = n1 / 10 + "千"
	} else if (n < 1000000) {
		let n1 = Math.floor(n / 1000);
		str = n1 / 10 + "万"
	} else if (n < 10000000) {
		let n1 = Math.floor(n / 1000000);
		str = n1 + "百万"
	} else if (n < 100000000) {
		let n1 = Math.floor(n / 10000000);
		str = n1 + "千万"
	} else if (n >= 100000000) {
		let n1 = Math.floor(n / 10000000);
		str = n1 / 10 + "亿"
	}
	return str;
};
/**
 * 金额显示过滤器（已分为单位，将100 转成 1）
 * @param {Number} money 金额
 * vk.pubfn.priceFilter(money);
 */
pubfn.priceFilter = function(money, defaultValue = "") {
	if (pubfn.isNull(money)) {
		return defaultValue;
	}
	if (isNaN(money)) {
		return money;
	}
	if (typeof money == "string") {
		money = parseFloat(money);
	}
	return (money / 100).toFixed(2);
};
// 金额过滤器 - 只显示小数点左边
pubfn.priceLeftFilter = function(n) {
	let s = "";
	if (n) {
		s = pubfn.priceFilter(n).split(".")[0];
	}
	return s;
};
// 金额过滤器 - 只显示小数点右边
pubfn.priceRightFilter = function(n) {
	let s = "";
	if (n) {
		s = pubfn.priceFilter(n).split(".")[1];
	}
	return s;
};
/**
 * 百分比过滤器 将 0.01 显示成 1%  1 显示成 100%
 * @param {Number} value 百分比值
 * @param {Boolean} needShowSymbol 显示 % 这个符号
 * @param {String | Number} defaultValue value为空时的默认值
 * vk.pubfn.percentageFilter(money);
 */
pubfn.percentageFilter = function(value, needShowSymbol = true, defaultValue = "") {
	if (pubfn.isNull(value)) {
		return defaultValue;
	}
	if (isNaN(value)) {
		return value;
	}
	if (typeof value == "string") {
		value = parseFloat(value);
	}
	value = parseFloat((value * 100).toFixed(2));
	if (needShowSymbol) {
		value += "%";
	}
	return value;
};
/**
 * 折扣过滤器 将 0.1 显示成 1折 1 显示成 原价 0 显示成免费
 * @param {Number} value 折扣值
 * @param {Boolean} needShowSymbol 显示 折 这个中文字符
 * @param {String | Number} defaultValue value为空时的默认值
 * vk.pubfn.discountFilter(value);
 */
pubfn.discountFilter = function(value, needShowSymbol = true, defaultValue = "") {
	if (pubfn.isNull(value)) {
		return defaultValue;
	}
	if (isNaN(value)) {
		return value;
	}
	if (typeof value == "string") {
		value = parseFloat(value);
	}
	value = parseFloat((value * 10).toFixed(2));
	if (value > 10) {
		return "折扣不可以大于原价";
	}
	if (value == 10) {
		return "原价";
	}
	if (value == 0) {
		return "免费";
	}
	if (value < 0) {
		return "折扣不可以小于0";
	}
	if (needShowSymbol) {
		value += " 折";
	}
	return value;
};
/**
 * 将字符串格式的时间转为时间戳
 * @param {String} 	dateString		格式为:2020-08-08 12:12:12
 */
pubfn.toTimeLong = function(dateString) {
	if (!dateString) {
		return "";
	}
	dateString = dateString.substring(0, 19);
	dateString = dateString.replace(new RegExp(/-/, "g"), '/');
	let time = new Date(dateString).getTime();
	if (isNaN(time)) {
		time = "";
	}
	return time;
};

/**
 * 单位进制换算
 * length	换算前大小
 * arr		进制的数组,如["B","KB","MB","GB"]
 * ary		进制,如KB-MB-GB,进制1024
 * precision	数值精度
 * vk.pubfn.calcSize(length,["B","KB","MB","GB"],1024,3);
 */
pubfn.calcSize = function(length = 0, arr, ary, precision = 2, showType = "auto") {
	length = parseFloat(length);
	let size = 0;
	let type = "";
	if (length < ary || arr.length <= 1) {
		type = arr[0];
		size = parseFloat(length.toFixed(precision));
	} else {
		for (let i = 1; i < arr.length; i++) {
			let currentType = arr[i];
			length = length / ary;
			if (showType === "auto") {
				if (length < ary) {
					type = currentType;
					size = parseFloat(length.toFixed(precision));
					break;
				}
			} else {
				if (showType === currentType) {
					type = currentType;
					size = parseFloat(length.toFixed(precision));
					break;
				}
			}
		}
	}
	return {
		size: size,
		type: type,
		title: size + " " + type
	}
};

/**
 * 将一个大数组拆分成N个小数组（分割数组）
 * @param {Array} array 大数组
 * @param {Number} size 小数组每组最大多少个
 * 代码示例
 * let newArray = vk.pubfn.splitArray(array, 2);
 */
pubfn.splitArray = function(array, size) {
	let data = [];
	for (let i = 0; i < array.length; i += size) {
		data.push(array.slice(i, i + size))
	}
	return data
};

/**
 * 将对象内的属性按照ASCII字符顺序进行排序，返回排序后的对象
 * @param {Object} obj 需要排序对象
 * 代码示例
 * let newObj = vk.pubfn.objectKeySort(obj);
 */
pubfn.objectKeySort = function(obj) {
	let keys = Object.keys(obj).sort();
	let newObject = {};
	for (let i in keys) {
		newObject[keys[i]] = (obj[keys[i]]);
	}
	return newObject;
};

// 以下是前端专属API-----------------------------------------------------------

/**
 * 手机端长列表分页加载数据 2.0版本
 * @param {Vue页面对象} 	that						页面数据对象this
 * @param {String} 			url							请求地址(云函数路径)
 * @param {String} 			listName				后端返回的list数组的字段名称,默认rows(二选一即可)
 * @param {String} 			listKey					后端返回的list数组的字段名称,默认rows(二选一即可)
 * @param {String} 			formKey					表单请求的对象数据源字段名称,默认queryForm1
 * @param {Object} 			data						额外数据
 * @param {function} 		dataPreprocess	数据预处理函数
 *
 * 代码示例
	vk.pubfn.getListData2({
		that : this,
		url : "template/db_api/pub/select",
		data : {
			a : 1
		},
		dataPreprocess : function(list){
			return list;
		}
	});
 */
pubfn.getListData2 = function(obj = {}) {
	let vk = uni.vk;
	let {
		that,
		listName,
		listKey = "rows",
		formKey = "queryForm1",
		url,
		dataPreprocess,
		idKeyName = "_id"
	} = obj;
	if (listName) listKey = listName;
	/**
	 * 2.0与1.0的区别
	 * 2.0使用的queryForm1作为查询,而1.0是form1
	 * 2.0云函数端是getTableData,而1.0是selects
	 */
	let queryForm1 = that[formKey] || that.queryForm1 || that.queryForm;
	// 标记为请求中
	that.loading = true;
	let hasMore = true;
	if (queryForm1.pagination.pageIndex === 1) {
		that.firstLoading = true;
	}
	vk.callFunction({
		url: url,
		data: queryForm1,
		success: function(data) {
			let list = data[listKey] || [];
			// 数据预处理
			if (typeof dataPreprocess == "function") {
				list = dataPreprocess(list);
			}
			if (queryForm1.pagination.pageIndex > 1) {
				// 翻页
				if (list.length == 0) {
					// 无数据时
					hasMore = false;
					queryForm1.pagination.pageIndex--;
					list = that.data.list;
				} else {
					// 有数据时
					if (list.length < queryForm1.pagination.pageSize) {
						hasMore = false;
					}
					// 数据合并
					list = vk.pubfn.arr_concat(that.data.list, list, idKeyName);
				}
			} else if (queryForm1.pagination.pageIndex == 1) {
				// 第一页
				if (list.length < queryForm1.pagination.pageSize) {
					hasMore = false;
				}
				if (list.length == 0) {
					that.state.isEmpty = true;
				} else {
					that.state.isEmpty = false;
				}
			}
			// 如果后端返回了hasMore,则使用后端的hasMore值
			if (typeof data.hasMore !== "undefined") {
				hasMore = data.hasMore;
			}
			data = {
				...data,
				total: data.total,
				list: list,
				hasMore: hasMore,
				pageIndex: data.pageIndex,
				pageSize: data.pageSize
			};
			that.state.loadmore = hasMore ? "loadmore" : "nomore"; // 更新状态
			that.data = vk.pubfn.objectAssign(that.data, data); // 更新数据
			if (typeof obj.success == "function") obj.success(data);
		},
		fail: function(err) {
			that.state.loadmore = "loadmore";
			if (queryForm1.pagination.pageIndex > 1) {
				queryForm1.pagination.pageIndex--;
			}
			if (typeof obj.fail == "function") {
				obj.fail(data);
			} else if (err && err.msg) {
				vk.toast(err.msg, "none");
			}
		},
		complete: function(res) {
			that.loading = false;
			if (queryForm1.pagination.pageIndex === 1) {
				that.state.firstLoading = false;
			}
			if (typeof obj.complete == "function") obj.complete(res);
		}
	});
};

/**
 * 手机端长列表分页加载数据(1.0版本)
 * @param {Vue页面对象} 	that						页面数据对象this
 * @param {String} 			url							请求地址(云函数路径)
 * @param {String} 			listName				后端返回的list数组的字段名称,默认rows
 * @param {String} 			listKey					后端返回的list数组的字段名称,默认rows
 * @param {String} 			formKey					表单请求的对象数据源字段名称,默认form1
 * @param {Object} 			data						额外数据
 * @param {function} 		dataPreprocess	数据预处理函数
 *
 * 代码示例
	vk.pubfn.getListData({
		that : this,
		url : "template/db_api/pub/select",
		listKey : "rows",
		formKey : "form1",
		data : {
			a : 1
		},
		dataPreprocess : function(list){
			return list;
		}
	});
 */
pubfn.getListData = function(obj = {}) {
	let {
		that,
		listName,
		listKey = "rows",
		formKey = "form1",
		url,
		dataPreprocess,
		loading
	} = obj;
	let vk = uni.vk;
	if (listName) listKey = listName;
	let { data = {} } = that;
	let form1 = that[formKey] || {};
	let { pageKey = true } = data;
	if (!form1.pageIndex) form1.pageIndex = 1;
	if (!form1.pageSize) form1.pageSize = 20;
	let addTime = form1.addTime;
	let endTime = form1.endTime;
	if (endTime) endTime += " 23:59:59";
	if (!pageKey && form1.pageIndex > 1) {
		form1.pageIndex--;
		return false;
	}

	if (addTime) form1.addTimeLong = pubfn.toTimeLong(addTime);
	if (endTime) form1.endTimeLong = pubfn.toTimeLong(endTime);
	if (obj.data && JSON.stringify(obj.data) != "{}") {
		pubfn.objectAssign(form1, obj.data);
	}
	let title = obj.title;
	if (typeof obj.title == "undefined" && !loading) {
		title = form1.pageIndex == 1 ? "请求中..." : "";
	}
	vk.callFunction({
		url: url,
		data: form1,
		title: title,
		loading: loading,
		success: function(data) {
			let list = data[listKey] || [];
			// 数据预处理
			if (typeof dataPreprocess == "function") {
				list = dataPreprocess(list);
			}
			if (form1.pageIndex > 1) {
				// 翻页
				if (list.length == 0) {
					// 无数据时
					pageKey = false;
					form1.pageIndex--;
					list = that.data.list;
				} else {
					// 有数据时
					if (list.length < form1.pageSize) {
						pageKey = false;
					}
					let oldList = that.data.list;
					// 数据合并
					list = pubfn.arr_concat(oldList, list, "_id");
				}
			} else if (form1.pageIndex == 1) {
				if (list.length < form1.pageSize) {
					pageKey = false;
				}
			}
			//console.log(pageKey,list.length,form1.pageSize);
			data = {
				...data,
				total: data.total,
				list: list,
				pageKey: pageKey,
				loadmore: pageKey ? "loadmore" : "nomore" // 更新状态
			};
			that.data = pubfn.objectAssign(that.data, data); // 更新数据
			if (typeof obj.success == "function") obj.success(data);
		},
		fail: function(err) {
			if (form1.pageIndex > 1) { form1.pageIndex--; }
			if (typeof obj.fail == "function") {
				obj.fail(data);
			} else if (err && err.msg) {
				vk.toast(err.msg, "none");
			}
		},
		complete: function(res) {
			if (typeof obj.complete == "function") obj.complete(res);
		},
	});
};

/**
 * 动态组件数据获取
 * @description 主要用于动态组件的数据获取
 * @param {Vue页面对象} that 页面数据对象this
 * @param {String}     ids  动态数据组件的ID
 *
 * 代码示例
 * 如:放置一个动态数据的 公告组件 和 一个轮播图组件
 * view  核心:自定义组件接收一个 Object 类型的属性 datas
  <vk-u-notice-bar :datas='componentsDynamic["notice-bar-01"]'></vk-u-notice-bar>
  <vk-u-swiper :datas='componentsDynamic["index-swiper-01"]' :custom-datas='{
    "height":600,
  }'></vk-u-swiper>
  在页面数据变量中新增 componentsDynamic
  data() {
    return {
      // 动态组件数据集合
      componentsDynamic:{}
    }
  }
  在页面初始化方法中执行下面的函数
  this.vk.pubfn.getComponentsDynamicData({
    that : this,
    ids : ["notice-bar-01","index-swiper-01"]
  });
 */
pubfn.getComponentsDynamicData = function(obj = {}) {
	let {
		that,
		keyName = "componentsDynamic",
		title,
		url = "plugs/components_dynamic/client/pub/getComponentsDynamicData",
		ids
	} = obj;
	let vk = uni.vk;
	let form1 = {
		ids: ids
	};
	if (obj.data && JSON.stringify(obj.data) != "{}") {
		pubfn.objectAssign(form1, obj.data);
	}
	// 读取缓存开始-----------------------------------------------------------
	let cacheKey = "pub-componentsDynamic";
	let cacheData = uni.getStorageSync(cacheKey) || {};
	let cacheDataKey = JSON.stringify(ids);
	if (cacheData[cacheDataKey]) {
		// 渲染本地数据
		that[keyName] = cacheData[cacheDataKey];
	}
	// 读取缓存结束-----------------------------------------------------------
	vk.callFunction({
		url: url,
		data: form1,
		title: title,
		success: function(data) {
			if (JSON.stringify(cacheData[cacheDataKey]) !== JSON.stringify(data.componentsDynamic)) {
				// 渲染服务器数据
				that[keyName] = data.componentsDynamic;
				// 同时将组件数据进行缓存
				cacheData[cacheDataKey] = data.componentsDynamic;
				uni.setStorageSync(cacheKey, cacheData);
			}
			if (typeof obj.success == "function") obj.success(data);
		},
		fail: function(err) {
			console.error(err);
			if (typeof obj.fail == "function") obj.fail(data);
		},
		complete: function() {
			if (typeof obj.complete == "function") obj.complete(data);
		},
	});
};

/**
 * 将../../ 形式的页面相对路径 转成 页面绝对路径
 * @param {String} url 需要转换的url
 * vk.pubfn.getPageFullPath(url);
 */
pubfn.getPageFullPath = function(url) {
	let fullPath = url;
	if (fullPath.indexOf("/") !== 0) {
		if (fullPath.indexOf("./") === 0) {
			//fullPath = "." + fullPath;
			fullPath = fullPath.substring(2);
		}
		let urlSplit = fullPath.split("../");
		// 向上目录级数,0:根目录 1:向上1级
		let level = urlSplit.length;
		// 尾部路径
		let urlEnd = urlSplit[level - 1];
		// 获取当前页面的页面全路径
		let pages = getCurrentPages();
		let currentPage = pages[pages.length - 1];
		let currentPagePath = currentPage.route;
		// 分割成目录,最后一段是页面名称
		let urlArr = currentPagePath.split("/");
		let urlSplicing = "";
		// 开始拼接
		for (let i = 0; i < urlArr.length - level; i++) {
			urlSplicing += urlArr[i] + "/";
		}
		// 完整页面路径
		fullPath = urlSplicing + urlEnd;
		if (fullPath.indexOf("/") != 0) {
			fullPath = "/" + fullPath;
		}
	}
	return fullPath;
};
/**
 * 获取平台信息
 * let platform = vk.pubfn.getPlatform();
 */
pubfn.getPlatform = function() {
	let platform;
	// #ifdef APP-PLUS || APP-NVUE || APP-PLUS-NVUE
	platform = "app-plus";
	// #endif
	// #ifdef H5
	platform = "h5";
	// #endif
	// #ifdef MP-WEIXIN
	platform = "mp-weixin";
	// #endif
	// #ifdef MP-ALIPAY
	platform = "mp-alipay";
	// #endif
	// #ifdef MP-BAIDU
	platform = "mp-baidu";
	// #endif
	// #ifdef MP-TOUTIAO
	platform = "mp-toutiao";
	// #endif
	// #ifdef MP-QQ
	platform = "mp-qq";
	// #endif
	// #ifdef MP-360
	platform = "mp-360";
	// #endif
	// #ifdef MP-KUAISHOU
	platform = "mp-toutiao";
	// #endif
	return platform;
};
/**
 * 获取当前页面实例
 * 返回数据
 * fullPath 当前打开页面的完整路径（带页面参数）
 * pagePath 当前打开页面的路径（不含参数）
 * options  当前打开页面的参数
 * route    当前打开页面路由地址
 * $vm      当前打开页面的vue实例
 * vk.pubfn.getCurrentPage();
 */
pubfn.getCurrentPage = function() {
	let res = {};
	let pages = getCurrentPages();
	let page = pages[pages.length - 1];
	if (page.route.indexOf("/") == 0) page.route = page.route.substring(1);
	let pagePath = `/${page.route}`;
	let fullPath = `/${page.route}`;
	let options = page.options;
	if (page.$page) {
		if (typeof page.$page.fullPath !== "undefined") {
			fullPath = page.$page.fullPath;
		} else if (typeof options === "object") {
			let optionsStr = pubfn.queryParams(options);
			fullPath = pagePath + optionsStr;
		}
	}
	res.fullPath = fullPath;
	res.pagePath = pagePath;
	res.options = options;
	res.route = page.route;
	res.$vm = page.$vm;
	return res;
};
/**
 * 获取当前页面路由
 * vk.pubfn.getCurrentPageRoute();
 */
pubfn.getCurrentPageRoute = function(removeSlash) {
	let pages = getCurrentPages();
	let page = pages[pages.length - 1];
	if (removeSlash) {
		return page.route;
	} else {
		return "/" + page.route;
	}
};
/**
 * 文件转base64

方式一

vk.pubfn.fileToBase64({
	file:res.tempFiles[0],
	success:function(base64){

	}
});

方式二

vk.pubfn.fileToBase64({ file }).then(base64 => {

});
 */
pubfn.fileToBase64 = function(obj = {}) {
	let { file } = obj;
	let filePath = typeof file === "object" ? file.path : file;
	return new Promise(function(resolve, reject) {
		// #ifdef H5
		let reader = new FileReader();
		reader.readAsDataURL(file);
		reader.onload = function(res) {
			let base64 = this.result;
			if (base64.indexOf(";base64,") == -1) {
				base64 = "data:image/jpeg;base64," + base64;
			}
			if (obj.success) obj.success(base64);
			if (obj.complete) obj.complete(base64);
			resolve(base64);
		};
		reader.onerror = function(err) {
			if (obj.fail) obj.fail(err);
			if (obj.complete) obj.complete(err);
			reject(err);
		};
		// #endif
		// #ifdef MP
		uni.getFileSystemManager().readFile({
			filePath: filePath,
			encoding: "base64",
			success: function(res) {
				let base64 = res.data;
				if (base64.indexOf(";base64,") == -1) {
					base64 = "data:image/jpeg;base64," + base64;
				}
				if (obj.success) obj.success(base64);
				if (obj.complete) obj.complete(base64);
				resolve(base64);
			},
			fail: function(err) {
				if (obj.fail) obj.fail(err);
				reject(err);
			},
			complete: obj.complete
		});
		// let base64 = uni.getFileSystemManager().readFileSync(file.path, 'base64');
		// if(obj.success) obj.success(base64);
		// if(obj.complete) obj.complete(base64);
		// resolve(base64);
		// #endif
		// #ifdef APP-PLUS
		plus.io.resolveLocalFileSystemURL(pubfn.getLocalFilePath(filePath), function(entry) {
			entry.file(function(file) {
				let fileReader = new plus.io.FileReader();
				fileReader.onload = function(data) {
					if (obj.success) obj.success(data.target.result);
					if (obj.complete) obj.complete(data.target.result);
					resolve(data.target.result);
				}
				fileReader.onerror = function(err) {
					if (obj.fail) obj.fail(err);
					reject(err);
				}
				fileReader.readAsDataURL(file)
			}, function(err) {
				if (obj.fail) obj.fail(err);
				reject(err);
			})
		}, function(err) {
			if (obj.fail) obj.fail(err);
			reject(err);
		})
		// #endif
	});
};

/**
 * base64转文件
方式一

vk.pubfn.base64ToFile({
	base64:base64,
	success:function(file){

	}
});

方式二

vk.pubfn.base64ToFile({ base64 }).then(file => {

});
 */
pubfn.base64ToFile = function(obj = {}) {
	let {
		base64 = "",
			filePath
	} = obj;
	let extName = base64.split(',')[0].match(/data\:\S+\/(\S+);/);
	if (extName) {
		extName = extName[1];
	} else {
		reject(new Error('base64 error'));
	}
	if (!filePath) {
		filePath = pubfn.random(32, "abcdefghijklmnopqrstuvwxyz0123456789") + '.' + extName;
	}
	let index = base64.indexOf("base64,");
	let base64Data = base64;
	if (index > -1) {
		base64Data = base64.substring(base64.indexOf("base64,") + 7);
	}
	let savePath;
	return new Promise(function(resolve, reject) {
		// #ifdef MP
		savePath = wx.env.USER_DATA_PATH + '/' + filePath;
		let fs = uni.getFileSystemManager();
		fs.writeFile({
			filePath: savePath,
			data: base64Data,
			encoding: "base64",
			success: function(res) {
				let file = {
					path: savePath,
					lastModifiedDate: new Date(),
					name: filePath
				};
				if (obj.success) obj.success(file);
				resolve(file);
			},
			fail: function(res) {
				if (obj.fail) obj.fail(res);
				reject(res);
			},
			complete: obj.complete
		});
		// #endif
		// #ifdef H5
		savePath = filePath;
		let blob = pubfn.base64toBlob(base64);
		let file = pubfn.blobToFile(blob, savePath);
		if (obj.success) obj.success(file);
		if (obj.complete) obj.complete(file);
		resolve(file);
		// #endif
		// #ifdef APP-PLUS
		let fileName = filePath;
		let basePath = '_user_resources';
		let dirPath = 'vk_temp';
		savePath = basePath + '/' + dirPath + '/' + fileName;
		let bitmap = new plus.nativeObj.Bitmap(fileName);
		bitmap.loadBase64Data(base64, function() {
			bitmap.save(savePath, {}, function() {
				bitmap.clear();
				let file = {
					path: savePath,
					lastModifiedDate: new Date(),
					name: filePath
				};
				if (obj.success) obj.success(file);
				if (obj.complete) obj.complete(file);
				resolve(file);
			}, function(error) {
				bitmap.clear();
				if (obj.fail) obj.fail(error);
				reject(error);
			})
		}, function(error) {
			bitmap.clear();
			if (obj.fail) obj.fail(error);
			reject(error);
		})
		// #endif
	});
};
/**
 * 将base64转换为blob （H5独有）
 vk.pubfn.base64toBlob(base64);
 */
pubfn.base64toBlob = function(base64) {
	let arr = base64.split(',');
	let mime = arr[0].match(/:(.*?);/)[1];
	let bstr = atob(arr[1]);
	let n = bstr.length;
	let u8arr = new Uint8Array(n);
	while (n--) {
		u8arr[n] = bstr.charCodeAt(n);
	}
	return new Blob([u8arr], { type: mime });
};
/**
 * //将blob转换为file
 vk.pubfn.blobToFile(base64);
 */
pubfn.blobToFile = function(blob, fileName) {
	blob.lastModifiedDate = new Date();
	blob.name = fileName;
	blob.path = URL.createObjectURL(blob);
	return blob;
};

/**
 * 小程序订阅消息 前端无需再写 #ifdef MP-WEIXIN
 vk.pubfn.requestSubscribeMessage({
	 tmplIds: ['NcspDBQpH6CGHos3mMADrrQpEv2gHmtfOPa5KTLs92E']
 });
 */
pubfn.requestSubscribeMessage = function(obj) {
	// #ifdef MP-WEIXIN
	return uni.requestSubscribeMessage(obj);
	// #endif
};

/**
 * 检测是否需要登录 此方法目前为测试版
 * vk.pubfn.checkLogin();
 */
pubfn.checkLogin = function(obj = {}) {
	let vk = uni.vk;
	let loginUrl = vk.getConfig("login.url");
	try {
		let url;
		try {
			url = obj.url || vk.pubfn.getCurrentPageRoute();
		} catch (err) {
			url = vk.getConfig("index.url") || "/pages/index/index";
		}
		vk.navigate.checkNeedLogin({
			url: url,
			success: function(res) {
				if (res.needLogin) {
					// 记录下原本要跳转的页面
					url = vk.pubfn.getPageFullPath(obj.fullPath || url);
					vk.navigate.setOriginalPage({ url });
					if (obj.isOnLaunch) vk.navigate.isOnLaunchToLogin = true; // 标记为首次启动的页面需要登录
					uni.reLaunch({
						url: loginUrl,
						success: () => {
							// #ifdef MP-WEIXIN
							setTimeout(() => {
								uni.hideHomeButton();
							}, 400);
							// #endif
						}
					});
				} else {
					// #ifdef H5
					// 解决微信公众号登录无法跳回原页面的问题
					if (!obj.options || !obj.options.code || !obj.options.state) {
						vk.navigate.setOriginalPage(null);
					}
					// #endif
					// #ifndef H5
					vk.navigate.setOriginalPage(null);
					// #endif
				}
			}
		});
	} catch (err) {
		console.error("catch", err);
		uni.reLaunch({
			url: loginUrl
		});
		// #ifdef MP-WEIXIN
		uni.hideHomeButton();
		// #endif
	}
};
/**
 * 获取文件本地路径
 * @param {Object} path
 */
pubfn.getLocalFilePath = function(path) {
	if (path.indexOf('_www') === 0 || path.indexOf('_doc') === 0 || path.indexOf('_documents') === 0 || path.indexOf('_downloads') === 0) {
		return path
	}
	if (path.indexOf('file://') === 0) {
		return path
	}
	if (path.indexOf('/storage/emulated/0/') === 0) {
		return path
	}
	if (path.indexOf('/') === 0 && typeof plus !== "undefined") {
		let localFilePath = plus.io.convertAbsoluteFileSystem(path)
		if (localFilePath !== path) {
			return localFilePath
		} else {
			path = path.substr(1)
		}
	}
	return '_www/' + path
};

/**
 * 获取当前支持的应用语言
 * let localeList = vk.pubfn.getLocaleList();
 */
pubfn.getLocaleList = function() {
	let localeList = [
		{ value: "zh-Hans", label: "简体中文" },
		{ value: "zh-Hant", label: "繁體中文" },
		{ value: "en", label: "English" }
	];
	return localeList;
};
/**
 * 获取当前应用语言
 * let locale = vk.pubfn.getLocale();
 */
pubfn.getLocale = function() {
	let localeValue;
	if (typeof uni.getLocale === "function") {
		localeValue = uni.getLocale();
	} else {
		localeValue = "zh-Hans"; // 默认中文简体
	}
	let localeObj = {
		"zh_CN": "zh-Hans", // 中国大陆（简体）
		"zh_HK": "zh-Hant", // 香港（繁体）
		"zh_MO": "zh-Hant", // 澳门（繁体）
		"zh_SG": "zh-Hans", // 新加坡（简体）
		"zh_TW": "zh-Hant", // 台湾（繁体）
	};
	if (localeObj[localeValue]) localeValue = localeObj[localeValue];
	return localeValue;
};
/**
 * 获取当前应用语言
 * let localeObj = vk.pubfn.getLocaleObject();
 */
pubfn.getLocaleObject = function() {
	let value = pubfn.getLocale();
	let list = pubfn.getLocaleList();
	return pubfn.getListItem(list, "value", value);
};
/**
 * 设置当前应用语言
 */
pubfn.setLocale = function(...e) {
	return uni.setLocale(...e);
};

/**
 * 将obj2的数据赋值给obj1，并使vue双向绑定（vue2对象新增属性不会双向绑定）
 * @description 将 obj2 的属性赋值给 obj1 (如果obj1中有对应的属性,则会被obj2的属性值覆盖)
 * @param {Object} 	obj1
 * @param {Object} 	obj2
 * @param {Object} 	that 页面实例
 * vk.pubfn.objectAssignForVue(obj1, obj2, that);
 */
pubfn.objectAssignForVue = function(obj1, obj2, that) {
	pubfn.objectDeleteInvalid(obj2);
	for (let key in obj2) {
		that.$set(obj1, key, obj2[key]);
	}
};

// 前端专属结束 -----------------------------------------------------------
export default pubfn;