# rs-commonjs

> 项目中常用的方法

Latest version **1.4.4** (published 2023-07-07) · ISC license · 0 weekly downloads

## Install

```sh
npm install rs-commonjs
pnpm add rs-commonjs
yarn add rs-commonjs
bun add rs-commonjs
```

## Health

**Score 25/100 (F)** — status: abandoned.

Positive: has types; no vulnerabilities; high quality score.

Warnings: low downloads; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.4.4 |
| Published | 2023-07-07 |
| First published | 2023-03-22 |
| Weekly downloads | 0 |
| License | ISC |
| TypeScript types | bundled |
| Module format | CommonJS |
| Dependencies | 0 |
| Unpacked size | 43.1 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Author | wangxiaofang1 |
| Maintainers | wangxiaofang1 |

## Links

- npm: https://www.npmjs.com/package/rs-commonjs
- npm.io page: https://npm.io/package/rs-commonjs

## Recent versions

- 1.4.4 (latest) — 2023-07-07
- 1.4.3 — 2023-06-20
- 1.4.2 — 2023-06-06
- 1.4.1 — 2023-06-06
- 1.4.0 — 2023-05-30
- 1.3.0 — 2023-05-30
- 1.2.0 — 2023-05-30
- 1.1.0 — 2023-05-30
- 1.0.0 — 2023-03-22

## README

#### rs-common 公共方法

##### uuid 通用唯一识别码

```js
/**
 * 通用唯一识别码
 * @rerurns string
 */
getuuid();
```

##### seStorage 设置本地存储

```js
/**
 * 设置本地存储
 * @param {*} name 存储字段
 * @param {*} content 存储内容
 * @param {*} storage 存储位置 sessionStorage / localStorage, 默认 sessionStorage
 */
seStorage(name, content, (storage = "sessionStorage"));
```

| 参数    | 默认值         | 可选值                        | 是否必填 | 说明     |
| ------- | -------------- | ----------------------------- | -------- | -------- |
| name    |                |                               | true     | 存储字段 |
| content |                |                               | true     | 存储内容 |
| storage | sessionStorage | sessionStorage / localStorage | false    | 存储位置 |

##### getStorage 获取本地存储

```js
/**
 * 获取本地存储
 * @param {*} name 存储字段
 * @param {*} storage 存储位置 sessionStorage / localStorage, 默认 sessionStorage
 * @returns string | object | array
 */
getStorage(name, (storage = "sessionStorage"));
```

| 参数    | 默认值         | 可选值                        | 是否必填 | 说明     |
| ------- | -------------- | ----------------------------- | -------- | -------- |
| name    |                |                               | true     | 存储字段 |
| storage | sessionStorage | sessionStorage / localStorage | false    | 存储位置 |

##### removeStorage 删除本地存储

```js
/**
 * 删除本地存储
 * @param {*} name 存储字段
 * @param {*} storage 存储位置 sessionStorage / localStorage, 默认 sessionStorage
 */
removeStorage(name, (storage = "sessionStorage"));
```

| 参数    | 默认值         | 可选值                        | 是否必填 | 说明     |
| ------- | -------------- | ----------------------------- | -------- | -------- |
| name    |                |                               | true     | 存储字段 |
| storage | sessionStorage | sessionStorage / localStorage | false    | 存储位置 |

##### formatTime 日期格式化

```js
/**
 * 日期格式化
 * @param {*} date 日期类型 Date | string | null | undefined | number
 * @param {*} format 日期格式  默认 yyyy-MM-dd HH:mm:ss
 * @returns 格式化后的日期字符串
 */
formatTime(date, (format = "yyyy-MM-dd HH:mm:ss"));
```

| 参数   | 默认值              | 可选值                                    | 是否必填 | 说明     |
| ------ | ------------------- | ----------------------------------------- | -------- | -------- |
| date   |                     | Date / string / null / undefined / number | true     | 日期类型 |
| format | yyyy-MM-dd HH:mm:ss |                                           | false    | 日期格式 |

