js常用的工具函数（ts版本）

前言

自己整理的一些比较常用的一些工具函数，有的是自己写的也有的是网上搬的，后续也会持续更新，如果你有好的建议或者有好的比较常用的工具函数都可以提。

常用的js工具函数

/** (1)
 * 把路径转换成驼峰命名 
 * @param path 路径
 * @returns  返回转码后的名
 */
export const pathToCamel = (path: string): string => {
  return path.replace(/\/(\w)/g, (all, letter) => letter.toUpperCase())
}

/** (2)
 * 实现深拷贝函数
 * @param data 需要深拷贝的数据
 * @returns 返回拷贝后的数据
 */
export const deepClone = (data: any): any => {
  try {
    const type = judgeType(data)
    let obj: any = null
    if (type == 'array') {
      obj = []
      for (let i = 0; i < data.length; i++) {
        obj.push(deepClone(data[i]))
      }
    } else if (type == 'object') {
      obj = {}
      for (let key in data) {
        if (data.hasOwnProperty(key)) {
          obj[key] = deepClone(data[key])
        }
      }
    } else {
      return data
    }
    return obj
  } catch (e: any) {
    return JSON.parse(JSON.stringify(data))
  }
}

/** (3)
 * 判断传入的对象是什么类型
 * @param obj 任意对象
 * @returns 对象类型
 */
export const judgeType = (obj: any): any => {
  // tostring会返回对应不同的标签的构造函数
  const toString = Object.prototype.toString
  const map: any = {
    '[object Boolean]': 'boolean',
    '[object Number]': 'number',
    '[object String]': 'string',
    '[object Function]': 'function',
    '[object Array]': 'array',
    '[object Date]': 'date',
    '[object RegExp]': 'regExp',
    '[object Undefined]': 'undefined',
    '[object Null]': 'null',
    '[object Object]': 'object'
  }
  if (obj instanceof Element) {
    return 'element'
  }
  return map[toString.call(obj)]
}

/** (4)
 * 获取随机的四位字母
 * @param n 获取随机字符串的长度
 * @returns 指定位数的随机字符串
 */
export const getRandomNumber = (n: number = 4): string => {
  return (Math.random() * 1000).toString(32).substring(3, n + 3)
}

/** (5)
 * 数组去重 每一项均为基础的常规的数据类型时使用
 * @param arr 需要去重的数组
 * @returns 去重后的数组
 */
export const distinctArray = (arr: Array<string | number>): any => {
  return Array.from(new Set(arr))
}
/** (6)
 * 数组排序
 * @param json  需要排序的对象
 * @param key   排序的属性
 * @returns  返回排序后的数据
 */
export const sortByProp = (json: any, key: string): any => {
  if (!Array.isArray(json)) return
  let news = ''
  let copyJson = deepClone(json)
  for (let i = 0; i <= copyJson.length; i++) {
    for (let j = 0; j < copyJson.length - 1; j++) {
      if (copyJson[j][key] < copyJson[j + 1][key]) {
        news = copyJson[j]
        copyJson[j] = copyJson[j + 1]
        copyJson[j + 1] = news
      }
    }
  }
  return copyJson
}

/** (7)
 * 排序数字数组
 * @param arr 需要排序的数组
 * @returns 返回排序后的数组
 */
export const sortNumber = (arr: Array<number>): Array<number> => {
  let newArr = deepClone(arr)
  let len = newArr.length
  for (let i = 0; i < len; i++) {
    for (let j = 0; j < len - 1; j++) {
      if (newArr[j] > newArr[j + 1]) {
        let temp = newArr[j]
        newArr[j] = newArr[j + 1]
        newArr[j + 1] = temp
      }
    }
  }
  return newArr
}

/**
 * (8)
 * @param time 传入时间
 * @returns  返回传入时间对应的年月日时分秒
 */
export const getTime = (t: string | Date | number): any => {
  if (!t) return ''
  let time = new Date(t)
  let year = time.getFullYear() //获取年份
  let month = checkTime(time.getMonth() + 1) //获取月份
  let day = checkTime(time.getDate()) //获取日期
  let hour = checkTime(time.getHours()) //获取时
  let minite = checkTime(time.getMinutes()) //获取分
  let second = checkTime(time.getSeconds()) //获取秒
  return `${year}/${month}/${day} ${hour}:${minite}:${second} `
}
// (9) 不足多少位前面补零
export const checkTime = (i: number,l:number=2): any => {
  return i.toString().padStart(l, '0')
}

