jsutils api

js工具类
时间示例演示：https://zhtt.gitee.io/angular-demo/great-ngform6/#/jsutils/time-test、

数组示例演示：https://zhtt.gitee.io/angular-demo/great-ngform6/#/jsutils/array-test

$3

great-generator、
great-jsutils、
great-ngform、
great-zorroutils、
great-vue

安装

``
npm i great-jsutils --save
`

License

请查看 MIT license.

一、数组

`js
import { ArrayUtils } from 'great-jsutils';
`

$3

ArrayUtils.add(array: any, obj: any, {idKey : 'id', pIdKey : 'parentId', childKey : 'children'} = {});

| 参数 | 名称 | 必传 | 参数类型
| ------ | ------ | ------ | ------ |
| array | 被操作的数组 | 是 | Array |
| obj | 被添加的元素 | 是 | any |
| keys | 主键、子属性对应关系 | 否 | string |

示例1：添加元素
`js
function add01() {
let data = [{
'id': 'A', 'type': '1', 'children': [
{
'id': 'A01', 'type': '2', 'children': [
{'id': 'A01-01', 'type': '3'}
]
},
{'id': 'A03', 'type': '3'}
]
}];
let child = {'id': 'A03-01', 'parentId': 'A03'};
let result = ArrayUtils.add(data, child);
console.log(result,JSON.stringify(data));
}
function add02() {
let data = [{
'orgId': 'A', 'type': '1', 'children': [
{'orgId': 'A01', 'type': '2'},
{'orgId': 'A03', 'type': '3'}
]
}];
let child = {'orgId': 'A03-01', 'parentId': 'A03'};
let result = ArrayUtils.add(data, child,{idKey:'orgId'});
console.log(result,JSON.stringify(data));
}
function add03() {
let data = [{
'orgId': 'A', 'type': '1', 'items': [
{'orgId': 'A01', 'type': '2'},
{'orgId': 'A03', 'type': '3'}
]
}];
let child = {'orgId': 'A03-01', 'parentId': 'A03'};
let result = ArrayUtils.add(data, child,{idKey:'orgId',childKey:'items'});
console.log(result,JSON.stringify(data));
}
function add04() {
let data = [{
'id': 'A', 'type': '1', 'children': [
{'id': 'A03', 'type': '3'}
]
}];
let keys = {'id': 'key'};
let child = {'id': 'A03-01', 'parent': {'id': 'A03'}};
let result = ArrayUtils.add(data, child,{'pIdKey':'parent'});
console.log(result,JSON.stringify(data));
}
`

$3

ArrayUtils.remove(array,value,key);

| 参数 | 名称 | 必传 | 参数类型
| ------ | ------ | ------ | ------ |
| array | 被操作的数组 | 是 | Array |
| value | 需要移除的值 | 是 | any |
| keys | 主键、子属性对应关系 | 否 | string |

示例1：移除字符串
`js
//字符串移除，第一个参数是被操作的数组，第二个参数是需要移除的字符串
function testArray(){
let arr=['a','b','c'];
ArrayUtils.remove(arr,'b');
console.log(arr.join(','));//a,c
}
`
示例2：对象移除
`js
function removeRoot01() {
let objArr=[{'id':'1','name':'赵云'},{'id':'2','name':'诸葛亮'}];
ArrayUtils.remove(objArr,{'id':'2'});
console.log(JSON.stringify(objArr));//[{'id':'1','name':'赵云'}]
}
`
示例3：对象移除
`js
function removeRoot02() {
let objArr=[{'userId':'1','name':'赵云'},{'userId':'2','name':'诸葛亮'}];
ArrayUtils.remove(objArr,{'userId':'2'},{idKey:'userId'});
console.log(JSON.stringify(objArr));//[{'userId':'1','name':'赵云'}]
}
`
示例4：子节点移除
`js
function removeChild01() {
let objArr=[{'id':'1','name':'山东省','children':[{'id':'2','name':'济南市'}]}];
ArrayUtils.remove(objArr,{'id':'2'});
console.log(JSON.stringify(objArr));//[{'id':'1','name':'赵云'}]
}
function removeChild02() {
let objArr=[{'id':'1','name':'山东省','items':[{'id':'2','name':'济南市'}]}];
ArrayUtils.remove(objArr,{'id':'2'},{childKey:'items'});
console.log(JSON.stringify(objArr));//[{'id':'1','name':'赵云'}]
}
`

$3

ArrayUtils.update(array,obj,keys);

| 参数 | 名称 | 必传 | 参数类型
| ------ | ------ | ------ | ------ |
| array | 被操作的数组 | 是 | Array |
| obj | 需要更新的对象 | 是 | any |
| keys | 主键、子属性对应关系 | 否 | string |

示例1：更新根节点中的元素
`js
//字符串移除，第一个参数是被操作的数组，第二个参数是需要更新的对象

function updateRoot01() {
let obj={'id':'001','name':'001'};
let array=[{'id':'001','name':'111'}];
let newArray=ArrayUtils.update(array,obj);
console.log(JSON.stringify(array));
}
`

示例2：更新根节点中的元素
`js
import { ArrayUtils } from 'great-jsutils';

