New Research: Supply Chain Attack on Axios Pulls Malicious Dependency from npm.Details →
Socket
Book a DemoSign in
Socket
Book a DemoSign in

great-jsutils

Package Overview
Dependencies
Maintainers
1
Versions
62
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

great-jsutils

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

latest
npmnpm
Version
1.4.4
Version published
Maintainers
1
Created
Source

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-generator、 great-jsutils、 great-ngform、 great-zorroutils、 great-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

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

2019.0829

keyvalue
版本1.2.1
升级说明根据json转model类
JsonUtils.toClassModel(jsonStr);

2019.0905

keyvalue
版本1.2.2
升级说明增加BankCardUtils、AjaxUtils
JsonUtils.toClassModel(jsonStr);

2019.0929

keyvalue
版本1.2.4
升级说明小数正则
RegexpUtils.isDecimal(num);

2019.1001

keyvalue
版本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

keyvalue
版本1.2.6
升级说明json转实体
toClassModel(json,{notes:false})

2019.1026

keyvalue
版本1.3.1
升级说明生成数字优化
toClassModel(json,{notes:false})

2020.0801

keyvalue
版本1.3.6
升级说明空值判断

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

Keywords

js
typescript
md5
time format
js时间格式化
utils

FAQs

Package last updated on 04 Sep 2022

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

Socket Named Top Sales Organization by RepVue

Company News

Socket Named Top Sales Organization by RepVue

Socket won two 2026 Reppy Awards from RepVue, ranking in the top 5% of all sales orgs. AE Alexandra Lister shares what it's like to grow a sales career here.

By Sarah Gooding  -  Apr 17, 2026
Socket Selected for OpenAI's Cybersecurity Grant Program

Company News

/

Security News

Socket Selected for OpenAI's Cybersecurity Grant Program

Socket is an initial recipient of OpenAI's Cybersecurity Grant Program, which commits $10M in API credits to defenders securing open source software.

By Sarah Gooding  -  Apr 16, 2026