##### formatTimeByStr 将字符串转成日期格式

```js
/**
 * @description: 将字符串转成日期格式
 * @param dateStr 日期字符串 如20220321 -> 2022-03-21
 * @param format  日期格式  默认 yyyy-MM-dd格式 （yyyy-MM-dd HH:mm:ss）
 * @returns 格式化后的日期字符串
 */
formatTimeByStr(dateStr, (format = "yyyy-MM-dd"));
```

| 参数    | 默认值     | 可选值                                    | 是否必填 | 说明       |
| ------- | ---------- | ----------------------------------------- | -------- | ---------- |
| dateStr |            | Date / string / null / undefined / number | true     | 日期字符串 |
| format  | yyyy-MM-dd | yyyy-MM-dd HH:mm:ss                       | false    | 日期格式   |

##### beforeTime 获取之前的日期

```js
/**
 * 获取之前的日期
 * @param {*} date 日期类型 Date | string | null | undefined | number
 * @param {number} num 小时数
 * @param {string} type 类型， hour/day/month/year
 * @param {string} format 日期格式
 * @returns 前几小时的完整日期
 */
beforeTime(date, num, type, format?);
```

| 参数   | 默认值 | 可选值                                    | 是否必填 | 说明                                       |
| ------ | ------ | ----------------------------------------- | -------- | ------------------------------------------ |
| date   |        | Date / string / null / undefined / number | true     | 日期类型                                   |
| num    |        | number                                    | true     | 数量                                       |
| type   | day    | hour/day/month/year                       | true     | 处理类型，day - 前几天，hour - 前几小时... |
| format |        | yyyy-MM-dd HH:mm:ss                       | false    | 日期格式,不传则默认返回 Date 格式的数据    |

##### deepCopy 深拷贝复杂类型变量

```js
/**
 * 深拷贝复杂类型变量
 * @param {object} target 复杂类型数据 object
 * @returns 新的复杂数据
 */
deepCopy(target);
```

| 参数   | 默认值 | 可选值 | 是否必填 | 说明     |
| ------ | ------ | ------ | -------- | -------- |
| target |        |        | true     | 目标数据 |

##### mergeObjAttr 合并对象

```js
/**
 * 合并对象
 * @param {*} origin 原始对象
 * @param {*} target 目标对象，需要被合并的对象
 * @param {*} rtNewObj 是否返回一个新对象，默认为false
 * @param {*} level 当前遍历层级，属于内部参数，调用时不必传入
 * @returns
 */
mergeObjAttr(origin, target, (rtNewObj = false), (level = 1));
```

| 参数     | 默认值 | 可选值 | 是否必填 | 说明                                       |
| -------- | ------ | ------ | -------- | ------------------------------------------ |
| origin   |        |        | true     | 原始对象                                   |
| target   |        |        | true     | 目标对象，需要被合并的对象                 |
| rtNewObj | false  |        | false    | 是否返回一个新对象，默认为 false           |
| level    | 1      |        | false    | 当前遍历层级，属于内部参数，调用时不必传入 |

##### mergeArray 合并数组

```js
/**
 * 合并数组
 * 这个合并数组并不是一般的合并，它跟普通的合并区别在于如果大家都是对象则合并属性，参考mergeObjAttr方法
 * @param origin: 原始数组
 * @param target: 目标数组
 * @param rtNewArray: 是否返回一个新数组，默认为false
 * @param level: 当前遍历层级，属于内部参数，调用时不必传入
 */
mergeArray(origin, target, (rtNewArray = false), (level = 1));
```

| 参数       | 默认值 | 可选值 | 是否必填 | 说明                                       |
| ---------- | ------ | ------ | -------- | ------------------------------------------ |
| origin     |        |        | true     | 原始数组                                   |
| target     |        |        | true     | 目标数组，需要被合并的对象                 |
| rtNewArray | false  |        | false    | 是否返回一个新数组，默认为 false           |
| level      | 1      |        | false    | 当前遍历层级，属于内部参数，调用时不必传入 |