function updateRoot02() {
let obj={'userId':'002','name':'222'};
let array=[{'userId':'002','name':'111'}];
let newArray=ArrayUtils.update(array,obj,{idKey:'userId'});
console.log(JSON.stringify(array));
}
`
示例3：更新子节点中的元素
`js
import { ArrayUtils } from 'great-jsutils';
function updateChildren01() {
let obj={'id':'001','name':'001'};
let array=[{'id':'a','name':'111','children':[{'id':'001','name':'222'}]}];
ArrayUtils.update(array,obj);
console.log(JSON.stringify(array));
}
`
示例4：更新子节点中的元素
`js
import { ArrayUtils } from 'great-jsutils';
function updateChildren02() {
let obj={'userId':'001','name':'001'};
let array=[{'userId':'A','name':'A','items':[{'userId':'001','name':'222'}]}];
ArrayUtils.update(array,obj,{idKey:'userId',childKey:'items'});
console.log(JSON.stringify(array));
}
`

**示例5：更新时，增加key
`javascript

function updateChildren03() {
let obj={'userId':'001','name':'001','checked':true};
let array=[{'userId':'A','name':'A','items':[{'userId':'001','name':'222'}]}];
ArrayUtils.update(array,obj,{idKey:'userId',childKey:'items'},function(oldData,newData){
return {'checked':newData['checked']};
});
console.log(JSON.stringify(array));

}
`

$3

ArrayUtils.merge(array,obj,keys);

| 参数 | 名称 | 必传 | 参数类型
| ------ | ------ | ------ | ------ |
| array | 被操作的数组 | 是 | Array |
| obj | 需要更新的对象 | 是 | any |
| keys | 主键、子属性对应关系 | 否 | string |
> 与update类似，这个会增加第二个参数中的新属性

$3

ArrayUtils.updateKey(array,keys,function);

| 参数 | 名称 | 必传 | 参数类型
| ------ | ------ | ------ | ------ |
| array | 被操作的数组 | 是 | Array |
| keys | 原key与新key的对应关系 | 是 | json |
| function | 自定义需要添加的属性 | 否 | string |

示例1：属性替换
`js
import { ArrayUtils } from 'great-jsutils';
//数组中的对象key替换，例如源数据为[{'name':'张三'}]替换为[{'text':'张三'}]
function testArray(){
let datas=[{'name':'张三','sex':'1'}];
let keys={'name':'text'};
let result=ArrayUtils.updateKey(datas,keys);
console.log(result);//{name: '张三', sex: '1'}
}
`

示例2：属性替换，并添加新属性
`js
//数组中对象key替换，例如源数据为[{'name':'张三','age':80}]替换为[{'text':'张三','age':80,'ageGroup':'老年人'}];
//这里是根据某些值特征，增加新的属性
function testArray(){
let datas=[{'name':'张三','sex':'1'}];
let keys={'name':'text'};
let result=ArrayUtils.updateKey(data,keys,function(){
if(data['age']>75){
return {'ageGroup':'老年人'};
}
});
console.log(result);//[{'text':'张三','age':80,'ageGroup':'老年人'}];
}
`

$3

ArrayUtils.get(array,obj,keys);

| 参数 | 名称 | 必传 | 参数类型
| ------ | ------ | ------ | ------ |
| array | 被操作的数组 | 是 | Array |
| obj | 需要更新的对象 | 是 | any |
| keys | 主键、子属性对应关系 | 否 | string |

示例1：根据主键获取
`js
//从树状数组中，根据id的值获取节点数据