/** (10)
 * 获取指定时间对应的星期
 * @param t 当前时间
 * @returns 返回时间对应的星期
 */
export const getWeek = (t: string | Date | number): any => {
  if (!t) return ''
  let time = new Date(t)
  let week = time.getDay()
  switch (week) {
    case 1:
      return '星期一'
    case 2:
      return '星期二'
    case 3:
      return '星期三'
    case 4:
      return '星期四'
    case 5:
      return '星期五'
    case 6:
      return '星期六'
    case 0:
      return '星期日'
  }
}

/** (11)
 * 获取两个时间的差
 * @param start 开始的时间
 * @param end 结束的时间
 * @returns 时间段相差的  { day, hour, min, afterMin }
 */
export const getDiffer = (start: string | Date | number, end: string | Date | number): any => {
  if (!start || !end) return
  let date1 = new Date(start)
  let date2 = new Date(end)

  let s1 = date1.getTime()
  let s2 = date2.getTime()
  let total: any = (s2 - s1) / 1000

  let day = parseInt((total / (24 * 60 * 60)).toString()) //计算整数天数
  let afterDay = total - day * 24 * 60 * 60 //取得算出天数后剩余的秒数
  let hour = parseInt((afterDay / (60 * 60)).toString()) //计算整数小时数
  let afterHour = total - day * 24 * 60 * 60 - hour * 60 * 60 //取得算出小时数后剩余的秒数
  let min = parseInt((afterHour / 60).toString()) //计算整数分
  let afterMin = (total - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60).toFixed(0) //取得算出分后剩余的秒数

  return { day, hour, min, afterMin }
}

/** (12)
 * 判断字符串是否为JSON格式
 * @param str 字符串
 * @returns 返回结果
 */
export const isJSON = (str: string): boolean => {
  if (typeof str == 'string') {
    try {
      var obj = JSON.parse(str)
      if (typeof obj == 'object' && obj) {
        return true
      } else {
        return false
      }
    } catch (e) {
      return false
    }
  }
  return false
}

/** (13)
 * 防抖代码 传入方法和时间 时间内记录执行最后一次提交
 */
export let time: any = null
export const debounce = (fn: any, delay: number) => {
  //设置time为定时器

  //闭包原理，返回一个函数
  if (time) {
    clearTimeout(time)
    time = null
  }
  time = setTimeout(fn, delay)
}

/** (14)
 * 扁平化数组
 * @param arr  需要扁平化的数组
 * @returns  返回扁平化的结果
 */
export const flatten = (arr: Array<any>): Array<any> => {
  let result: any = []

  for (let i = 0; i < arr.length; i++) {
    if (Array.isArray(arr[i])) {
      result = result.concat(flatten(arr[i]))
    } else {
      result.push(arr[i])
    }
  }
  return result
}

/** (15)
 * 去除字符串空格
 * @param str 字符串
 * @returns 返回去除空格后的结果
 */
export const trimSpace = (str: string): string => {
  return str.replace(/\s*/g, '')
}

/** (16)
 * 将数字转为价格的效果 ￥121,281,271.22
 * @param str 字符串
 * @returns 返回去除空格后的结果
 */
export const formatMoney = (strNum: string, symbol: string = '', decimals: number = 2): string => {
  if (typeof strNum === 'number') {
    return `${symbol}${parseFloat(formatToFixed(strNum, decimals)).toLocaleString('zh', { maximumFractionDigits: decimals, useGrouping: true })}`
  }
  return strNum
}

/** (17)
 * 字符串数字取整 四舍五入 toFixed() 精度问题
 * @param strNum 字符串数字
 * @param decimals 保留多少位小数
 * @returns 返回取整结果
 */
export const formatToFixed = (strNum: string, decimals = 2): string => {
  return (Math.round((parseFloat(strNum) + Number.EPSILON) * Math.pow(10, decimals)) / Math.pow(10, decimals)).toFixed(decimals)
}