js常用的工具函数（ts版本）_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)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282