458 lines
11 KiB
JavaScript
458 lines
11 KiB
JavaScript
/*
|
|
* @Descripttion: 工具集
|
|
* @version: 2.0
|
|
* @LastEditors: sakuya
|
|
* @LastEditTime: 2026年1月15日
|
|
*/
|
|
|
|
import CryptoJS from 'crypto-js'
|
|
import sysConfig from '@/config'
|
|
|
|
const tool = {}
|
|
|
|
/**
|
|
* 检查是否为有效的值（非null、非undefined、非空字符串、非空数组、非空对象）
|
|
* @param {*} value - 要检查的值
|
|
* @returns {boolean}
|
|
*/
|
|
tool.isValid = function (value) {
|
|
if (value === null || value === undefined) {
|
|
return false
|
|
}
|
|
if (typeof value === 'string' && value.trim() === '') {
|
|
return false
|
|
}
|
|
if (Array.isArray(value) && value.length === 0) {
|
|
return false
|
|
}
|
|
if (typeof value === 'object' && Object.keys(value).length === 0) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* 防抖函数
|
|
* @param {Function} func - 要执行的函数
|
|
* @param {number} wait - 等待时间（毫秒）
|
|
* @param {boolean} immediate - 是否立即执行
|
|
* @returns {Function}
|
|
*/
|
|
tool.debounce = function (func, wait = 300, immediate = false) {
|
|
let timeout
|
|
return function (...args) {
|
|
const context = this
|
|
clearTimeout(timeout)
|
|
if (immediate && !timeout) {
|
|
func.apply(context, args)
|
|
}
|
|
timeout = setTimeout(() => {
|
|
timeout = null
|
|
if (!immediate) {
|
|
func.apply(context, args)
|
|
}
|
|
}, wait)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 节流函数
|
|
* @param {Function} func - 要执行的函数
|
|
* @param {number} wait - 等待时间（毫秒）
|
|
* @param {Object} options - 配置选项 { leading: boolean, trailing: boolean }
|
|
* @returns {Function}
|
|
*/
|
|
tool.throttle = function (func, wait = 300, options = {}) {
|
|
let timeout
|
|
let previous = 0
|
|
const { leading = true, trailing = true } = options
|
|
|
|
return function (...args) {
|
|
const context = this
|
|
const now = Date.now()
|
|
|
|
if (!previous && !leading) {
|
|
previous = now
|
|
}
|
|
|
|
const remaining = wait - (now - previous)
|
|
|
|
if (remaining <= 0 || remaining > wait) {
|
|
if (timeout) {
|
|
clearTimeout(timeout)
|
|
timeout = null
|
|
}
|
|
previous = now
|
|
func.apply(context, args)
|
|
} else if (!timeout && trailing) {
|
|
timeout = setTimeout(() => {
|
|
previous = leading ? Date.now() : 0
|
|
timeout = null
|
|
func.apply(context, args)
|
|
}, remaining)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 深拷贝对象（支持循环引用）
|
|
* @param {*} obj - 要拷贝的对象
|
|
* @param {WeakMap} hash - 用于检测循环引用
|
|
* @returns {*}
|
|
*/
|
|
tool.deepClone = function (obj, hash = new WeakMap()) {
|
|
if (obj === null || typeof obj !== 'object') {
|
|
return obj
|
|
}
|
|
|
|
if (hash.has(obj)) {
|
|
return hash.get(obj)
|
|
}
|
|
|
|
const clone = Array.isArray(obj) ? [] : {}
|
|
hash.set(obj, clone)
|
|
|
|
for (const key in obj) {
|
|
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
|
clone[key] = tool.deepClone(obj[key], hash)
|
|
}
|
|
}
|
|
|
|
return clone
|
|
}
|
|
|
|
/* localStorage */
|
|
tool.data = {
|
|
set(key, data, datetime = 0) {
|
|
//加密
|
|
if (sysConfig.LS_ENCRYPTION == 'AES') {
|
|
data = tool.crypto.AES.encrypt(JSON.stringify(data), sysConfig.LS_ENCRYPTION_key)
|
|
}
|
|
let cacheValue = {
|
|
content: data,
|
|
datetime: parseInt(datetime) === 0 ? 0 : new Date().getTime() + parseInt(datetime) * 1000,
|
|
}
|
|
return localStorage.setItem(key, JSON.stringify(cacheValue))
|
|
},
|
|
get(key) {
|
|
try {
|
|
const value = JSON.parse(localStorage.getItem(key))
|
|
if (value) {
|
|
let nowTime = new Date().getTime()
|
|
if (nowTime > value.datetime && value.datetime != 0) {
|
|
localStorage.removeItem(key)
|
|
return null
|
|
}
|
|
//解密
|
|
if (sysConfig.LS_ENCRYPTION == 'AES') {
|
|
value.content = JSON.parse(tool.crypto.AES.decrypt(value.content, sysConfig.LS_ENCRYPTION_key))
|
|
}
|
|
return value.content
|
|
}
|
|
return null
|
|
} catch {
|
|
return null
|
|
}
|
|
},
|
|
remove(key) {
|
|
return localStorage.removeItem(key)
|
|
},
|
|
clear() {
|
|
return localStorage.clear()
|
|
},
|
|
}
|
|
|
|
/*sessionStorage*/
|
|
tool.session = {
|
|
set(table, settings) {
|
|
const _set = JSON.stringify(settings)
|
|
return sessionStorage.setItem(table, _set)
|
|
},
|
|
get(table) {
|
|
const data = sessionStorage.getItem(table)
|
|
try {
|
|
return JSON.parse(data)
|
|
} catch {
|
|
return null
|
|
}
|
|
},
|
|
remove(table) {
|
|
return sessionStorage.removeItem(table)
|
|
},
|
|
clear() {
|
|
return sessionStorage.clear()
|
|
},
|
|
}
|
|
|
|
/*cookie*/
|
|
tool.cookie = {
|
|
/**
|
|
* 设置cookie
|
|
* @param {string} name - cookie名称
|
|
* @param {string} value - cookie值
|
|
* @param {Object} config - 配置选项
|
|
*/
|
|
set(name, value, config = {}) {
|
|
const cfg = {
|
|
expires: null,
|
|
path: null,
|
|
domain: null,
|
|
secure: false,
|
|
httpOnly: false,
|
|
sameSite: 'Lax',
|
|
...config,
|
|
}
|
|
let cookieStr = `${name}=${encodeURIComponent(value)}`
|
|
if (cfg.expires) {
|
|
const exp = new Date()
|
|
exp.setTime(exp.getTime() + parseInt(cfg.expires) * 1000)
|
|
cookieStr += `;expires=${exp.toUTCString()}`
|
|
}
|
|
if (cfg.path) {
|
|
cookieStr += `;path=${cfg.path}`
|
|
}
|
|
if (cfg.domain) {
|
|
cookieStr += `;domain=${cfg.domain}`
|
|
}
|
|
if (cfg.secure) {
|
|
cookieStr += `;secure`
|
|
}
|
|
if (cfg.sameSite) {
|
|
cookieStr += `;SameSite=${cfg.sameSite}`
|
|
}
|
|
document.cookie = cookieStr
|
|
},
|
|
/**
|
|
* 获取cookie
|
|
* @param {string} name - cookie名称
|
|
* @returns {string|null}
|
|
*/
|
|
get(name) {
|
|
const arr = document.cookie.match(new RegExp('(^| )' + name + '=([^;]*)(;|$)'))
|
|
if (arr != null) {
|
|
return decodeURIComponent(arr[2])
|
|
}
|
|
return null
|
|
},
|
|
/**
|
|
* 删除cookie
|
|
* @param {string} name - cookie名称
|
|
*/
|
|
remove(name) {
|
|
const exp = new Date()
|
|
exp.setTime(exp.getTime() - 1)
|
|
document.cookie = `${name}=;expires=${exp.toUTCString()}`
|
|
},
|
|
}
|
|
|
|
/* Fullscreen */
|
|
/**
|
|
* 切换全屏状态
|
|
* @param {HTMLElement} element - 要全屏的元素
|
|
*/
|
|
tool.screen = function (element) {
|
|
const isFull = !!(document.webkitIsFullScreen || document.mozFullScreen || document.msFullscreenElement || document.fullscreenElement)
|
|
if (isFull) {
|
|
if (document.exitFullscreen) {
|
|
document.exitFullscreen()
|
|
} else if (document.msExitFullscreen) {
|
|
document.msExitFullscreen()
|
|
} else if (document.mozCancelFullScreen) {
|
|
document.mozCancelFullScreen()
|
|
} else if (document.webkitExitFullscreen) {
|
|
document.webkitExitFullscreen()
|
|
}
|
|
} else {
|
|
if (element.requestFullscreen) {
|
|
element.requestFullscreen()
|
|
} else if (element.msRequestFullscreen) {
|
|
element.msRequestFullscreen()
|
|
} else if (element.mozRequestFullScreen) {
|
|
element.mozRequestFullScreen()
|
|
} else if (element.webkitRequestFullscreen) {
|
|
element.webkitRequestFullscreen()
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 复制对象（浅拷贝） */
|
|
/**
|
|
* 浅拷贝对象
|
|
* @param {*} obj - 要拷贝的对象
|
|
* @returns {*} - 拷贝后的对象
|
|
*/
|
|
tool.objCopy = function (obj) {
|
|
if (obj === null || typeof obj !== 'object') {
|
|
return obj
|
|
}
|
|
return JSON.parse(JSON.stringify(obj))
|
|
}
|
|
|
|
/* 日期格式化 */
|
|
/**
|
|
* 格式化日期
|
|
* @param {Date|string|number} date - 日期对象、时间戳或日期字符串
|
|
* @param {string} fmt - 格式化字符串，默认 "yyyy-MM-dd hh:mm:ss"
|
|
* @returns {string} - 格式化后的日期字符串
|
|
*/
|
|
tool.dateFormat = function (date, fmt = 'yyyy-MM-dd hh:mm:ss') {
|
|
if (!date) return ''
|
|
const dateObj = new Date(date)
|
|
if (isNaN(dateObj.getTime())) return ''
|
|
|
|
const o = {
|
|
'M+': dateObj.getMonth() + 1, // 月份
|
|
'd+': dateObj.getDate(), // 日
|
|
'h+': dateObj.getHours(), // 小时
|
|
'm+': dateObj.getMinutes(), // 分
|
|
's+': dateObj.getSeconds(), // 秒
|
|
'q+': Math.floor((dateObj.getMonth() + 3) / 3), // 季度
|
|
S: dateObj.getMilliseconds(), // 毫秒
|
|
}
|
|
if (/(y+)/.test(fmt)) {
|
|
fmt = fmt.replace(RegExp.$1, (dateObj.getFullYear() + '').substr(4 - RegExp.$1.length))
|
|
}
|
|
for (const k in o) {
|
|
if (new RegExp('(' + k + ')').test(fmt)) {
|
|
fmt = fmt.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k] : ('00' + o[k]).substr(('' + o[k]).length))
|
|
}
|
|
}
|
|
return fmt
|
|
}
|
|
|
|
/* 千分符 */
|
|
/**
|
|
* 格式化数字，添加千分位分隔符
|
|
* @param {number|string} num - 要格式化的数字
|
|
* @param {number} decimals - 保留小数位数，默认为0
|
|
* @returns {string} - 格式化后的字符串
|
|
*/
|
|
tool.groupSeparator = function (num, decimals = 0) {
|
|
if (num === null || num === undefined || num === '') return ''
|
|
const numStr = Number(num).toFixed(decimals)
|
|
const parts = numStr.split('.')
|
|
parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ',')
|
|
return parts.join('.')
|
|
}
|
|
|
|
/* 常用加解密 */
|
|
tool.crypto = {
|
|
//MD5加密
|
|
MD5(data) {
|
|
return CryptoJS.MD5(data).toString()
|
|
},
|
|
//BASE64加解密
|
|
BASE64: {
|
|
encrypt(data) {
|
|
return CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(data))
|
|
},
|
|
decrypt(cipher) {
|
|
return CryptoJS.enc.Base64.parse(cipher).toString(CryptoJS.enc.Utf8)
|
|
},
|
|
},
|
|
//AES加解密
|
|
AES: {
|
|
encrypt(data, secretKey, config = {}) {
|
|
if (secretKey.length % 8 != 0) {
|
|
console.warn('[SCUI error]: 秘钥长度需为8的倍数，否则解密将会失败。')
|
|
}
|
|
const result = CryptoJS.AES.encrypt(data, CryptoJS.enc.Utf8.parse(secretKey), {
|
|
iv: CryptoJS.enc.Utf8.parse(config.iv || ''),
|
|
mode: CryptoJS.mode[config.mode || 'ECB'],
|
|
padding: CryptoJS.pad[config.padding || 'Pkcs7'],
|
|
})
|
|
return result.toString()
|
|
},
|
|
decrypt(cipher, secretKey, config = {}) {
|
|
const result = CryptoJS.AES.decrypt(cipher, CryptoJS.enc.Utf8.parse(secretKey), {
|
|
iv: CryptoJS.enc.Utf8.parse(config.iv || ''),
|
|
mode: CryptoJS.mode[config.mode || 'ECB'],
|
|
padding: CryptoJS.pad[config.padding || 'Pkcs7'],
|
|
})
|
|
return CryptoJS.enc.Utf8.stringify(result)
|
|
},
|
|
},
|
|
}
|
|
|
|
/* 树形数据转扁平数组 */
|
|
/**
|
|
* 将树形结构转换为扁平数组
|
|
* @param {Array} tree - 树形数组
|
|
* @param {Object} config - 配置项 { children: "children" }
|
|
* @returns {Array} - 扁平化后的数组
|
|
*/
|
|
tool.treeToList = function (tree, config = { children: 'children' }) {
|
|
const result = []
|
|
tree.forEach((item) => {
|
|
const tmp = { ...item }
|
|
const childrenKey = config.children || 'children'
|
|
|
|
if (tmp[childrenKey] && tmp[childrenKey].length > 0) {
|
|
result.push({ ...item })
|
|
const childrenRoutes = tool.treeToList(tmp[childrenKey], config)
|
|
result.push(...childrenRoutes)
|
|
} else {
|
|
result.push(tmp)
|
|
}
|
|
})
|
|
return result
|
|
}
|
|
|
|
/* 获取父节点数据（保留原有函数名） */
|
|
/**
|
|
* 根据ID获取父节点数据
|
|
* @param {Array} list - 数据列表
|
|
* @param {number|string} targetId - 目标ID
|
|
* @param {Object} config - 配置项 { pid: "parent_id", idField: "id", field: [] }
|
|
* @returns {*} - 父节点数据或指定字段
|
|
*/
|
|
tool.get_parents = function (list, targetId = 0, config = { pid: 'parent_id', idField: 'id', field: [] }) {
|
|
let res = null
|
|
list.forEach((item) => {
|
|
if (item[config.idField || 'id'] === targetId) {
|
|
if (config.field && config.field.length > 1) {
|
|
res = {}
|
|
config.field.forEach((field) => {
|
|
res[field] = item[field]
|
|
})
|
|
} else if (config.field && config.field.length === 1) {
|
|
res = item[config.field[0]]
|
|
} else {
|
|
res = item
|
|
}
|
|
}
|
|
})
|
|
return res
|
|
}
|
|
|
|
/* 获取数据字段 */
|
|
/**
|
|
* 从数据对象中提取指定字段
|
|
* @param {Object} data - 数据对象
|
|
* @param {Array} fields - 字段名数组
|
|
* @returns {*} - 提取的字段数据
|
|
*/
|
|
tool.getDataField = function (data, fields = []) {
|
|
if (!data || typeof data !== 'object') {
|
|
return data
|
|
}
|
|
if (fields.length === 0) {
|
|
return data
|
|
}
|
|
if (fields.length === 1) {
|
|
return data[fields[0]]
|
|
} else {
|
|
const result = {}
|
|
fields.forEach((field) => {
|
|
result[field] = data[field]
|
|
})
|
|
return result
|
|
}
|
|
}
|
|
|
|
// 兼容旧函数名
|
|
tool.tree_to_list = tool.treeToList
|
|
tool.get_data_field = tool.getDataField
|
|
|
|
export default tool
|