great-jsutils
TypeScript icon, indicating that this package has built-in type declarations

1.4.4 • Public • Published

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

友情链接

great-generatorgreat-jsutilsgreat-ngformgreat-zorroutilsgreat-vue

安装

npm i great-jsutils --save

License

请查看 MIT license.

一、数组

import { ArrayUtils } from 'great-jsutils';

添加元素

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

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

示例1:添加元素

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));
}

移除元素

ArrayUtils.remove(array,value,key);

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

示例1:移除字符串

//字符串移除,第一个参数是被操作的数组,第二个参数是需要移除的字符串
function testArray(){
    let arr=['a','b','c'];
    ArrayUtils.remove(arr,'b');
    console.log(arr.join(','));//a,c
}

示例2:对象移除

function removeRoot01() {
    let objArr=[{'id':'1','name':'赵云'},{'id':'2','name':'诸葛亮'}];
    ArrayUtils.remove(objArr,{'id':'2'});
    console.log(JSON.stringify(objArr));//[{'id':'1','name':'赵云'}]
}

示例3:对象移除

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:子节点移除

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':'赵云'}]
}

更新元素

ArrayUtils.update(array,obj,keys);

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

示例1:更新根节点中的元素

//字符串移除,第一个参数是被操作的数组,第二个参数是需要更新的对象

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:更新根节点中的元素

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:更新子节点中的元素

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:更新子节点中的元素

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

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));

}

合并元素

ArrayUtils.merge(array,obj,keys);

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

与update类似,这个会增加第二个参数中的新属性

属性替换

ArrayUtils.updateKey(array,keys,function);

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

示例1:属性替换

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:属性替换,并添加新属性

//数组中对象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':'老年人'}];
}

获取树节点

ArrayUtils.get(array,obj,keys);

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

示例1:根据主键获取

//从树状数组中,根据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:根据主键获取

//从树状数组中,根据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' }
}

是否是个有效的数组对象

ArrayUtils.valid(array);

是否是个有效的数组对象,有则返回第一个子元素,否则返回false

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

示例1:是否是个有效的数组对象

//从树状数组中,根据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);
}

节点向上移动操作

示例一:将第二个元素上移到第2个位置

/**
* 将第二个元素上移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个位置

/**
* 将第二个元素下移到第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);
}

节点向下移动操作

示例一:将第二个元素,移动到第1个位置

/**
* 将第二个元素下移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个位置

/**
* 将第二个元素下移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个位置

/**
* 将第二个元素下移到第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);
}

将指定索引的节点移到底部

将第二个元素移动到底部

function moveBottom() {
    let arr = ['a', 'b', 'c', 'd', 'e'];
    //ArrayUtils
    let index = 2;
    ArrayUtils.bottom(arr,index);
    console.log(arr);
}

移动对象

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' } ]
     */
}

将指定索引的节点移到顶部

将第二个元素移动到顶部

function top() {
    let arr = ['a', 'b', 'c', 'd', 'e'];
    //ArrayUtils
    let index = 2;
    ArrayUtils.top(arr,index);
    console.log(arr);
}

移动对象

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' } ]
     */
}

节点位置交换

/**
 * 两个元素交换位子
 * @param arr:被移动的数组
 * @param index1:被移动的元素一
 * @param index2:被移动的元素二
 * @returns {any}
 */
ArrayUtils.swap(arr, index1, index2);

示例:将第一个和第三个进行交换

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

//字符串的加密
import {JsUtilsApi } from 'great-jsutils';
function md5() {
  JsUtilsApi.md5('admin123456')
}

示例2:Base64

//字符串的加密、解密
import {Base64 } from 'great-jsutils';
function base64() {
console.log('base64:',Base64.encode('123'));
console.log('base64:',Base64.decode('MTIz'));
}

示例3:md5File,读取文件内容生成md5值