function get01() {
let data = [ {'id': 'A01', 'type': '2'},{'id': 'A03', 'type': '3'}];
let item = ArrayUtils.get(data, 'A03');
console.log(item);//{'id': 'A03', 'type': '3'}
}
function get02() {
let data = [ {'userId': 'A01', 'type': '2'},{'userId': 'A03', 'type': '3'}];
let item = ArrayUtils.get(data, 'A03',{idKey:'userId'});
console.log(item);//{'id': 'A03', 'type': '3'}
}
function get03() {
let data = [ {'userId': 'A01', 'type': '2'},{'userId': 'A03', 'type': '3'}];
let item = ArrayUtils.get(data, {'id':'A03'});
console.log(item);//{'id': 'A03', 'type': '3'}
}
function get() {
let data = [{
'id': 'A', 'type': '1', 'children': [
{
'id': 'A01', 'type': '2', 'children': [
{
'id': 'A01-01', 'type': '3', 'children': [
{'id': 'A01-01-01', 'type': '3-01', 'children': [
{'id': 'A01-01-01', 'type': '3-02'}
]}
]
}, {
'id': 'A01-02', 'type': '3', 'children': [
{'id': 'A01-02-01', 'type': '3-01', 'children': [
{'id': 'A01-02-01-01', 'type': '3-02', 'children': [
{'id': 'A01-02-01-01-01', 'type': '3-02'}
]}
]}
]
}
]
},
{'id': 'A03', 'type': '3'}
]
}];
let item = ArrayUtils.get(data, 'A01-02-01-01-01');
console.log(item);//{ id: 'A01-02-01-01-01', type: '3-02' }
}
`
示例2：根据主键获取
`js
//从树状数组中，根据id的值获取节点数据
function getTreeNodeById(){
let arr=[{'id':'A','type':'1','children':[
{'id':'A01','type':'2','children':[
{'id':'A01-01','type':'3','children':[
{'id':'A01-01-01','type':'3-01'}
]},
{'id':'A01-02','type':'3','children':[
{'id':'A01-02-01','type':'3-02'}
]}
]},
{'id':'A03','type':'3'}
]}];
let item=ArrayUtils.get(arr,'A01-02-01','id','children');
console.log(item);//{ id: 'A01-02-01', type: '3-02' }
}
`

$3

ArrayUtils.valid(array);
>是否是个有效的数组对象，有则返回第一个子元素，否则返回false

| 参数 | 名称 | 必传 | 参数类型
| ------ | ------ | ------ | ------ |
| array | 被操作的数组 | 是 | Array |

示例1：是否是个有效的数组对象
`js
//从树状数组中，根据id的值获取节点数据
function valid(){
let arr=[{'id':'A','type':'1','children':[
{'id':'A01','type':'2','children':[
{'id':'A01-01','type':'3','children':[
{'id':'A01-01-01','type':'3-01'}
]},
{'id':'A01-02','type':'3','children':[
{'id':'A01-02-01','type':'3-02'}
]}
]},
{'id':'A03','type':'3'}
]}];
let item=ArrayUtils.valid(arr);
console.log(item);
}
`

$3

示例一：将第二个元素上移到第2个位置
`js
/**
* 将第二个元素上移2个位置
*/
function move01() {
let arr=['a','b','c','d','e'];
//ArrayUtils
let index=2;
let size=2;
ArrayUtils.up(arr,index,{size});
console.log(arr);
}
`

示例二：将第二个元素上移到第2个位置
`js
/**
* 将第二个元素下移到第2个位置
*/
function move01() {
let arr=['a','b','c','d','e'];
//ArrayUtils
let index=2;
let end=2;
ArrayUtils.up(arr,index,{end});
console.log(arr);
}
`

$3

示例一：将第二个元素，移动到第1个位置
`js
/**
* 将第二个元素下移2个位置
*/
function down10() {
let arr=['a', 'b', 'c', 'd'];
console.log('移动前',arr);
let index=2;
let end=1;
ArrayUtils.down(arr,index,{end});
console.log('移动后',arr);
/**
* 移动前 [ 'a', 'b', 'c', 'd' ]
* 移动后 [ 'a', 'c', 'b', 'd' ]
*/
}
`
示例一：将第二个元素下移到第2个位置
`js
/**
* 将第二个元素下移2个位置
*/
function move01() {
let arr=['a','b','c','d','e'];
//ArrayUtils
let index=2;
let size=2;
ArrayUtils.down(arr,index,{size});
console.log(arr);
}
`

示例二：将第二个元素下移到第2个位置
`js
/**
* 将第二个元素下移到第2个位置
*/
function move01() {
let arr=['a','b','c','d','e'];
//ArrayUtils
let index=2;
let end=2;
ArrayUtils.down(arr,index,{end});
console.log(arr);
}
`

$3

将第二个元素移动到底部
`js
function moveBottom() {
let arr = ['a', 'b', 'c', 'd', 'e'];
//ArrayUtils
let index = 2;
ArrayUtils.bottom(arr,index);
console.log(arr);
}
`

移动对象
`js
function moveBottom2() {
let arr = [{name:'1'},{name:'2'},{name:'3'},{name:'4'}];
let index = 2;
ArrayUtils.bottom(arr,index);
console.log(arr);
/**
* 打印结果：
* [ { name: '1' }, { name: '2' }, { name: '4' }, { name: '3' } ]
*/
}
`

$3

将第二个元素移动到顶部
`js
function top() {
let arr = ['a', 'b', 'c', 'd', 'e'];
//ArrayUtils
let index = 2;
ArrayUtils.top(arr,index);
console.log(arr);
}
`

移动对象
`js
function top() {
let arr = [{name:'1'},{name:'2'},{name:'3'},{name:'4'}];
let index = 2;
ArrayUtils.top(arr,index);
console.log(arr);
/**
* 打印结果：
* [ { name: '3' }, { name: '1' }, { name: '2' }, { name: '4' } ]
*/
}
`

$3

`
/**
* 两个元素交换位子
* @param arr：被移动的数组
* @param index1：被移动的元素一
* @param index2：被移动的元素二
* @returns {any}
*/
ArrayUtils.swap(arr, index1, index2);
`
示例：将第一个和第三个进行交换
`js
function swap(){
let arr = [{name:'1'},{name:'2'},{name:'3'},{name:'4'}];
ArrayUtils.swap(arr,1,3);
console.log(arr);
/**
* 打印结果：
* [ { name: '1' }, { name: '4' }, { name: '3' }, { name: '2' } ]
*/
}
`

二、 加密

示例1：md5
`js
//字符串的加密
import {JsUtilsApi } from 'great-jsutils';
function md5() {
JsUtilsApi.md5('admin123456')
}
`
示例2：Base64
`js
//字符串的加密、解密
import {Base64 } from 'great-jsutils';
function base64() {
console.log('base64：',Base64.encode('123'));
console.log('base64：',Base64.decode('MTIz'));
}
`
示例3：md5File，读取文件内容生成md5值
`js
//字符串的加密、解密
import {JsUtilsApi } from 'great-jsutils';
function md5File() {
JsUtilsApi.md5File(file).then(
(md5)=>{ // 成功回调
this.file.fileMd5 = md5;
}
);
}
`

三、 时间工具类

* 常量
`js
FORMAT_FULL = 'yyyy-MM-dd hh:mm:ss';
FORMAT_FULL_IE = 'yyyy/MM/dd hh:mm:ss';
FORMAT_FULL_CN = 'yyyy年MM月dd日 hh时mm分ss秒';
FORMAT_YMD = 'yyyy-MM-dd';
FORMAT_YMD_IE = 'yyyy/MM/dd';
FORMAT_YMD_CN = 'yyyy年MM月dd日';
FORMAT_HMS = 'hh:mm:ss';
FORMAT_HMS_CN = 'hh时mm分ss秒';
`
`js
import { TimeUtils } from 'great-jsutils';
`
判断是否是日期类型
`js
TimeUtils.isDate(args);
`
获取某天开始、结束时间
TimeUtils.getDayTime(n:number);

| 参数 | 名称 | 必传 | 参数类型
| ------ | ------ | ------ | ------ |
| n | 获取n天前时间，不传则为当天时间 | 否 | number |

>根据传入的数字，获取n天前的开始结束时间，正数则往后推，负数则往前推
`js
import {TimeUtils } from 'great-jsutils';
function testTime(){
console.log('当天开始、结束时间',TimeUtils.getDayTime());
//当天开始、结束时间 { start: '2018-08-31 00:00:00', end: '2018-08-31 24:59:59' }
console.log('获取昨天时间：',TimeUtils.getDayTime(-1));
console.log('获取前天时间：',TimeUtils.getDayTime(-2));
console.log('获取明天时间：',TimeUtils.getDayTime(1));
console.log('获取后天时间：',TimeUtils.getDayTime(1));
}
`
获取某周开始、结束时间
`js
TimeUtils.getWeekTime(n:number);
`
根据传入的数字，获取n周前的开始结束时间，正数则往后推，负数则往前推
`js
import {TimeUtils } from 'great-jsutils';
function testTime(){
console.log('本周开始、结束时间',TimeUtils.getWeekTime());
//本周开始、结束时间 { start: '2018-09-17 00:00:00', end: '2018-09-23 24:59:59' }
console.log('上周开始、结束时间',TimeUtils.getWeekTime(-1));
//上周开始、结束时间 { start: '2018-09-10 00:00:00', end: '2018-09-16 24:59:59' }
}
`
获取某月开始、结束时间
`js
TimeUtils.getMonthTime(integer);
`
根据传入的数字，获取n月前的开始结束时间，正数则往后推，负数则往前推
`js
import {TimeUtils } from 'great-jsutils';
function testTime(){
console.log('本月开始、结束时间',TimeUtils.getMonthTime());
//本月开始、结束时间 { start: '2018-09-01 00:00:00', end: '2018-09-30 24:59:59' }
console.log('上月开始、结束时间',TimeUtils.getMonthTime(-1));
//上月开始、结束时间 { start: '2018-08-01 00:00:00', end: '2018-08-31 24:59:59' }
}
`
获取某季度开始、结束时间
`js
TimeUtils.getQuarterTime(n:number);
`
根据传入的数字，获取n月前的开始结束时间，正数则往后推，负数则往前推
`js
import {TimeUtils } from 'great-jsutils';
function testTime(){
console.log('本季度开始结束时间',TimeUtils.getQuarterTime());
//本季度开始结束时间 { start: '2018-07-01 00:00:00', end: '2018-09-30 24:59:59' }
console.log('上季度开始结束时间',TimeUtils.getQuarterTime(-1));
}
`
获取某年开始、结束时间
`js
TimeUtils.getYearTime(n:number);
`
根据传入的数字，获取n年前的开始结束时间，正数则往后推，负数则往前推
`js
import {TimeUtils } from 'great-jsutils';
function testTime(){
console.log('本年开始结束时间',TimeUtils.getYearTime());
//本年开始结束时间 { start: '2018-01-01 00:00:00', end: '2018-12-31 24:59:59' }
console.log('上年开始结束时间',TimeUtils.getYearTime(-1));
}
`
获取N天内的开始、结束时间
>getWinthInDayTime

| 参数 | 名称 | 必传 | 参数类型
| ------ | ------ | ------ | ------ |
| num | 指定天数 | 否 | number |
`
function getWinthInDayTime(){
let num1 = -29;// 向前推获取30天内的时间
let time1 = TimeUtils.getWinthInDayTime(num1);
console.log(\n${num1}天内的开始、结束时间：\n, time1);
/*
-29天内的开始、结束时间：
{ start: '2019-03-23 00:00:00', end: '2019-04-21 24:59:59' }
*/

let num2 = 29; // 向后推，获取30天内的时间
let time2 = TimeUtils.getWinthInDayTime(num2);
console.log(\n${num2}天内的开始、结束时间：\n, time2);
/*
29天内的开始、结束时间：
{ start: '2019-04-21 00:00:00', end: '2019-05-20 24:59:59' }
*/
}
`

格式化时间
TimeUtils.format(date:Date,format:string)

| 参数 | 名称 | 必传 | 参数类型
| ------ | ------ | ------ | ------ |
| date | 需要格式化的时间 | 否 | Date |
| format | 需要转换的格式 | 否 | string |
`js
import {TimeUtils } from 'great-jsutils';
function testTime(){
console.log('格式化时间（默认的格式化类型）：',TimeUtils.format());//当前时间
//格式化时间（默认的格式化类型）： 2018-09-23 17:18:19
console.log('格式化时间（默认的格式化类型）：',TimeUtils.format(new Date()));
//格式化时间（默认的格式化类型）： 2018-09-23 17:18:19
console.log('格式化时间（根据传入的参数格式）：',TimeUtils.format(new Date(),'yyyy-MM-dd hh时'));
//格式化时间（根据传入的参数格式）： 2018-09-23 17时
console.log('格式化时间（API提供的类型）：',TimeUtils.format(new Date(),TimeUtils.FORMAT_YMD));
//格式化时间（API提供的类型）： 2018-09-23
}
`
生成一个随机时间
`javascript
/ 获取一个随机时间 /
function random() {
let date = TimeUtils.random();
let dateStr = TimeUtils.format(date);
console.log(dateStr);
}
random();
`
根据当前时间，输出早上好、上午好……
`javascript
function sayHello() {
let hello = TimeUtils.sayHello();
console.log(hello);
}
sayHello();
`
字符串转时间
`js
function parse(){
let date = TimeUtils.parse('2019年11年9日 11点11分11秒');
if(date){
console.log('parse：',TimeUtils.format(date));
//parse： 2019-11-09 11:11:11
}else{
console.log('null');
}
}
`
获取某月最后一天的时间
`js
TimeUtils.getMonthEndDateByDateStr(dateStr);
`

四、 字符串

`js
import { StringUtils } from 'great-jsutils';
`
示例1：删除全部空格
`js
import {StringUtils } from 'great-jsutils';
StringUtils.trim(str);
`
示例2：删除前后空格
`js
import {StringUtils } from 'great-jsutils';
StringUtils.trimAround(str);
`

五、 json

`js
import { JsonUtils } from 'great-jsutils';
`
示例1：判断是否为json
`js
import {JsonUtils } from 'great-jsutils';
function json(){
let str1='123';
console.log(str1,JsonUtils.isJsonString(str1));
let str2="{'name':'1'}";
console.log(str2,JsonUtils.isJsonString(str2));
let str3="{name:'1'}";
console.log(str3,JsonUtils.isJsonString(str3));
let str4="{'name':'xt'}";
console.log(str4,JsonUtils.isJsonString(str4));
}
`
示例2：字符串转json
`js
import {JsonUtils } from 'great-jsutils';
let str4="{'name':'xt'}";
JsonUtils.toJson(str4);
`
示例3：syntaxHighlight
`js
import {JsonUtils } from 'great-jsutils';
let str4="{'name':'xt'}";
JsonUtils.syntaxHighlight(str4);
`
`js
/**
* 是否是jsonStr
*/
JsonUtils.isJsonString
`
`js
/**
* 转成jsonStr
*/
JsonUtils.toJsonStr
`
`js
/**
* 转成json对象
*/
JsonUtils.toJson
`
`js
/**
* json转前端实体类
*/
JsonUtils.toClassModel(json,{notes:false})
`

六、 正则RegexpUtils

`js
import {RegexpUtils} from 'great-jsutils';
`

$3

`js
/**
* 数字验证
* 验证数字是否是规定的范围格式
* 例如：是否为指定的小数位数、是否大于某个数字、是否小于某个数字、是否在某个数据范围之间
*/
RegexpUtils.isNumber(str,{
max:'最大值',
min:'最小值',
maxScale:'最大小数位数',
minScale:'至少小数位数',
scale:'小数位数'
});
`
场景示例
`js
let numStr = "123.222";