##### getDataType 获取数据类型

```js
/**
 * 获取数据类型
 * @param {*} data 数据
 * @param {boolean} isStatic 是否严格, 默认false, 即在object下， 只区分array, 不做Date等的区分
 * @returns 返回数据类型 object/array/string/....
 */
getDataType(data);
```

| 参数     | 默认值 | 可选值  | 是否必填 | 说明                                                                                  |
| -------- | ------ | ------- | -------- | ------------------------------------------------------------------------------------- |
| data     |        | any     | true     | 目标数据                                                                              |
| isStatic | false  | boolean | false    | 是否返回严格的数据类型，默认 false, 即在 object 下， 只区分 array, 不做 Date 等的区分 |

##### cleanData 规范字典数据

```js
/**
 * 规范字典数据
 * @param {*} dic {Object} key对象 如{value:"code",label:"name"} 即code->value name->label，意思是将原数据中code字段的数据赋值给value字段
 * @param {*} data {Array}  需处理的数据
 * @param {*} keep {Array}  是否保留原数据的其他字段
 * @param {*} childrenName {Object} 子数据的key值替换  如{'children':'childs'}  将原数据中的childs转成children
 * @returns array
 */
cleanData(data, dic, (keep = false), (childrenName = { children: "children" }));
```

| 参数         | 默认值                           | 可选值 | 是否必填 | 说明                     |
| ------------ | -------------------------------- | ------ | -------- | ------------------------ |
| data         | []                               |        | true     | 需处理的数据             |
| dic          | {value: dataKey, label: dataKey} |        | true     | key 对象                 |
| keep         | false                            |        | false    | 是否保留原数据的其他字段 |
| childrenName | {'children': dataKey}            |        | false    | 子数据的 key 值替换      |

##### flatData 扁平化数组对象数据

```js
/**
 * 扁平化数组对象数据, 将树结构 -》 列表数据
 * @param {Array} data   需处理的数据
 * @param {Object} dic  key对象 如{resule:"code",label:"name"} 即code->value name->label 为{}则不存在转化字段
 * @param {String} childName  子集的集合字段
 * @returns array 一维数组
 */
flatData(data, (dic = {}), (childName = "children"));
```

| 参数      | 默认值   | 可选值                    | 是否必填 | 说明           |
| --------- | -------- | ------------------------- | -------- | -------------- |
| data      | []       |                           | true     | 需处理的数据   |
| dic       | {}       | {resultKey: dataKey, ...} | false    | key 对象       |
| childName | children |                           | false    | 子集的集合字段 |

##### arrToObj 将数组转成对象

```js
/**
 * @param {*} data 数组数据
 * @param {*} dataKey 以数组中哪一个字段的数据作为对象的key
 * @param {Object} dic  key对象 如{resultKey: dataKey,...}  为{}则不存在转化字段
 * @returns object
 */
arrToObj(data, (dic = {}), (childName = "children"));
```

| 参数    | 默认值 | 可选值                   | 是否必填 | 说明                                   |
| ------- | ------ | ------------------------ | -------- | -------------------------------------- |
| data    | []     |                          | true     | 数组数据                               |
| dataKey |        | data 里面任意的 key      | true     | 以数组中哪一个字段的数据作为对象的 key |
| dic     | {}     | {resultKey: dataKey,...} | false    | 转化字段配置， 为{}则不存在转化字段    |

##### listToTree 把列表数据转换成树结构, 列表数据必须有父节点标识

```js
/**
 * 把列表数据转换成树结构, 列表数据必须有父节点标识
 * @param {*} data 列表数据
 * @param {*} parentId 父节点的唯一标识数据
 * @param {*} dic {id: dataKey, parentId: dataKey2,...}
 * @param {*} level
 * @returns array
 */
listToTree(data, (parentId = null), dic, (level = 0));
```