//字符串的加密、解密
import {JsUtilsApi } from 'great-jsutils';
function md5File() {
    JsUtilsApi.md5File(file).then(
      (md5)=>{ // 成功回调
        this.file.fileMd5 = md5;
      }
    );
}

三、 时间工具类

  • 常量
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秒';
import { TimeUtils } from 'great-jsutils';

判断是否是日期类型

TimeUtils.isDate(args);

获取某天开始、结束时间 TimeUtils.getDayTime(n:number);

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

根据传入的数字,获取n天前的开始结束时间,正数则往后推,负数则往前推

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));
}

获取某周开始、结束时间

TimeUtils.getWeekTime(n:number); 

根据传入的数字,获取n周前的开始结束时间,正数则往后推,负数则往前推

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' }
}

获取某月开始、结束时间

 TimeUtils.getMonthTime(integer);

根据传入的数字,获取n月前的开始结束时间,正数则往后推,负数则往前推

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' }
}

获取某季度开始、结束时间

TimeUtils.getQuarterTime(n:number); 

根据传入的数字,获取n月前的开始结束时间,正数则往后推,负数则往前推

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));
}

获取某年开始、结束时间

TimeUtils.getYearTime(n:number); 

根据传入的数字,获取n年前的开始结束时间,正数则往后推,负数则往前推

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
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
}

生成一个随机时间

/* 获取一个随机时间 */
function random() {
    let date =  TimeUtils.random();
    let dateStr = TimeUtils.format(date);
    console.log(dateStr);
}
random();

根据当前时间,输出早上好、上午好……

function sayHello() {
    let hello =  TimeUtils.sayHello();
    console.log(hello);
}
sayHello();

字符串转时间

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');
    }
}

获取某月最后一天的时间

TimeUtils.getMonthEndDateByDateStr(dateStr);

四、 字符串

import { StringUtils } from 'great-jsutils';

示例1:删除全部空格

import {StringUtils } from 'great-jsutils';
StringUtils.trim(str);

示例2:删除前后空格

import {StringUtils } from 'great-jsutils';
StringUtils.trimAround(str);

五、 json

import { JsonUtils } from 'great-jsutils';

示例1:判断是否为json

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

import {JsonUtils } from 'great-jsutils';
let str4="{'name':'xt'}";
JsonUtils.toJson(str4);

示例3:syntaxHighlight

import {JsonUtils } from 'great-jsutils';
let str4="{'name':'xt'}";
JsonUtils.syntaxHighlight(str4);
/**
 * 是否是jsonStr
 */
JsonUtils.isJsonString
/**
 * 转成jsonStr
 */
JsonUtils.toJsonStr
/**
 * 转成json对象
 */
JsonUtils.toJson
/**
 * json转前端实体类
 */
JsonUtils.toClassModel(json,{notes:false})

六、 正则RegexpUtils

import {RegexpUtils} from 'great-jsutils';

1、数字验证

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

场景示例

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

2、字节个数验证

/**
 * 字节个数验证
 * 由于数据库中定义的字段长度为字节长度,
 * 所以中英文混合输入时,为了避免避免输入超长,
 * 需要检查输入数字的字节长度
 */
RegexpUtils.byteLength(str,{
    maxLength:'最大长度',
    minLength:'最小长度',
});

场景示例

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、匹配中文信息

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

4、其他操作

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

5、去除空格

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

6、单词转变量

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

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

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

7、身份证呈

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

七、 对象操作

import {ObjectUtils} from 'great-jsutils';
/**
 * 清除对象中的空值
 */