// 场景一：检查输入的是否为数字
let result1 = RegexpUtils.isNumber(numStr);
console.log(numStr+'是否为数字：', result1);
//打印结果： 123.222是否为数字：true

// 场景二：检查输入的小数是否为三位
let result2 = RegexpUtils.isNumber(numStr,{scale:3});
console.log(numStr+'小数位数：==3',result2);
//打印结果： 123.222小数位数：==3 true

// 场景三：检查小数位数是否多于三位
let result3 = RegexpUtils.isNumber(numStr,{minScale:3});
console.log(numStr+'小数位数：>=3',result3);
//打印结果： 123.222小数位数：>=3 true

// 场景四：检查小数位数的个数是否多于4个、少于5个
let result4 = RegexpUtils.isNumber(numStr,{minScale:4, maxScale:5});
console.log(numStr+'小数位数：4-5',result4);
//打印结果： 123.222小数位数：4-5 false

// 场景五：检查小数位数是否多于5个
let result5 = RegexpUtils.isNumber(numStr,{maxScale:5});
console.log(numStr+'小数位数：<5',result5);
//打印结果： 123.222小数位数：<5 true

// 场景六：检查数字是否大于5
let result6 = RegexpUtils.isNumber(numStr,{min:5});
console.log(numStr+'>5：',result6);
//打印结果： 123.222>5： true

