uview-ultra-plus 1.0.0

package/uview-ultra/libs/composable/useFuncIndex.uts

@@ -0,0 +1,861 @@
+import {
+	number as testNumber,
+	array as testArray,
+	empty as testEmpty
+} from '../function/test.uts'
+import { round } from '../function/digit.uts'
+import config from '../config/config'
+
+export const useFuncIndex = () => {
+    // 查询节点信息
+    // 目前此方法在支付宝小程序中无法获取组件跟接点的尺寸，为支付宝的bug(2020-07-21)
+    // 解决办法为在组件根部再套一个没有任何作用的view元素
+    function upGetRect(selector: string, all: boolean = false, comp: ComponentPublicInstance|ComponentInternalInstance|null = null): Promise<NodeInfo> {
+        return new Promise((resolve) => {
+            if (all == true) {
+                uni.createSelectorQuery()
+                    .in(comp).select(selector)
+                    .boundingClientRect((res) => {
+                        const nodeInfoArray = res as NodeInfo[]
+                        const nodeInfoArrayItem = nodeInfoArray[0]
+                        resolve(nodeInfoArrayItem)
+                    })
+                    .exec()
+            } else {
+                uni.createSelectorQuery()
+                    .in(comp).selectAll(selector)
+                    .boundingClientRect((res) => {
+                        const nodeInfoArray = res as NodeInfo[]
+                        const nodeInfoArrayItem = nodeInfoArray[0]
+                        resolve(nodeInfoArrayItem)
+                    })
+                    .exec()
+            }
+        })
+    }
+            
+    /**
+    * 生成bem规则类名
+    * 由于微信小程序，H5，nvue之间绑定class的差异，无法通过:class="[bem()]"的形式进行同用
+    * 故采用如下折中做法，最后返回的是数组（一般平台）或字符串（支付宝和字节跳动平台），类似['a', 'b', 'c']或'a b c'的形式
+    * @param {String} name 组件名称
+    * @param {Array} fixed 一直会存在的类名
+    * @param {Array} change 会根据变量值为true或者false而出现或者隐藏的类名
+    * @returns {Array|string}
+    */
+    function bem(name: string, fixed: Array<string>, change: Array<Array<any>>): string {
+        // 类名前缀
+        const prefix = `up-${name}--`
+        const classes = {}
+        if (fixed.length > 0) {
+            fixed.map((item) => {
+                    // 这里的类名，会一直存在
+                    classes[prefix + item] = true
+            })
+        }
+        if (change.length > 0) {
+            change.map((item) => {
+                // 这里的类名，会根据item[1]的值为true或者false，而进行添加或者移除某一个类
+                if (item[1] as boolean) {
+                    (classes[prefix + (item[0] as string)] = item[1] as boolean)
+                }
+                // : (delete classes[prefix + item[0]])
+            })
+        }
+        // #ifdef APP
+        return UTSJSONObject.keys(classes).join(' ')
+        // #endif
+        // #ifdef WEB || MP
+        return UTSJSONObject.keys(classes).join(' ')
+        // #endif
+        // 支付宝，头条小程序无法动态绑定一个数组类名，否则解析出来的结果会带有","，而导致失效
+    }
+
+    /**
+    * @description 如果value小于min，取min；如果value大于max，取max
+    * @param {number} min 
+    * @param {number} max 
+    * @param {number} value
+    */
+    function range(min = 0, max = 0, value = 0):number {
+        return Math.max(min, Math.min(max, (value as number)))
+    }
+
+    /**
+    * @description 用于获取用户传递值的px值  如果用户传递了"xxpx"或者"xxrpx"，取出其数值部分，如果是"xxxrpx"还需要用过uni.upx2px进行转换
+    * @param {number|string} value 用户传递值的px值
+    * @param {boolean} unit 
+    * @returns {number|string}
+    */
+    function getPx(valueOri: any, unit = false): string {
+        let value: string = valueOri.toString()
+        if (testNumber(value)) {
+            return unit ? `${value}px` : (value)
+        }
+        // 如果带有rpx，先取出其数值部分，再转为px值
+        if (/(rpx|upx)$/.test(value)) {
+            // todo
+            // return unit ? `${uni.upx2px(parseInt(value)).toString()}px` : uni.upx2px(parseInt(value))
+        }
+        return unit ? `${value}px` : (value)
+    }
+
+    /**f
+    * @description 进行延时，以达到可以简写代码的目的 比如: await sleep(20)将会阻塞20ms
+    * @param {number} value 堵塞时间 单位ms 毫秒
+    * @returns {Promise} 返回promise
+    */
+    function sleep(value = 30): Promise<UTSJSONObject> {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve({})
+            }, value)
+        })
+    }
+    /**
+    * @description 运行期判断平台
+    * @returns {string} 返回所在平台(小写) 
+    * @link 运行期判断平台 https://uniapp.dcloud.io/frame?id=判断平台
+    */
+    function os(): string {
+        return uni.getSystemInfoSync().osName
+    }
+    /**
+    * @description 获取系统信息同步接口
+    * @link 获取系统信息同步接口 https://uniapp.dcloud.io/api/system/info?id=getsysteminfosync 
+    */
+    function sys(): GetSystemInfoResult {
+        return uni.getSystemInfoSync()
+    }
+
+    function getWindowInfo(): GetWindowInfoResult {
+        return uni.getWindowInfo()
+    }
+
+    function getDeviceInfo(): GetDeviceInfoResult {
+        return uni.getDeviceInfo()
+    }
+
+    /**
+    * @description 取一个区间数
+    * @param {Number} min 最小值
+    * @param {Number} max 最大值
+    */
+    function random(min: number, max: number): number {
+        if (min >= 0 && max > 0 && max >= min) {
+            const gab = max - min + 1
+            return Math.floor(Math.random() * gab + min)
+        }
+        return 0
+    }
+
+    // /**
+    //  * @param {Number} len uuid的长度
+    //  * @param {Boolean} firstU 将返回的首字母置为"u"
+    //  * @param {Nubmer} radix 生成uuid的基数(意味着返回的字符串都是这个基数),2-二进制,8-八进制,10-十进制,16-十六进制
+    //  */
+    function guid(len = 32, firstU = true, radix = 0): string {
+        const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('')
+        let uuid: Array<String> = []
+        for (let i = 0; i < len; i++) {
+            uuid.push('')
+        }
+        radix = radix > 0 ? radix : chars.length
+
+        if (len > 0) {
+            // 如果指定uuid长度,只是取随机的字符,0|x为位运算,能去掉x的小数位,返回整数位
+            for (let i = 0; i < len; i++) {
+                const index = Math.floor(Math.random() * radix);
+                uuid[i] = chars[index % chars.length]
+            }
+        } else {
+            let r:number
+            // rfc4122标准要求返回的uuid中,某些位为固定的字符
+            uuid[23] = '-'
+            uuid[8] = '-'
+            uuid[13] = '-'
+            uuid[18] ='-'
+            uuid[14] = '4'
+
+            for (let i = 0; i < 36; i++) {
+                r = 0 | Math.random() * 16
+                uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r]
+            }
+        }
+        // 移除第一个字符,并用u替代,因为第一个字符为数值时,该guuid不能用作id或者class
+        if (firstU) {
+            uuid.shift()
+            return `u${uuid.join('')}`
+        }
+        return uuid.join('')
+    }
+
+    /**
+    * @description 样式转换
+    * 对象转字符串，或者字符串转对象
+    * @param {object | string} customStyle 需要转换的目标
+    * @param {String} target 转换的目的，object-转为对象，string-转为字符串
+    * @returns any
+    */
+    function addStyle(customStyle: any, target = 'object'): any {
+        // 字符串转字符串，对象转对象情形，直接返回
+        if (testEmpty(customStyle) || typeof(customStyle) === 'object' && target === 'object' || target === 'string' &&
+            typeof(customStyle) === 'string') {
+            return customStyle
+        }
+        // 字符串转对象
+        if (target === 'object') {
+            let customStyleStr = JSON.stringify(customStyle)
+            // 去除字符串样式中的两端空格(中间的空格不能去掉，比如padding: 20px 0如果去掉了就错了)，空格是无用的
+            customStyleStr = customStyleStr.trim()
+            // 根据";"将字符串转为数组形式
+            const styleArray = customStyleStr.split(';')
+            const style = {}
+            // 历遍数组，拼接成对象
+            for (let i = 0; i < styleArray.length; i++) {
+                // 'font-size:20px;color:red;'，如此最后字符串有";"的话，会导致styleArray最后一个元素为空字符串，这里需要过滤
+                if (styleArray[i] != '') {
+                    const item = styleArray[i].split(':')
+                    if (item.length > 1) {
+                        style[(item[0]).trim()] = item[1].trim()
+                    }
+                }
+            }
+            return style
+        }
+        // 这里为对象转字符串形式
+        let string = ''
+        // let customStyleObj
+        UTSJSONObject.keys(customStyle as UTSJSONObject).forEach((key: string) => {
+            // 驼峰命名转换为中划线
+            key = key.replace(/([A-Z])/g, '-$1').toLowerCase()
+            let val = customStyle[key]
+            string += `${key}: ${val};`
+        })
+        // 去除两端空格
+        return string.trim()
+    }
+
+    /**
+    * @description 添加单位，如果有rpx，upx，%，px等单位结尾或者值为auto，直接返回，否则加上px单位结尾
+    * @param {string|number} value 需要添加单位的值
+    * @param {string} unit 添加的单位名 比如px
+    */
+    function addUnit(pvalue: any|null, punit = 'px'): string {
+        let value = pvalue
+        if (value == '' || value == null) {
+            value = 'auto'
+        }
+        let unit = punit
+        if ( unit == '') {
+            unit = config['unit'] as string
+        }
+        let valueStr = value.toString()
+        // 用uview-plus内置验证规则中的number判断是否为数值
+        return testNumber(valueStr) ? `${valueStr}${unit}` : valueStr
+    }
+
+    /**
+    * @description 深度克隆
+    * @param {object} obj 需要深度克隆的对象
+    * @returns {*} 克隆后的对象或者原值（不是对象）
+    */
+    function deepClone(obj: object): any|null {
+        // 对常见的"非"值，直接返回原来值
+        // if ([null, undefined, NaN, false].includes(obj)) return obj
+        return JSON.parse(JSON.stringify(obj))
+    }
+
+    /**
+    * @description JS对象深度合并
+    * @param {UTSJSONObject} target 需要拷贝的对象
+    * @param {UTSJSONObject} source 拷贝的来源对象
+    * @returns {UTSJSONObject|boolean} 深度合并后的对象或者false（入参有不是对象）
+    */
+    function deepMerge(
+        targetOrigin: any = {},
+        source: any = {}): UTSJSONObject {
+        let targetJson = JSON.parse(JSON.stringify(targetOrigin)) as UTSJSONObject
+        let sourceJson = JSON.parse(JSON.stringify(source)) as UTSJSONObject
+        let target:UTSJSONObject = {}
+        // #ifdef APP
+        target = UTSJSONObject.assign(targetJson, sourceJson)
+        // #endif
+        // #ifdef WEB
+        target = Object.assign(targetJson, sourceJson)
+        // #endif
+    //    if (typeof target !== 'object' || typeof source !== 'object') return false
+    //    for (const prop in source) {
+        // source.forEach((val, prop) => {
+    //        if (!source[prop]) continue
+    //        if (target[prop]) {
+    //            if (source[prop] == null) {
+    //                target[prop] = source[prop]
+    //            }else if (typeof target[prop] !== 'object') {
+    //                target[prop] = source[prop]
+    //            } else if (typeof source[prop] !== 'object') {
+    //                target[prop] = source[prop]
+    //            } else if (target[prop].concat && source[prop].concat) {
+    //            //     target[prop] = target[prop].concat(source[prop])
+    //            } else {
+    //            //     target[prop] = deepMerge(target[prop], source[prop])
+    //            }
+    //        } else {
+    //            target[prop] = source[prop]
+    //        }
+    //    })
+        return target
+    }
+
+    /**
+    * @description error提示
+    * @param {*} err 错误内容
+    */
+    function error(err: string): void {
+        // 开发环境才提示，生产环境不会提示
+        if (process.env.NODE_ENV === 'development') {
+            console.error(`uview-plus提示：${err}`)
+        }
+    }
+
+    /**
+    * @description 打乱数组
+    * @param {array} array 需要打乱的数组
+    * @returns {array} 打乱后的数组
+    */
+    function randomArray(array: any[] = []): any[] {
+        // 原理是sort排序,Math.random()产生0<= x < 1之间的数,会导致x-0.05大于或者小于0
+        array.sort((): number => {
+            return Math.random() - 0.5
+        })
+        return array.sort(() => Math.random() - 0.5)
+    }
+
+    // // padStart 的 polyfill，因为某些机型或情况，还无法支持es7的padStart，比如电脑版的微信小程序
+    // // 所以这里做一个兼容polyfill的兼容处理
+    // if (!String.prototype.padStart) {
+    //     // 为了方便表示这里 fillString 用了ES6 的默认参数，不影响理解
+    //     String.prototype.padStart = function(maxLength, fillString = ' '): any {
+    //         if (Object.prototype.toString.call(fillString) !== '[object String]') {
+    //             throw new TypeError(
+    //                 'fillString must be String'
+    //             )
+    //         }
+    //         const str = this
+    //         // 返回 String(str) 这里是为了使返回的值是字符串字面量，在控制台中更符合直觉
+    //         if (str.length >= maxLength) return String(str)
+
+    //         const fillLength = maxLength - str.length
+    //         let times = Math.ceil(fillLength / fillString.length)
+    //         while (times >>= 1) {
+    //             fillString += fillString
+    //             if (times === 1) {
+    //                 fillString += fillString
+    //             }
+    //         }
+    //         return fillString.slice(0, fillLength) + str
+    //     }
+    // }
+
+    /**
+    * @description 格式化时间
+    * @param {String|Number} dateTime 需要格式化的时间戳
+    * @param {String} fmt 格式化规则 yyyy:mm:dd|yyyy:mm|yyyy年mm月dd日|yyyy年mm月dd日 hh时MM分等,可自定义组合 默认yyyy-mm-dd
+    * @returns {string} 返回格式化后的字符串
+    */
+    function timeFormat(dateTime: any = 0, formatStr: string = 'yyyy-mm-dd'): string {
+    let date: any
+        // 若传入时间为假值，则取当前时间
+    if (dateTime == 0) {
+        date = new Date()
+    }
+    // 若为unix秒时间戳，则转为毫秒时间戳（逻辑有点奇怪，但不敢改，以保证历史兼容）
+    else if (/^\d{10}$/.test(dateTime.toString().trim())) {
+        date = new Date(parseInt(dateTime.toString()) * 1000)
+    }
+    // 若用户传入字符串格式时间戳，new Date无法解析，需做兼容
+    else if (typeof dateTime === 'string' && /^\d+$/.test(dateTime.toString().trim())) {
+        date = new Date(parseInt(dateTime.toString()))
+    }
+    // 其他都认为符合 RFC 2822 规范
+    else {
+        // 处理平台性差异，在Safari/Webkit中，new Date仅支持/作为分割符的字符串时间
+        date = new Date(
+        typeof dateTime === 'string'
+            ? dateTime.toString().replace(/-/g, '/')
+            : dateTime.toString()
+        )
+    }
+
+        const timeSource = {
+            // 'y': date.getFullYear().toString(), // 年
+            // 'm': (date.getMonth() as number + 1).toString().padStart(2, '0'), // 月
+            // 'd': date.getDate().toString().padStart(2, '0'), // 日
+            // 'h': date.getHours().toString().padStart(2, '0'), // 时
+            // 's': date.getSeconds().toString().padStart(2, '0') // 秒
+            // 有其他格式化字符需求可以继续添加，必须转化成字符串
+        } as UTSJSONObject
+        timeSource['y'] = date.getFullYear().toString()
+        timeSource['m'] = (date.getMonth() as number + 1).toString().padStart(2, '0').toString()
+        timeSource['d'] = date.getDate().toString().padStart(2, '0').toString()
+        timeSource['M'] = date.getMinutes().toString().padStart(2, '0').toString()
+        timeSource['h'] = date.getHours().toString().padStart(2, '0').toString()
+        timeSource['s'] = date.getSeconds().toString().padStart(2, '0').toString()
+
+    let timeSourceReturn = formatStr
+    // console.log(timeSource)
+    for (const key in timeSource) {
+        const ret = new RegExp(`${key}+`).exec(formatStr)
+        if (ret != null && ret[0] != null) {
+        // console.log('ret', ret)
+        // 年可能只需展示两位
+        const beginIndex = key === 'y' && ret.length == 2 ? 2 : 0
+        if (timeSource[key] != null
+            && key != '') {
+            let replaceVal: string = ''
+            let timeSourceKey = timeSource.getString(key)
+            // console.log('timeSourceKey', typeof timeSourceKey)
+            if (timeSourceKey != null) {
+                replaceVal = timeSourceKey!!.slice(beginIndex)
+            }
+            timeSourceReturn = timeSourceReturn.replace(
+                ret[0].toString(),
+                replaceVal
+            )
+        }
+        }
+    }
+
+    return timeSourceReturn
+    }
+
+    // /**
+    //  * @description 时间戳转为多久之前
+    //  * @param {String|Number} timestamp 时间戳
+    //  * @param {String|Boolean} format 
+    //  * 格式化规则如果为时间格式字符串，超出一定时间范围，返回固定的时间格式；
+    //  * 如果为布尔值false，无论什么时间，都返回多久以前的格式
+    //  * @returns {string} 转化后的内容
+    //  */
+    // function timeFrom(timestamp: number = 0, format: any = 'yyyy-mm-dd'): any {
+    //     if (timestamp == 0) timestamp = Number(new Date())
+    //     // timestamp = parseInt(timestamp)
+    //     // 判断用户输入的时间戳是秒还是毫秒,一般前端js获取的时间戳是毫秒(13位),后端传过来的为秒(10位)
+    //     if (timestamp.toString().length == 10) timestamp *= 1000
+    //     let timer = (new Date()).getTime() - timestamp
+    //     timer = (timer / 1000).toInt()
+    //     // 如果小于5分钟,则返回"刚刚",其他以此类推
+    //     let tips = ''
+    //     switch (true) {
+    //         case timer < 300:
+    //             tips = '刚刚'
+    //             break
+    //         case timer >= 300 && timer < 3600:
+    //             tips = `${(timer / 60).toInt()}分钟前`
+    //             break
+    //         case timer >= 3600 && timer < 86400:
+    //             tips = `${(timer / 3600).toInt()}小时前`
+    //             break
+    //         case timer >= 86400 && timer < 2592000:
+    //             tips = `${(timer / 86400).toInt()}天前`
+    //             break
+    //         default:
+    //             // 如果format为false，则无论什么时间戳，都显示xx之前
+    //             if (format === false) {
+    //                 if (timer >= 2592000 && timer < 365 * 86400) {
+    //                     tips = `${(timer / (86400 * 30)).toInt()}个月前`
+    //                 } else {
+    //                     tips = `${(timer / (86400 * 365)).toInt()}年前`
+    //                 }
+    //             } else {
+    //                 tips = timeFormat(timestamp, format)
+    //             }
+    //     }
+    //     return tips
+    // }
+
+    /**
+    * @description 去除空格
+    * @param String str 需要去除空格的字符串
+    * @param String pos both(左右)|left|right|all 默认both
+    */
+    function trim(str: string, pos = 'both'): string {
+        if (pos == 'both') {
+            return str.replace(/^\s+|\s+$/g, '')
+        }
+        if (pos == 'left') {
+            return str.replace(/^\s*/, '')
+        }
+        if (pos == 'right') {
+            return str.replace(/(\s*$)/g, '')
+        }
+        if (pos == 'all') {
+            return str.replace(/\s+/g, '')
+        }
+        return str
+    }
+
+    /**
+    * @description 对象转url参数
+    * @param {object} data,对象
+    * @param {Boolean} isPrefix,是否自动加上"?"
+    * @param {string} arrayFormat 规则 indices|brackets|repeat|comma
+    */
+    function queryParams(data: UTSJSONObject = {}, isPrefix: boolean = true, arrayFormat: string = 'brackets'): string {
+        return ''
+    //    const prefix = isPrefix ? '?' : ''
+    //    const _result: string[] = []
+    //    if (['indices', 'brackets', 'repeat', 'comma'].indexOf(arrayFormat) == -1) arrayFormat = 'brackets'
+        // data.toMap().forEach((value: any | null, key: string) => {
+    //        // 去掉为空的参数
+    //        if (['', null].indexOf(value) < 0) {
+    //            // 如果值为数组，另行处理
+    //            if (Array.isArray(value)) {
+    //                // e.g. {ids: [1, 2, 3]}
+    //                switch (arrayFormat) {
+    //                    case 'indices':
+    //                        // 结果: ids[0]=1&ids[1]=2&ids[2]=3
+    //                        for (let i = 0; i < value.length; i++) {
+    //                            _result.push(`${key}[${i}]=${value[i]}`)
+    //                        }
+    //                        break
+    //                    case 'brackets':
+    //                        // 结果: ids[]=1&ids[]=2&ids[]=3
+    //                        value.forEach((_value) => {
+    //                            _result.push(`${key}[]=${_value}`)
+    //                        })
+    //                        break
+    //                    case 'repeat':
+    //                        // 结果: ids=1&ids=2&ids=3
+    //                        value.forEach((_value) => {
+    //                            _result.push(`${key}=${_value}`)
+    //                        })
+    //                        break
+    //                    case 'comma':
+    //                        // 结果: ids=1,2,3
+    //                        let commaStr = ''
+    //                        value.forEach((_value) => {
+    //                            commaStr += (commaStr != '' ? ',' : '') + _value
+    //                        })
+    //                        _result.push(`${key}=${commaStr}`)
+    //                        break
+    //                    default:
+    //                        value.forEach((_value) => {
+    //                            _result.push(`${key}[]=${_value}`)
+    //                        })
+    //                }
+    //            } else {
+    //                _result.push(`${key}=${value}`)
+    //            }
+    //        }
+    //    })
+    //    return _result.length > 0 ? prefix + _result.join('&') : ''
+    }
+
+    /**
+    * 显示消息提示框
+    * @param {String} title 提示的内容，长度与 icon 取值有关。
+    * @param {Number} duration 提示的延迟时间，单位毫秒，默认：2000
+    */
+    function toast(title: string, duration = 2000) {
+        uni.showToast({
+            title: title,
+            icon: 'none',
+            duration
+        })
+    }
+
+    /**
+    * @description 根据主题type值,获取对应的图标
+    * @param {String} type 主题名称,primary|info|error|warning|success
+    * @param {boolean} fill 是否使用fill填充实体的图标
+    */
+    function type2icon(type: string = 'success', fill: boolean = false): string {
+        // 如果非预置值,默认为success
+        if (['primary', 'info', 'error', 'warning', 'success'].indexOf(type) == -1) {
+            type = 'success'
+        }
+        let iconName = ''
+        // 目前(2019-12-12),info和primary使用同一个图标
+        switch (type) {
+            case 'primary':
+                iconName = 'info-circle'
+                break
+            case 'info':
+                iconName = 'info-circle'
+                break
+            case 'error':
+                iconName = 'close-circle'
+                break
+            case 'warning':
+                iconName = 'error-circle'
+                break
+            case 'success':
+                iconName = 'checkmark-circle'
+                break
+            default:
+                iconName = 'checkmark-circle'
+        }
+        // 是否是实体类型,加上-fill,在icon组件库中,实体的类名是后面加-fill的
+        if (fill) iconName = iconName + '-fill'
+        return iconName
+    }
+
+    /**
+    * @description 数字格式化
+    * @param {number|string} number 要格式化的数字
+    * @param {number} decimals 保留几位小数
+    * @param {string} decimalPoint 小数点符号
+    * @param {string} thousandsSeparator 千分位符号
+    * @returns {string} 格式化后的数字
+    */
+    function priceFormat(numberOri: any, decimals = 0, decimalPoint = '.', thousandsSeparator = ','): string {
+        let numberStr: string = numberOri.toString()
+        let numberNo: number = parseFloat((`${numberStr}`).replace(/[^0-9+-Ee.]/g, ''))
+        const n = !isFinite(numberNo) ? 0 : numberNo
+        const prec: number = !isFinite(decimals) ? 0 : Math.abs(decimals)
+        const sep = (typeof thousandsSeparator === 'undefined') ? ',' : thousandsSeparator
+        const dec = (typeof decimalPoint === 'undefined') ? '.' : decimalPoint
+        let s: string[] = []
+        
+        if (prec > 0) {
+            s = n.toString().split('.')
+            s[1] = s[1].slice(0, prec)
+        } else {
+            s = (`${Math.round(n)}`).split('.')
+        }
+        const re = /(-?\d+)(\d{3})/
+        while (re.test(s[0])) {
+            s[0] = s[0].replace(re, `$1${sep}$2`)
+        }
+        if (s.length > 1) {
+            if ((s[1]).length < prec) {
+                s[1] = s[1]
+                s[1] += new Array(prec - s[1].length + 1).join('0')
+            }
+        }
+        
+        return s.join(dec)
+    }
+
+    /**
+    * @description 获取duration值
+    * 如果带有ms或者s直接返回，如果大于一定值，认为是ms单位，小于一定值，认为是s单位
+    * 比如以30位阈值，那么300大于30，可以理解为用户想要的是300ms，而不是想花300s去执行一个动画
+    * @param {String|number} value 比如: "1s"|"100ms"|1|100
+    * @param {boolean} unit  提示: 如果是false 默认返回number
+    * @return {string|number} 
+    */
+    function getDuration(value: any, unit = true): string {
+        let valueString = value.toString()
+        if (unit) {
+            if (/s$/.test(valueString)) {
+                return value.toString()
+            }
+            return parseInt(valueString) > 30 ? `${valueString}ms` : `${valueString}s`
+        }
+        let valueNum = 0
+        if (/(ms)$/.test(valueString)) {
+            valueNum = parseInt(valueString.slice(-2))
+            return valueNum.toString()
+        } else if (/(s)$/.test(valueString)) {
+            valueNum = parseInt(valueString.slice(-1))
+            return valueNum > 30 ? valueNum.toString() : (valueNum * 1000).toString()
+        } else {
+            valueNum = parseInt(valueString)
+            return valueNum.toString()
+        }
+    }
+
+    /**
+    * @description 日期的月或日补零操作
+    * @param {String} value 需要补零的值
+    */
+    function padZero(value: any): string {
+        let str = value.toString()
+        return `00${str}`.slice(-2)
+    }
+
+    /**
+    * @description 在up-form的子组件内容发生变化，或者失去焦点时，尝试通知up-form执行校验方法
+    * @param {*} instance
+    * @param {*} event
+    */
+    function formValidate(instance: any, event: any): void {
+        // todox
+        // const formItem = uni.$u.$parent.call(instance, 'up-form-item')
+        // const form = uni.$u.$parent.call(instance, 'up-form')
+        // // 如果发生变化的input或者textarea等，其父组件中有up-form-item或者up-form等，就执行form的validate方法
+        // // 同时将form-item的pros传递给form，让其进行精确对象验证
+        // if (formItem && form) {
+        // 	form.validateField(formItem.prop, () => {}, event)
+        // }
+    }
+
+    // /**
+    //  * @description 获取某个对象下的属性，用于通过类似'a.b.c'的形式去获取一个对象的的属性的形式
+    //  * @param {object} obj 对象
+    //  * @param {string} key 需要获取的属性字段
+    //  * @returns {*}
+    //  */
+    function getProperty(obj: UTSJSONObject, key: string): any {
+        if (null == obj) {
+            return ''
+        }
+        if (key === '') {
+            return ''
+        }
+        if (key.indexOf('.') !== -1) {
+            const keys = key.split('.')
+            let firstObj = (obj[keys[0]] ?? {}) as UTSJSONObject
+
+            for (let i = 1; i < keys.length; i++) {
+                if (firstObj != null) {
+                    firstObj = firstObj[keys[i]] as UTSJSONObject
+                }
+            }
+            return firstObj
+        }
+        return obj[key] ?? {}
+    }
+
+    // /**
+    //  * @description 设置对象的属性值，如果'a.b.c'的形式进行设置
+    //  * @param {object} obj 对象
+    //  * @param {string} key 需要设置的属性
+    //  * @param {string} value 设置的值
+    //  */
+    function setProperty(obj: UTSJSONObject, key: string, value: string): void {
+        if (typeof obj !== 'object') {
+            return
+        }
+        // 递归赋值
+        const inFn = function(_obj: object, keys: Array<string>, v: string) {
+            // 最后一个属性key
+            if (keys.length === 1) {
+                _obj[keys[0]] = v
+                return
+            }
+            // 0~length-1个key
+            while (keys.length > 1) {
+                const k = keys[0]
+                if (!_obj[k] || (typeof _obj[k] !== 'object')) {
+                    _obj[k] = {}
+                }
+                const key = keys.shift()
+                // 自调用判断是否存在属性，不存在则自动创建对象
+                inFn(_obj[k], keys, v)
+            }
+        }
+
+        if (typeof key !== 'string' || key === '') {
+
+        } else if (key.indexOf('.') !== -1) { // 支持多层级赋值操作
+            const keys = key.split('.')
+        //     inFn(obj, keys, value)
+        } else {
+            obj[key] = value
+        }
+    }
+
+    /**
+    * @description 获取当前页面路径
+    */
+    function page(): string {
+        const pages: Array<UniNormalPage> = getCurrentPages()
+        // 某些特殊情况下(比如页面进行redirectTo时的一些时机)，pages可能为空数组
+        let url = ''
+        // if (pages[pages.length - 1].route != null) {
+        // 	url = pages[pages.length - 1].route
+        // }
+        return `/${url}`
+    }
+
+    /**
+    * @description 获取当前路由栈实例数组
+    */
+    function pages(): Array<UniNormalPage> {
+        const pages: Array<UniNormalPage> = getCurrentPages()
+        return pages
+    }
+
+    function getParent(that: ComponentPublicInstance, name = ''): ComponentPublicInstance | null {
+        // console.log('that', that)
+        let parent = that.$parent
+        // 通过while历遍，这里主要是为了H5需要多层解析的问题
+        while (parent != null) {
+            // console.log(parent.$options)
+            // 父组件
+            if (
+                // parent.$options != null && 
+                parent.$options['name'] != null &&
+                parent.$options['name'] != name) {
+                // 如果组件的name不相等，继续上一级寻找
+                parent = parent.$parent
+            } else {
+                // return parent
+                break
+            }
+        }
+        return parent
+    }
+    
+    function getParentData(that: any, parentName: string): any {
+        console.log('that', JSON.stringify(that))
+        // 避免在created中去定义parent变量
+        //if (that.parent == null) that.parent = {}
+        // 这里的本质原理是，通过获取父组件实例(也即类似up-radio的父组件up-radio-group的this)
+        // 将父组件this中对应的参数，赋值给本组件(up-radio的this)的parentData对象中对应的属性
+        // 之所以需要这么做，是因为所有端中，头条小程序不支持通过this.parent.xxx去监听父组件参数的变化
+        // 此处并不会自动更新子组件的数据，而是依赖父组件up-radio-group去监听data的变化，手动调用更新子组件的方法去重新获取
+        // that.$data['parent'] = getParent(that, parentName)
+        // console.log('that.parent', that.parent)
+        // todo
+        // if (that.parent.children) {
+        //     // 如果父组件的children不存在本组件的实例，才将本实例添加到父组件的children中
+        //     that.parent.children.indexOf(that) === -1 && that.parent.children.push(that)
+        // }
+        // if (that.parent != null && that.parentData != null) {
+        //     // 历遍parentData中的属性，将parent中的同名属性赋值给parentData
+        //     UTSJSONObject.keys(that.parentData).map((key: string) => {
+        //         that.parentData[key] = that.parent[key]
+        //     })
+        // }
+        return {}
+    }
+    
+    return {
+        upGetRect,
+        bem,
+        range,
+        getPx,
+        sleep,
+        os,
+        sys,
+        getWindowInfo,
+        getDeviceInfo,
+        random,
+        guid,
+        addStyle,
+        addUnit,
+        deepClone,
+        deepMerge,
+        error,
+        randomArray,
+        timeFormat,
+        trim,
+        queryParams,
+        toast,
+        type2icon,
+        priceFormat,
+        getDuration,
+        padZero,
+        formValidate,
+        getProperty,
+        setProperty,
+        page,
+        pages,
+        getParent,
+        getParentData
+    };
+};