function obj01(){
    let obj={a:null,b:'',c:2,d:'aa'};
    ObjectUtils.filter(obj);
    console.log('obj\t',obj); //obj   { c: 2, d: 'aa' }
}
/**
 * 清除对象中的空值。
 * 并指定其他需要强制移除的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}
}
/**
 * 根据指定函数确定需要移除的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

1.1随机生成一组整数

默认返回一个小于10的整数,可以指定返回的最大值、最小值,以及返回的个数

import { NumberUtils } from 'great-jsutils';

示例1:随机生成一个小于10的整数

NumberUtils.randomInt();

示例2:随机生成一个小于100的整数

NumberUtils.randomInt({max:100});

示例3:随机生成四个大于等于10,小于100的整数

NumberUtils.randomInt({max:100,min:10,number:4})

1.2随机生成一组浮点数

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

示例1:随机生成一个小于10的两位小数的浮点数

NumberUtils.randomInt();

示例2:随机生成一个小于100的两位小数的浮点数

NumberUtils.randomInt({max:100});

示例3:随机生成四个大于等于10,小于100的两位小数的浮点数

NumberUtils.randomInt({max:100,min:10,number:4})

示例4:随机生成四个大于等于10,小于100的三位小数的浮点数

NumberUtils.randomInt({max:100,min:10,number:4,scale3})

1.3 将数字转人民币大写

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

1.4 将阿拉伯数字转中文表示方式

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

1.5 数字相加

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

1.6 数字相减

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

1.7 数字相乘

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

1.8 数字相除

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

九、 DataTypeUtils

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

十、 数据生成器:DataGeneratorUtils

import {DataGeneratorUtils} from 'great-jsutils';

1. 生成姓名

1.1、 生成一个姓名

let personName = DataGeneratorUtils.personName();

1.2、 生成多个姓名

let personNames = DataGeneratorUtils.personName({size:8});

2. 生成一个手机号

*2.1、 生成一个手机号

let mobile = DataGeneratorUtils.mobile();

*2.2、 生成多个手机号

let mobiles = DataGeneratorUtils.mobile({size:8});

3. 生成字母

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

*3.1、 生成一个字母,默认为一个且为大写

let letter = DataGeneratorUtils.letter();
console.log(letter);//B

*3.2、 生成多个字母,通过length指定长度为2

let letters = DataGeneratorUtils.letter({length:2});
console.log(letters);//BD

*3.3、 生成多组字母

let letters = DataGeneratorUtils.letter({size:2});
console.log(letters);//['D', 'W']

*3.4、 生成多组字母,且长度为4

let letters = DataGeneratorUtils.letter({size:2, length:4});
console.log(letters);//['DACK', 'BKJA']

*3.5、 生成小写字母

let letters = DataGeneratorUtils.letter({length:4, upperCase:false});
console.log(letters);//aabc

4. 从数组中随机获取一个元素

let personName = DataGeneratorUtils.getElementByArray(array);

5. 生成邮箱

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

6. 其他

5.1、随机生成整数、小数

可以指定最大数、最小数、生成的个数等

import {NumberUtils} from 'great-jsutils';

5.2、随机生成时间

可以格式化时间、获取一个月内、上下个月、上下个周内等

import {TimeUtils} from 'great-jsutils';

十一、 CommonUtils

1.1、 CommonUtils.isIos();

是否为ios系统

1.2、CommonUtils.isPC();

是否为pc端

1.3、 CommonUtils.browserType();

浏览器类型

1.4、CommonUtils.getRandomColor();

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

1.5、CommonUtils.uuid();

import {CommonUtils} from 'great-jsutils';
CommonUtils.uuid();

生成一个uuid

十二、ValueUtils

import {ValueUtils} from 'great-jsutils';

1.1、空值校验(isNullValue)

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

1.2、是否为数字(isNumberValue)

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

1.3、是否为空数组(isEmptyArray)

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

1.4、是否为非空数组(isNotEmptyArray)

十三 BrowserUtils

// 获取浏览器版本信息
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

HttpUtils.getUrlParam(name)
HttpUtils.getUrlParams(url)
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
升级说明 空值判断

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

Package Sidebar

Install

npm i great-jsutils

Weekly Downloads

33

Version

1.4.4

License

MIT

Unpacked Size

314 kB

Total Files

69

Last publish

Collaborators

  • zhaoqingkaitt