// 场景七：检查数字是否大于5，并且小于200
let result7 = RegexpUtils.isNumber(numStr,{min:5, max:200});
console.log(numStr+'>5 && '+numStr+'<200：',result7);
//打印结果：123.222>5 && 123.222<200： true

// 场景八：检查数字是否小于555
let result8 = RegexpUtils.isNumber(numStr,{max:555});
console.log(numStr+'<555：',result8);
//打印结果： 123.222<555： true

let result9 = RegexpUtils.isNumber(numStr,{});
console.log(numStr+'｛｝：',result9);
//打印结果： 123.222｛｝： true
`

$3

`js
/**
* 字节个数验证
* 由于数据库中定义的字段长度为字节长度，
* 所以中英文混合输入时，为了避免避免输入超长，
* 需要检查输入数字的字节长度
*/
RegexpUtils.byteLength(str,{
maxLength:'最大长度',
minLength:'最小长度',
});
`
场景示例
`js
let str = '富强prosperity/1/2/3';

let result = RegexpUtils.byteLength(str,{maxLength: 10});
console.log(${str}字节数<10：,result);
// 打印结果：富强prosperity/1/2/3字节数<10： false

let result2 = RegexpUtils.byteLength(str,{minLength: 10});
console.log(${str}字节数>10：,result2);
// 打印结果：富强prosperity/1/2/3字节数>10： true