| 参数     | 默认值                           | 可选值 | 是否必填 | 说明         |
| -------- | -------------------------------- | ------ | -------- | ------------ |
| data     | []                               |        | true     | 需处理的数据 |
| parentId |                                  |        | true     | 父节点的 id  |
| dic      | {id: dataKey, parentId: dataKey} |        | true     | key 对象     |
| level    | {value: dataKey, label: dataKey} |        | true     | 层级         |

##### cleanDataByChart 处理 echarts 的数据

```js
/**
 * 处理echarts的数据
 * @param {*} data object/array
 * @param {*} dic {resultKey1: dataKey1, resultKey2: {value: dataKey2, ...}}
 * @returns {object}
 */
cleanDataByChart(data, dic);
```

| 参数 | 默认值                                                     | 可选值       | 是否必填 | 说明         |
| ---- | ---------------------------------------------------------- | ------------ | -------- | ------------ |
| data | []                                                         | array/object | true     | 需处理的数据 |
| dic  | {resultKey1: dataKey1, resultKey2: {value: dataKey2, ...}} |              | true     | key 对象     |

##### dealWithData 处理判空数据

```js
/**
 * 处理判空数据
 * @param {number | null | undefined | string} data 数据
 * @param {string} unit 单位
 * @param {object} base {
 *   emptyArr: [], - 判空的集合，不传则默认为[null, undefined]
 *   abs: false,  - 是否取绝对值
 *   subValue: "-", - 数据为空时替代的文本, 不传则默认为 '-'
 *   subUnit: '',  - 数据为空时替代的单位，不传则使用unit
 *   fn: null - 在判断emptyArr之后判断的方法
 * }
 * @returns {string|*}
 */
dealWithData(data, unit, base);
```

| 参数 | 默认值 | 可选值                                                                 | 是否必填 | 说明           |
| ---- | ------ | ---------------------------------------------------------------------- | -------- | -------------- |
| data |        | number / null / undefined /string                                      | true     | 需处理的数据   |
| unit |        |                                                                        | false    | 单位, 默认为'' |
| base |        | { emptyArr: [], abs: false, subValue: "-", subUnit: '', fn: () => '' } | false    | 配置           |

##### formatNumber 格式化数字

```js
/**
 * 格式化数字
 * @param {number | null | undefined | string} data 数据
 * @param {number} fixedNum 保留的小数位数，默认不处理
 * @param {string} unit 单位
 * @returns {string|*}
 */
formatNumber(num, fixedNum, unit);
```

| 参数     | 默认值 | 可选值                            | 是否必填 | 说明                       |
| -------- | ------ | --------------------------------- | -------- | -------------------------- |
| data     |        | number / null / undefined /string | true     | 需处理的数据               |
| fixedNum |        |                                   | false    | 保留的小数位数，默认不处理 |
| unit     | ''     |                                   | false    | 单位                       |

##### inRange 判断数据是否在区间中

```js
/**
 * 判断数据是否在区间中
 * @param {number} number 目标数据
 * @param {string} range 比较范围 []/[)/()/(]
 * @param {string} compareType 判断类型 取值： in - 区间内 out - 区间外
 *
 * @returns boolean
 */
inRange(number, range, (compareType = "in"));
```

| 参数        | 默认值 | 可选值                              | 是否必填 | 说明                              |
| ----------- | ------ | ----------------------------------- | -------- | --------------------------------- |
| number      |        | number / null / undefined /string   | true     | 目标数据                          |
| range       |        | '[0,10]'/'[0,10)'/'(0,10)'/'(0,10]' | true     | 比较范围                          |
| compareType | in     | in/out                              | false    | 判断类型 in - 区间内 out - 区间外 |

##### equals 判断数据是否相等

```js
/**
 * 判断数据是否相等
 * @param {*} data1 数据1
 * @param {*} data2 数据2
 * @param {*} compare 比较的基准 ==/===
 * @returns boolean
 */
equals(data1, data2, (compare = "=="));
```