let result3 = RegexpUtils.byteLength(str,{minLength: 10, maxLength: 12});
console.log(${str}字节数>10&&<12：,result3);
// 打印结果：富强prosperity/1/2/3字节数>10&&<12： false

let result4 = RegexpUtils.byteLength(str,{minLength: 10, maxLength: 20});
console.log(${str}字节数>10&&<20：,result4);
// 打印结果：富强prosperity/1/2/3字节数>10&&<20： true
`

$3

`js
let str = '富强prosperity 、民主democracy/1/2/3';
console.log(RegexpUtils.matchChinese(str));
// 打印结果：[ '富', '强', '、', '民', '主' ]
`

$3

`js
let str = 'zhaoqingkaitt@163.com';

// 是否为邮箱
console.log('邮箱：', RegexpUtils.isEmail(str));
// 打印结果：邮箱： true

// 是否为中文
console.log('中文：', RegexpUtils.isChinese(str));
// 打印结果： 中文： false

// 是否为身份证号
console.log('身份证号：', RegexpUtils.isIdentityCard(str));
// 打印结果： 身份证号： false

// 是否为MAC地址
console.log('MAC地址：', RegexpUtils.isMac(str));
// 打印结果： MAC地址： false

// 是否为http地址
console.log('HTTP地址：', RegexpUtils.isUrl(str));
// 打印结果： HTTP地址： false

// 是否为整数
console.log('整数：', RegexpUtils.isInteger(str));
// 打印结果： 整数： false

// 纳税人识别号格式
console.log('整数：', RegexpUtils.isTaxpayerIdentificationNumber(str));
// 打印结果： 整数： false
`

$3

`js
// 去除空格
RegexpUtils.trim(str);
// 去除前后空格
RegexpUtils.trimAround(str);
// 去除前空格
RegexpUtils.trimLeft(str);
// 去除后空格
RegexpUtils.trimRight(str);
`

$3

`js
let str= 'hello word';
//首字母大写
RegexpUtils.upperCaseFirst(str);
// 打印 HelloWord

// 首字母转小写
RegexpUtils.lowerCaseFirst(str);

// 小驼峰
RegexpUtils.lowerCamelCase(str);
// 打印 helloWord
`

$3

`js
// 是否为身份证号
RegexpUtils.isIdentityCard(idCard);
// 获取出生日期
RegexpUtils.getBirthdayStrByIdCard(idCard);
// 获取年龄
RegexpUtils.getAgeByIdCard(idCard);
// 获取性别
RegexpUtils.getSexByIdCard(idCard);
// 获取性别、年龄、出生日期
RegexpUtils.getPersonInfoByIdCard(idCard);
`

七、 对象操作

`js
import {ObjectUtils} from 'great-jsutils';

`


`js
/**
* 清除对象中的空值
*/
function obj01(){
let obj={a:null,b:'',c:2,d:'aa'};
ObjectUtils.filter(obj);
console.log('obj\t',obj); //obj { c: 2, d: 'aa' }
}
`

`js
/**
* 清除对象中的空值。
* 并指定其他需要强制移除的key
*/
function obj02(){
let obj={a:null,b:'',c:2,d:'aa'};
let removeKeys=['d'];
ObjectUtils.filter(obj,{removeKeys});
console.log('obj\t',obj);//obj { c: 2}
}

`


`js
/**
* 根据指定函数确定需要移除的key
* 下面示例将删除值长度为2 或 值为b的key
*/
function obj03(){
let obj={a:'dd',b:'b',c:'ddd',d:'aa'};
function fun(v){
return v=='b' || v.length==2;
}
ObjectUtils.filter(obj,{fun});
console.log('obj\t',obj);// { c: 'ddd' }
}

`

八、 number

$3

>默认返回一个小于10的整数，可以指定返回的最大值、最小值，以及返回的个数
`js
import { NumberUtils } from 'great-jsutils';
`
示例1：随机生成一个小于10的整数
`js
NumberUtils.randomInt();
`
示例2：随机生成一个小于100的整数
`js
NumberUtils.randomInt({max:100});
`
示例3：随机生成四个大于等于10，小于100的整数
`js
NumberUtils.randomInt({max:100,min:10,number:4})
`

$3

>默认返回一个小于10的浮点数，可以指定返回的最大值、最小值、小数位数，以及返回的个数

示例1：随机生成一个小于10的两位小数的浮点数
`js
NumberUtils.randomInt();
`
示例2：随机生成一个小于100的两位小数的浮点数
`js
NumberUtils.randomInt({max:100});
`
示例3：随机生成四个大于等于10，小于100的两位小数的浮点数
`js
NumberUtils.randomInt({max:100,min:10,number:4})
`
示例4：随机生成四个大于等于10，小于100的三位小数的浮点数
`js
NumberUtils.randomInt({max:100,min:10,number:4,scale3})
`

$3

`js
console.log(NumberUtils.changeToChinese(1200));
`

$3

`js
console.log(NumberUtils.numberToChinese(12));
`

$3

`js
console.log(NumberUtils.sum(1.1,1.3));// 2.4
console.log(1.1+1.3);//2.4000000000000004
`
* 一组数字相加
`js
console.log(NumberUtils.adds(1.001,1.3,1.4,2.33,12.3103));//18.3413
`

$3

`js
console.log(NumberUtils.sub(1.1,1.2));
`

$3

`js
console.log(NumberUtils.mul(1.1,1.2));
`

$3

`js
console.log(NumberUtils.div(1.1,1.2));
`

九、 DataTypeUtils

`js
import {DataTypeUtils} from 'great-jsutils';
`

`js
/**
* 获取对象类型
*/
DataTypeUtils.getDataType(o);
`
`js
/**
* 是否为空对象
*/
DataTypeUtils.isNull(o);
`
`js
/**
* 是否为undefined
*/
DataTypeUtils.isUndefined(o);
`
`js
/**
* 是否为对象
*/
DataTypeUtils.isObject(o);
`
`js
/**
* 是否为数组
*/
DataTypeUtils.isArray(o);
`
`js
/**
* 是否为字符串
*/
DataTypeUtils.isString(o);
`
`js
/**
* 是否为数字
*/
DataTypeUtils.isNumber(o);
`
`js
/**
* 是否为布尔
*/
DataTypeUtils.isBoolean(o);
`
`js
/**
* 是否为函数
*/
DataTypeUtils.isFunction(o);
`
`js
/**
* 是否为日期
*/
DataTypeUtils.isDate(o);
`
`js
/**
* 是否为正则
*/
DataTypeUtils.isRegExp(o);
`
`js
/**
* 是否为错误对象
*/
DataTypeUtils.isError(o);
`
`js
/**
* 是否为Symbol对象
*/
DataTypeUtils.isSymbol(o);
`
`js
/**
* 是否为promise对象
*/
DataTypeUtils.isPromise(o);
`
`js
/**
* 是否为set对象
*/
DataTypeUtils.isSet(o);
`
`js
/**
* isFalse
*/
DataTypeUtils.isFalse(o);
`
`js
/**
* isTrue
*/
DataTypeUtils.isTrue(o);
`
`js
/**
* 是否为空值：符合空值的条件（空字符串、null、undefined、数组长度为0、对象中没有key）
*/
DataTypeUtils.isNullValue(o);
`

十、 数据生成器：DataGeneratorUtils

`js
import {DataGeneratorUtils} from 'great-jsutils';
`

$3

1.1、 生成一个姓名
`js
let personName = DataGeneratorUtils.personName();
`
1.2、 生成多个姓名
`js
let personNames = DataGeneratorUtils.personName({size:8});
`

$3

*2.1、 生成一个手机号
`js
let mobile = DataGeneratorUtils.mobile();
`
*2.2、 生成多个手机号
`js
let mobiles = DataGeneratorUtils.mobile({size:8});
`

$3

| 参数 | 名称 | 必传 | 参数类型
| ------ | ------ | ------ | ------ |
| size | 个数 | 否 | number |
| upperCase | 转大写 | 否 | boolean |
| length | 长度 | 否 | number |
| prefix | 前缀 | 否 | string |
| suffix | 后缀 | 否 | string |

*3.1、 生成一个字母，默认为一个且为大写
`js
let letter = DataGeneratorUtils.letter();
console.log(letter);//B
`
*3.2、 生成多个字母，通过length指定长度为2
`js
let letters = DataGeneratorUtils.letter({length:2});
console.log(letters);//BD
`
*3.3、 生成多组字母
`js
let letters = DataGeneratorUtils.letter({size:2});
console.log(letters);//['D', 'W']
`
*3.4、 生成多组字母，且长度为4
`js
let letters = DataGeneratorUtils.letter({size:2, length:4});
console.log(letters);//['DACK', 'BKJA']
`
*3.5、 生成小写字母
`js
let letters = DataGeneratorUtils.letter({length:4, upperCase:false});
console.log(letters);//aabc
`

$3

`js
let personName = DataGeneratorUtils.getElementByArray(array);
`

$3

`js
let email = DataGeneratorUtils.email({size:2});
`

$3

5.1、随机生成整数、小数
>可以指定最大数、最小数、生成的个数等
`js
import {NumberUtils} from 'great-jsutils';
`
5.2、随机生成时间
>可以格式化时间、获取一个月内、上下个月、上下个周内等
`js
import {TimeUtils} from 'great-jsutils';
`

十一、 CommonUtils

$3

是否为ios系统

$3

是否为pc端

$3

浏览器类型

$3

随机生成一个16进制颜色值

$3

`
import {CommonUtils} from 'great-jsutils';
CommonUtils.uuid();
`
生成一个uuid

十二、ValueUtils

`js
import {ValueUtils} from 'great-jsutils';
`

$3

`js
let a = [],a1={},a2=null,a3,a4=' ';
console.log('ValueUtils.isNullValue(',a,'):', ValueUtils.isNullValue(a));// 打印：true
console.log('ValueUtils.isNullValue(',a1,'):', ValueUtils.isNullValue(a1));// 打印：true
console.log('ValueUtils.isNullValue(',a2,'):', ValueUtils.isNullValue(a2));// 打印：true
console.log('ValueUtils.isNullValue(',a3,'):', ValueUtils.isNullValue(a3));// 打印：true
console.log('ValueUtils.isNullValue(',a4,'):', ValueUtils.isNullValue(a4));// 打印：false
console.log('ValueUtils.isNullValue(',a4,',true):', ValueUtils.isNullValue(a4, true));// 打印：true
`

$3

`js
let b="123", b1="a23", b2=23;
console.log('ValueUtils.isNumberValue(',b,'):', ValueUtils.isNumberValue(b)); // 打印：true
console.log('ValueUtils.isNumberValue(',b1,'):', ValueUtils.isNumberValue(b1));// 打印：false
console.log('ValueUtils.isNumberValue(',b2,'):', ValueUtils.isNumberValue(b2));// 打印：true
`

$3

`js
let c = [], c1, c2={}, c3=[1], c4=[{name:'张三'}];
console.log('ValueUtils.isEmptyArray(',c,'):', ValueUtils.isEmptyArray(c));// 打印：true
console.log('ValueUtils.isEmptyArray(',c1,'):', ValueUtils.isEmptyArray(c1));// 打印：false
console.log('ValueUtils.isEmptyArray(',c2,'):', ValueUtils.isEmptyArray(c2));// 打印：false
console.log('ValueUtils.isEmptyArray(',c3,'):', ValueUtils.isEmptyArray(c3));// 打印：false
console.log('ValueUtils.isEmptyArray(',c4,'):', ValueUtils.isEmptyArray(c4));// 打印：false
`

$3

十三 BrowserUtils

`js
// 获取浏览器版本信息
BrowserUtils.getBrowser();
`

LoadjsUtils加载js文件

`
LoadjsUtils.dynamicLoads([
./assets/ueditor/ueditor.config.js,
./assets/ueditor/ueditor.all.js,
./assets/ueditor/lang/zh-cn/zh-cn.js
]).then(() => {
});
`

HttpUtils

`js
HttpUtils.getUrlParam(name)
`
`js
HttpUtils.getUrlParams(url)
`
`js
HttpUtils.delParamsUrl(url, name)
`

SessionStroage

bug修复

2019.0817

| key | value |
| ------ | ------ |
| 版本 | 1.2.0 |
| 升级说明 | 数组移除方法，子节点移除时优化 |

2019.0829

| key | value |
| ------ | ------ |
| 版本 | 1.2.1 |
| 升级说明 | 根据json转model类 |
`
JsonUtils.toClassModel(jsonStr);
`
2019.0905

| key | value |
| ------ | ------ |
| 版本 | 1.2.2 |
| 升级说明 | 增加BankCardUtils、AjaxUtils |
`
JsonUtils.toClassModel(jsonStr);
`
2019.0929

| key | value |
| ------ | ------ |
| 版本 | 1.2.4 |
| 升级说明 | 小数正则 |
`
RegexpUtils.isDecimal(num);
`
2019.1001

| key | value |
| ------ | ------ |
| 版本 | 1.2.5 |
| 升级说明 | 代码格式化 |
`
HighlightUtils.syntaxHighlight(num);
HighlightUtils.formatFunction(fn,fnName);
HighlightUtils.formatText(num);
HighlightUtils.formatHtml(num);
HighlightUtils.escapeHtml(num);
`
2019.1004
`
//深拷贝
ObjectUtils.deepClone
`
2019.1008
`
//深拷贝
ObjectUtils.clone
//数据类型
DataTypeUtils.is……
`

2019.1013

| key | value |
| ------ | ------ |
| 版本 | 1.2.6 |
| 升级说明 | json转实体 |
`
toClassModel(json,{notes:false})
`

2019.1026

| key | value |
| ------ | ------ |
| 版本 | 1.3.1 |
| 升级说明 | 生成数字优化 |
`
toClassModel(json,{notes:false})
``

2020.0801

| key | value |
| ------ | ------ |
| 版本 | 1.3.6 |
| 升级说明 | 空值判断 |

___感谢你的支持，我将持续优化我的服务，希望为你提供更大的帮助！___
!感谢你的支持
___感谢你的支持，我将持续优化我的免费的服务，希望为你提供更大的帮助！___
Show more