| 参数    | 默认值 | 可选值                                     | 是否必填 | 说明       |
| ------- | ------ | ------------------------------------------ | -------- | ---------- |
| data1   |        | number / null / undefined /string / object | true     | 数据 1     |
| data2   |        | number / null / undefined /string / object | true     | 数据 2     |
| compare | ==     | == / ===                                   | false    | 比较的基准 |

##### downloadFile 导出文件

```js
/**
 * 导出文件
 * @param blob 文件|blob类型
 * @param downloadName 导出的文件名称
 * @param type 文件扩展名 | 默认xls
 * @param defDate 文件名后面是否要加上日期 | 默认true
 */
downloadFile(blob, downloadName, (type = "xls"), (defDate = true));
```

| 参数         | 默认值 | 可选值 | 是否必填 | 说明                     |
| ------------ | ------ | ------ | -------- | ------------------------ |
| blob         |        | blob   | true     | 文件二进制流             |
| downloadName |        | string | true     | 导出的文件名称           |
| type         | xls    |        | false    | 文件扩展名               |
| defDate      | true   |        | false    | 文件名后面是否要加上日期 |

##### filterAsyncRoutes 获取权限路由

```js
/**
 * 获取权限路由
 * @param routes  本地配置的路由资源
 * @param resource  后端返回的权限资源
 * @returns {[]}
 */
filterAsyncRoutes(routes, resource);
```

| 参数     | 默认值 | 可选值 | 是否必填 | 说明               |
| -------- | ------ | ------ | -------- | ------------------ |
| routes   | []     |        | true     | 本地配置的路由资源 |
| resource | []     |        | true     | 后端返回的权限资源 |

##### getRealApi 获取目标 api

```js
/**
 * 获取api
 * @param {*} apiStr api组装的字符串
 * @param {*} apis   api集合
 */
getRealApi(apiStr, apis);
```

| 参数   | 默认值            | 可选值 | 是否必填 | 说明             |
| ------ | ----------------- | ------ | -------- | ---------------- |
| apiStr | 'xxx.xxxx'        | string | true     | api 组装的字符串 |
| apis   | {xxx: {xxxx: ''}} | object | true     | api 集合         |

##### debounce 防抖

```js
/** 防抖函数
 * @param {Function} func
 * @param {number} wait
 * @param {boolean} immediate
 * @param {object} context
 * @return {Function} 事件处理函数
 */
debounce(fn, delay, immediate, context);
```

| 参数      | 默认值   | 可选值   | 是否必填 | 说明         |
| --------- | -------- | -------- | -------- | ------------ |
| fn        | () => {} | function | true     | 执行的方法   |
| delay     | 1000     | number   | true     | 延时时间     |
| immediate | false    | boolean  | false    | 是否立即执行 |
| context   | this     |          |          | 上下文对象   |

##### throttle 节流函数

```js
/** 防抖函数
 * @param {Function} func
 * @param {number} wait
 * @param {boolean} immediate
 * @param {object} context
 * @return {Function} 事件处理函数
 */
throttle(fn, (delay = 200), (immediate = false), (context = this));
```

| 参数      | 默认值   | 可选值   | 是否必填 | 说明         |
| --------- | -------- | -------- | -------- | ------------ |
| fn        | () => {} | function | true     | 执行的方法   |
| delay     | 1000     | number   | true     | 延时时间     |
| immediate | false    | boolean  | false    | 是否立即执行 |
| context   | this     |          |          | 上下文对象   |

##### initPromise 设置微任务事件

```js
/** 设置微任务事件
 * @param {Function} callback
 */
initPromise(callback);
```

| 参数     | 默认值   | 可选值   | 是否必填 | 说明       |
| -------- | -------- | -------- | -------- | ---------- |
| callback | () => {} | function | true     | 执行的方法 |

---
_Source: https://npm.io/package/rs-commonjs · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._