安装

npm i mitch-tool --save 或者 yarn add mitch-tool

异步方法使用说明

1. 引用 import {to} from 'mitch-tool'
2. const [err,data] = await to(Promise);

crypto类加解密方法使用说明

1. 引用 import {crypto} from 'mitch-tool'
2. 使用方法示例：crypto.encrypt()

加密数据

    /**
     * 加密数据
     *
     * @param {string} text 需要加密的字符串
     * @param {crypto.BinaryToTextEncoding} [encoding] 加密方式 默认为hex
     * @param {string} [algorithm] 加密模式，默认为aes-128-ecb
     * @param {crypto.CipherKey} [password] 加密密钥，不传使用默认值
     * @param {string} [iv] 加密偏移量
     * @returns {string}
     * @memberof Crypto
     */
    encrypt(text: string, encoding?: crypto.BinaryToTextEncoding, algorithm?: string, password?: crypto.CipherKey, iv?: string): string

解密数据

/**
     * 解密数据
     *
     * @param {string} text 需要解密的字符串
     * @param {crypto.BinaryToTextEncoding} [encoding] 加密方式 默认为hex
     * @param {string} [algorithm] 加密模式 默认为aes-128-ecb
     * @param {crypto.CipherKey} [password] 加密密钥，不传使用默认值
     * @param {string} [iv] 加密偏移量
     * @returns {string}
     * @memberof Crypto
     */
    decrypt(text: string, encoding?: crypto.BinaryToTextEncoding, algorithm?: string, password?: crypto.CipherKey, iv?: string): string

签名数据

/**
     * 签名数据
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.SignKeyObjectInput | crypto.SignPrivateKeyInput)} privateKey 签名私钥
     * @param {string} data 签名数据
     * @param {string} algorithm 验签模式 默认为SHA1
     * @param {crypto.BinaryToTextEncoding} output_format 签名输出类型 默认为base64
     * @returns {string}
     * @memberof Crypto
     */
    sign(privateKey: string | crypto.KeyObject | Buffer | crypto.SignKeyObjectInput | crypto.SignPrivateKeyInput, data: string, algorithm?: string, output_format?: crypto.BinaryToTextEncoding): string

验证签名

/**
     * 验证签名
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.VerifyKeyObjectInput | crypto.VerifyPublicKeyInput)} publicKey 验签公钥
     * @param {string} data 签名数据
     * @param {BufferEncoding} input_encoding 输入的签名数据类型 默认为base64
     * @param {string} signStr 签名数据
     * @param {string} algorithm 验签模式 默认为SHA1
     * @param {("base64" | "hex" | undefined)} [signature_format]  签名数据类型 默认为base64
     * @returns {boolean}
     * @memberof Crypto
     */
    verify(publicKey: string | crypto.KeyObject | Buffer | crypto.VerifyKeyObjectInput | crypto.VerifyPublicKeyInput, data: string, signStr: string, input_encoding?: BufferEncoding, algorithm?: string, signature_format?: "base64" | "hex" | undefined): boolean

将16进制转换成二进制，主要用于需要将加密解密密钥进行转换来用的情况。比如云闪付的解密手机号就需要用到

/**
     * 将16进制转换成二进制，主要用于需要将加密解密密钥进行转换来用的情况。比如云闪付的解密手机号就需要用到
     *
     * @param {string} str 传入的16进制数据
     * @returns {any[]}
     * @memberof Crypto
     */
    Hexstring2btye(str: string): any[]

HMAC 加密方式 （带加密密钥）

  /**
     * HMAC 加密方式 （带加密密钥）
     *
     * @param {string} data 需要加密的字符串
     * @param {string} key 加密的密钥
     * @param {string} algorithm 签名模式  默认为SHA1
     * @param {crypto.BinaryToTextEncoding} encoding 加密后生成的类型 默认为base64
     * @returns {string}
     * @memberof Crypto
     */
    createHmac(data: string, key: string, algorithm?: string, encoding?: crypto.BinaryToTextEncoding): string

公钥加密

/**
     * 公钥加密
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.RsaPublicKey | crypto.RsaPrivateKey)} publicKey 公钥
     * @param {NodeJS.ArrayBufferView} buffer 需要加密的数据
     * @returns {string}
     * @memberof Crypto
     */
    publicEncrypt(publicKey: string | crypto.KeyObject | Buffer | crypto.RsaPublicKey | crypto.RsaPrivateKey, data: any): string

私钥解密

 /**
     * 私钥解密
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.RsaPrivateKey)} private_key 私钥
     * @param {NodeJS.ArrayBufferView} buffer 需要解密的私钥
     * @returns {string}
     * @memberof Crypto
     */
    privateDecrypt(private_key: string | crypto.KeyObject | Buffer | crypto.RsaPrivateKey, data: any): string

私钥加密

/**
     * 私钥加密
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.RsaPrivateKey)} private_key 私钥
     * @param {NodeJS.ArrayBufferView} buffer 需要加密的数据
     * @returns {string}
     * @memberof Crypto
     */
    privateEncrypt(private_key: string | crypto.KeyObject | Buffer | crypto.RsaPrivateKey, data: any): string

公钥解密

/**
     * 公钥解密
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.RsaPublicKey | crypto.RsaPrivateKey)} publicKey 公钥
     * @param {NodeJS.ArrayBufferView} buffer 需要解密的数据
     * @returns {string}
     * @memberof Crypto
     */
    publicDecrypt(publicKey: string | crypto.KeyObject | Buffer | crypto.RsaPublicKey | crypto.RsaPrivateKey, data: any): string

hash加密 （不带加密密钥）

/**
     * hash加密 （不带加密密钥）
     *
     * @param {string} data 加密的数据
     * @param {string} algorithm 加密类型 默认为sha256
     * @param {crypto.BinaryToTextEncoding} encoding 加密后转换的字符串类型  默认为base64
     * @returns {string}
     * @memberof Crypto
     */
    createHash(data: string, algorithm?: string, encoding?: crypto.BinaryToTextEncoding): string

ascii排序 通过spliter方式连接

 /**
     * ascii排序 通过spliter方式连接 
     *
     * @param {*} dataObject 排序对象
     * @param {string} spliter 分割符号
     * @returns {string}
     * @memberof Crypto
     */
    sortASCII(dataObject: any, spliter: string):string

jsrsa 签名方法

    /**
     * jsrsa 签名方法 
     *
     * @param {string} data 签名数据
     * @param {*} privateKey 私钥文件数据
     * @param {string} [alg] 签名类型 默认为 SHA256withRSA
     * @returns {string} 字符串为base64
     * @memberof Crypto
     */
    JSRSASign(data: string, privateKey: any, alg?: string): string

mail类相关方法使用说明

1. 引用import { mail } from "mitch-tool"

创建邮件发送对象

 /**
     * 创建邮件发送对象
     *
     * @param {string} name 邮件对象名称
     * @param {MailConfig} config 创建邮件对象参数 {host: string; port: number; secure?: boolean; auth: { user: string, pass: string } }
     * @returns {Mail}
     * @memberof NodeMail
     */
    createMailTransport(name: string, config: MailConfig): Mail

发送邮件

/**
     * 发送邮件
     *
     * @param {Mail} mail 创建的邮件对象
     * @param {mailOption} option 发送邮件对应的操作参数 
     * {from: 发送者邮箱，多个用‘，’隔开; to: 收件人邮箱，多个用‘，’隔开; subject: 邮件标题; html: 邮件内容 html格式的字符串; attachments: 附件 [{filename: 'test.md',path: './test.md'}, {filename: 'content', content: '发送内容'}] }}
     * @returns {Promise<any>}
     * @memberof NodeMail
     */
    sendEmail(mail: Mail, option: mailOption): Promise<any>

mysql类相关方法使用说明

1. 引用import { mysql } from "mitch-tool"

创建数据库对象单列方法

/**
     * 创建数据库对象单列方法
     *
     * @param {string} DBName 创建的单列名称
     * @param {dbConfig[]} config 创建数据库连接的config配置
     * @returns {mysqlDB}
     * @memberof Mysql
     */
    createSqlPool(DBName:string, config: dbConfig[]): mysqlDB

创建数据库公用方法对象

 /**
     * 创建数据库公用方法对象
     *
    * @param {string} modelName 创建单列名称
    * @param {modelConfig} model 创建数据库公用方法表配置文件
    * @param {mysqlDB} db 引用的数据库对象
     * @returns {mysqlModel}
     * @memberof Mysql
     */
    createSqlModel(modelName:string, model: modelConfig,db: mysqlDB): mysqlModel

自定义mysql方法类,获取到类对象后即可使用类中方法

新增或更新数据，根据传入的字段中是否有主键来决定，没有主键则新增，有主键则更新

/**
    * 新增或更新数据，根据传入的字段中是否有主键来决定，没有主键则新增，有主键则更新
    *
    * @param {*} data
    * @returns
    * @memberof mysqlModel
    */
    createOrUpdate(data: any): Promise<any[]> {
        if (data[this.pk]) {
            let idObj = this.createPkObj(data[this.pk]);
            delete data[this.pk];
            const params = [this.name, data, idObj];
            const strSql = "update ?? set ? where ? ";
            return this.mysqlMainDB.execWP(strSql, params);
        } else {
            const params = [this.name, data];
            delete data[this.pk];
            const strSql = "insert into ?? set ?";
            return this.mysqlMainDB.execWP(strSql, params);
        }
    }

根据key参数来决定，如果表中存在对应的key则更新，不存在则插入,使用replace 参数中必须包含主键

 /**
     * 根据key参数来决定，如果表中存在对应的key则更新，不存在则插入,使用replace 参数中必须包含主键
     *
     * @param {*} data 数据对象中必须包含主键ID
     * @memberof mysqlModel
     */
    createOrUpdateByReplace(data: any): Promise<any[]> {
        let keyAll = '';
        let valueAll = '';
        for (const k in data) {
            keyAll += `${k},`;
            valueAll += `'${data[k]}',`;
        }
        keyAll = keyAll.substr(0, keyAll.length - 1);
        valueAll = valueAll.substr(0, valueAll.length - 1);
        const params = [this.name];
        const strSql = `REPLACE INTO ?? (${keyAll}) VALUES(${valueAll});`;

        return this.mysqlMainDB.execWP(strSql, params);
    }

根据key参数来决定，如果表中存在对应的key则更新，不存在则插入,使用Duplicate 参数中必须包含主键

/**
     * 根据key参数来决定，如果表中存在对应的key则更新，不存在则插入,使用Duplicate 参数中必须包含主键
     *
     * @param {*} data 数据对象中必须包含主键ID
     * @memberof mysqlModel
     */
    createOrUpdateByDuplicate(data: any): Promise<any[]> {
        let keyAll = '';
        let valueAll = '';
        for (const k in data) {
            keyAll += `${k},`;
            valueAll += `'${data[k]}',`;
        }
        keyAll = keyAll.substr(0, keyAll.length - 1);
        valueAll = valueAll.substr(0, valueAll.length - 1);
        const params = [this.name, data];
        const strSql = `INSERT INTO ?? (${keyAll}) VALUES(${valueAll}) ON DUPLICATE KEY UPDATE ?;`;
        return this.mysqlMainDB.execWP(strSql, params);
    }

根据指定的主键字段来更新对应数据

/**
     * 根据指定的主键字段来更新对应数据
     *
     * @param {*} data
     * @param {string} upPk 指定的主键字段
     * @returns
     * @memberof mysqlModel
     */
    upDateByPkData(data: any, upPk: string): Promise<any[]> {
        let idObj = this.createMyPkObj(data[upPk], upPk);
        delete data[upPk];
        const params = [this.name, data, idObj];
        const strSql = "update ?? set ? where ? ";
        return this.mysqlMainDB.execWP(strSql, params);
    }

通过主键来查询数据

/**
    * 通过主键来查询数据
    *
    * @param {*} id
    * @returns
    * @memberof mysqlModel
    */
    get(id: any): Promise<any[]> {
        const params = [this.column, this.name, this.createPkObj(id)];
        const strSql = "select ?? from ?? where ? ";
        return this.mysqlMainDB.execWP(strSql, params);
    };

通过字段key和对应的value值来查询数据

/**
    * 通过字段key和对应的value值来查询数据
    *
    * @param {*} key
    * @param {*} value
    * @returns
    * @memberof mysqlModel
    */
    getKeyValue(key: any, value: any): Promise<any[]> {
        const params = [this.column, this.name, value];
        const strSql = `select ?? from ?? where ${key} = ? `;
        return this.mysqlMainDB.execWP(strSql, params);
    };

通过主键ID来删除column数据

/**
     * 通过主键ID来删除column数据
     *
     * @param {*} id
     * @returns
     * @memberof mysqlModel
     */
    deleteById(id: any): Promise<any[]> {
        const params = [this.name, this.createPkObj(id)];
        const strSql = "delete from ?? where ? ";
        return this.mysqlMainDB.execWP(strSql, params);
    };

通过自定义where条件对象来查询数据

/**
    * 通过自定义where条件对象来查询数据
    *
    * @param {*} where
    * @param {*} order
    * @memberof mysqlModel
    */
    getWhere(where: any, order = ''): Promise<any[]> {
        const params = [this.column, this.name, ...where.params];
        const strSql = `select ?? from ?? ${where.strSql} ${order}`;
        return this.mysqlMainDB.execWP(strSql, params);
    };

通过参入自定义where对象，排序和分页来查询数据

/**
     * 通过参入自定义where对象，排序和分页来查询数据
     *
     * @memberof mysqlModel
     */
    getWhereAndPage(where: any, order: any, page: any): Promise<any[]>{
        const params = [this.column, this.name, ...where.params, ...page.params];
        const strSql = `select ?? from ?? ${where.strSql} ${order} ${page.strSql}`;
        return this.mysqlMainDB.execWP(strSql, params);
    }

通过参入自定义where对象，排序和分页来查询数据，并查询出最大数据数量。

/**
     * 通过参入自定义where对象，排序和分页来查询数据，并查询出最大数据数量。
     *
     * @memberof mysqlModel
     */
    getWhereAndPageTotal(where: any, order: any, page: any): Promise<any[]> {
        const params = [this.column, this.name, ...where.params, ...page.params];
        const strSql = `select SQL_CALC_FOUND_ROWS ?? from ?? ${where.strSql} ${order} ${page.strSql};select found_rows() as total;`;
        return this.mysqlMainDB.execWP(strSql, params);
    }

自定义输入sql语句和参数来查询

/**
     * 自定义输入sql语句和参数来查询
     *
     * @memberof mysqlModel
     */
    dealMySqlDIY(sql: string, _params: any[]): Promise<any[]> {
        const params = [..._params];
        const strSql = sql;
        return this.mysqlMainDB.execWPTRAN(strSql, params);
    };

自定义输入sql语句和参数来查询 未开启事务

/**
     * 自定义输入sql语句和参数来查询 未开启事务
     *
     * @memberof mysqlModel
     */
    dealMySqlDIY2(sql: string, _params: any[]): Promise<any[]> {
        const params = [..._params];
        const strSql = sql;
        return this.mysqlMainDB.execWP(strSql, params);
    };

根据join表对象数据来链接

/**
 * 
 *
 * @param {*} data 需要join 的数据对象数组  {name:表名,type:join方式（left join,right join ....）,on:join的on链接参数}
 * @param {*} where
 * @param {*} order
 * @memberof mysqlModel
 */
    getJoin(data: joinObj[], searchData: any[], where: any, order = ''): Promise<any[]> {
        let joinSql = "";
        let _searchData = "";
        for (let d of data) {
            joinSql += ` ${d.type} ${d.name} on ${d.on} `
        }
        if (searchData.length > 0) {
            for (let s of searchData) {
                _searchData += `${s},`;
            }
            _searchData = _searchData.substring(0, _searchData.length - 1);
        } else {
            _searchData = '*';
        }

        const params = [this.name, ...where.params];
        const strSql = `select ${_searchData} from ?? ${joinSql} ${where.strSql} ${order}`;

        return this.mysqlMainDB.execWP(strSql, params);

    }

通过指定key来删除column数据

 /**
    * 通过指定key来删除column数据
    *
    * @param {*} key
    * @param {*} value
    * @returns
    * @memberof mysqlModel
    */
    deleteByKeyValue(key: any, value: any): Promise<any[]> {
        const params = [this.name, value];
        const strSql = `delete from ?? where ${key} = ?`;
        return this.mysqlMainDB.execWP(strSql, params);
    }

多表关联查询

/**
    *多表关联查询
    *
    * 
    * @param {Obj} sqlObj  
    * {
    * colunums:<string>'', // 要查询的字段
    * joinTbales:<string>'', //相关表连接查询
    * params: <any>[], //where条件参数
    * strSql: <string>"", // where条件sql语句
    * group:<string>"" //分组条件
    * };
    * @param {string} order 排序字符串
    * @param {obj} page 分页对象  { params: [ 0, 10 ], strSql: ' limit ?,?' }
    * @returns
    */
    selJoinTable(sqlObj: any, order: any, page: any): Promise<any[]> {
        let params = [...sqlObj.params, ...page.params];
        let strSQL = `select SQL_CALC_FOUND_ROWS ${sqlObj.colunums} from ${sqlObj.joinTbales}
         ${sqlObj.whereStrSql} ${sqlObj.whereGroup} ${order} ${page.strSql};select found_rows() as total;`
        return this.mysqlMainDB.execWP(strSQL, params);
    }

redis类相关方法使用说明

1.引用 import { redis } from "mitch-tool"

创建redisDB单列对象

 /**
     * 创建redisDB单列对象
     *
     * @param {string} name 创建单例名称
     * @param {redisConfig[]} dbConfig 创建redis对象的参数配置
     * @returns {(ioRedis.Redis | ioRedis.Cluster)}
     * @memberof Redis
     */
    createRedisDB(name:string,dbConfig: redisConfig[]): ioRedis.Redis | ioRedis.Cluster

创建redis公用模块对象

 /**
     * 创建redis公用模块对象
     *
     * @param {string} name 创建公用模块名称
     * @param {(ioRedis.Redis | ioRedis.Cluster)} redisDB 用到的redisDB对象
     * @returns {redisModel}
     * @memberof Redis
     */
    createRedisModel(name:string, redisDB: ioRedis.Redis | ioRedis.Cluster): redisModel

发送redisMQ队列数据

/**
     * 发送redisMQ队列数据
     *
     * @param {(ioRedis.Redis | ioRedis.Cluster)} redisDB 创建的redisDB对象
     * @param {string} MQStreamName 队列名称
     * @param {object} data 发送的数据对象 为 {} 结构
     * @param {number} [maxLen] 此队列中最大保存的数据条数
     * @returns {Promise<boolean>} 返回true为成功  false为失败
     * @memberof Redis
     */
    sendMQData(redisDB:ioRedis.Redis | ioRedis.Cluster, MQStreamName: string, data: object,maxLen?: number): Promise<boolean> 

启动redisMQ队列

   /**
     * 启动redisMQ队列 默认会创建一个默认的{}数据对象，option中操作函数需要对{}对象数据进行处理，遇见{}对象数据直接返回成功并ack，非{}数据再进行其他操作
     *
     * @param {(ioRedis.Redis | ioRedis.Cluster)} redisDB 创建的redisDB对象
     * @param {RedisMQConfig} option 相关的队列对象参数
     * @returns {Promise<void>}
     * @memberof Redis
     */
    redisMQStart(redisDB:ioRedis.Redis | ioRedis.Cluster, option:RedisMQConfig): Promise<void>

自定义redis方法类,获取到类对象后即可使用类中方法

获取字符串指定 key 的值。

 /**
     *获取字符串指定 key 的值。
     *
     * @param {string} keyName key值
     * @returns {Promise<any>} 返回一个promise
     * @memberof redisModel
     */
    public get(keyName: string): Promise<any> {
        return new Promise((resolve, reject) => {
            this.redisClient.get(keyName, (err, result) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(result);
                }
            })
        })
    }

设置字符串指定 key 的值

/**
     *设置字符串指定 key 的值
     *
     * @param {string} keyName key值
     * @param {string} data 字符串value
     * @returns {Promise<any>}
     * @memberof redisModel
     */
    public set(keyName: string, data: string): Promise<any> {
        return new Promise((resolve, reject) => {
            this.redisClient.set(keyName, data, (err, result) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(result);
                }
            })
        })
    }

检查指定字符串 key 是否存在。

  /**
     *检查指定字符串 key 是否存在。
     *
     * @param {string} keyName 给定key值
     * @returns {Promise<any>}
     * @memberof redisModel
     */
    public exists(keyName: string): Promise<any> {
        return new Promise((resolve, reject) => {
            this.redisClient.exists(keyName, (err, result) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(result);
                }
            })
        })
    }

将哈希表 key 中的字段 field 的值设为 value 。

    /**
     *将哈希表 key 中的字段 field 的值设为 value 。
     *
     * @param {string} keyName key值
     * @param {string} filed 指定的字段
     * @param {string} data value 
     * @returns 成功返回1，如果字段存在，成功则返回0
     * @memberof redisModel
     */
    public setHash(keyName: string, filed: string, data: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.hset(keyName, filed, data, (err, result) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(result);
                }
            })
        })
    }

获取存储在哈希表中指定字段的值

 /**
     *
     *获取存储在哈希表中指定字段的值
     * @param {string} keyName key值
     * @param {string} filed 指定的字段
     * @returns
     * @memberof redisModel
     */
    public getHash(keyName: string, filed: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.hget(keyName, filed, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

删除一个或多个哈希表字段

 /**
     * 删除一个或多个哈希表字段
     *
     * @param {string} keyName 指定key值
     * @param {(string | string[])} field 除的字段，单个：string,多个：array,数组里面存放field字段
     * @returns 删除成功返回1
     * @memberof redisModel
     */
    public delHash(keyName: string, field: string | string[]) {
        return new Promise((resolve, reject) => {
            this.redisClient.hdel(keyName, field, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

获取在哈希表中指定 key 的所有字段和值

 /**
     * 获取在哈希表中指定 key 的所有字段和值
     *
     * @param {string} keyName 指定的key值
     * @memberof redisModel
     * @returns 返回一个对象，object
     */
    public getAllHash(keyName: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.hgetall(keyName, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

查看哈希表 key 中，指定的字段是否存在。

   /**
     *查看哈希表 key 中，指定的字段是否存在。
     *
     * @param {string} keyName key值
     * @param {string} field 指定字段
     * @memberof redisModel 如果哈希表含有给定字段，返回 1 。 如果哈希表不含有给定字段，或 key 不存在，返回 0 。
     */
    public hexists(keyName: string, field: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.hexists(keyName, field, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

将一个或多个值插入到列表头部

/**
     *将一个或多个值插入到列表头部
     *
     * @param {string} keyName
     * @param {string} data
     * @memberof redisModel
     */
    public lpush(keyName: string, data: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.lpush(keyName, data, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

获取列表指定范围内的元素,默认取全部元素

/**
     *获取列表指定范围内的元素,默认取全部元素
     *
     * @param {string} keyName key值
     * @param {number} start 区间偏移量，0表示第一个元素，以此类推
     * @param {number} end 区间偏移量，-1标识最后一个元素，以此类推
     * @memberof redisModel
     */
    public lrange(keyName: string, start?: number, end?: number) {
        let _start = start || 0
        let _end = end || -1
        return new Promise((resolve, reject) => {
            this.redisClient.lrange(keyName, _start, _end, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

移除列表元素

/**
     *移除列表元素
     *
     * @param {string} keyName key值
     * @param {number} count
     *  count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
     * count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
     * count = 0 : 移除表中所有与 VALUE 相等的值。
     * @param {string} value value值
     * @memberof redisModel
     */
    public Lrem(keyName: string, count: number, value: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.lrem(keyName, count, value, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

删除整个key值

    /**
     *删除整个key值
     *
     * @param {string} keyName
     * @memberof redisModel
     */
    public delAll(keyName: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.del(keyName, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

schedule类方法使用说明

引入 import { schedule } from "mitch-tool"

初始化设置定时器设置

 /**
     * 初始化设置定时器设置  
     * 程序中启动定时任务, pm2 启动会默认自带一个 'NODE_APP_INSTANCE' 的环境变量,  它从 0 开始自增, 
     * 永远不能能重复, 每一个worker拥有一个值，或者执行方法的时候判断下 if(process.env.NODE_APP_INSTANCE === '0'){// TO DO ...}  这样就可以在某个worker里执行一次
     *
     * @param {string} time 定时器时间   * * * * * *
     *                                  ┬ ┬ ┬ ┬ ┬ ┬
     *                                  │ │ │ │ │  |
     *                                  │ │ │ │ │ └ day of week (0 - 7) (0 or 7 is Sun)
     *                                  │ │ │ │ └───── month (1 - 12)
     *                                  │ │ │ └────────── day of month (1 - 31)
     *                                  │ │ └─────────────── hour (0 - 23)
     *                                  │ └──────────────────── minute (0 - 59)
     *                                  └───────────────────────── second (0 - 59, OPTIONAL)
     * @param {() => any} fuc 定时执行的方法 
     * @returns {schedule.Job} 返回定时器任务对象
     * @memberof nodeSchedule
     */
    setSchedule(time: string, fuc: () => any): schedule.Job

取消定时器

   /**
     * 取消定时器
     *
     * @param {schedule.Job} job 定时器任务对象
     * @memberof nodeSchedule
     */
    stopSchedule(job: schedule.Job): void

根据规则来设置定时器

/**
     * 根据规则来设置定时器
     *
     * @param {schedule.RecurrenceRule} scheduleRuler 定时器规则
     * 程序中启动定时任务, pm2 启动会默认自带一个 'NODE_APP_INSTANCE' 的环境变量,  它从 0 开始自增, 
     * 永远不能能重复, 每一个worker拥有一个值，或者执行方法的时候判断下 if(process.env.NODE_APP_INSTANCE === '0'){// TO DO ...}  这样就可以在某个worker里执行一次
     * 
     * Examples:
     * 
     *     let rule = new schedule.RecurrenceRule();
     *     rule.dayOfWeek = 2;
     *     rule.month = 3;
     *     rule.dayOfMonth = 1;
     *     rule.hour = 1;
     *     rule.minute = 42; 或者数组 [0, 15, 45]
     *     rule.second = 0;
     * @param {() => any} fuc 定时器执行的方法
     * @returns {schedule.Job} 返回定时器对象
     * @memberof nodeSchedule
     */
    rulerSetSchedule(scheduleRuler: schedule.RecurrenceRule, fuc: () => any): schedule.Job
}

ipBlock类相关方法说明

引用import { ipBlock } from "mitch-tool"

创建ipBlock对象 创建对象后，可使用对象中的addIp removeIp 方法来操作redis中的数据

/**
     * 创建ipBlock对象  创建对象后，可使用对象中的addIp  removeIp 方法来操作redis中的数据
     *
     * @param {string} name 对象单列名称
     * @param {(ioRedis.Redis | ioRedis.Cluster)} redisDB 使用到的redisDB对象
     * @param {IpBlockOption} option 操作参数   block: boolean 是否禁用IP;  maxCount: number 检测周期时间内访问最大次数;  blockCount: number 禁用IP访问最大次数 一般大于maxCount; 
     * expireIn: number 检测周期时间; key: string 保存次数的key名称;  blockKeyName:string 保存禁用IP Hash表的名称; whileKeyName:string 保存白名单IP Hash表的名称；
     * @returns {IpBlock}
     * @memberof IPBlock
     */
    createIpBlock(name:string, redisDB: ioRedis.Redis | ioRedis.Cluster, option: IpBlockOption): IpBlock

express框架对ip进行检测阻拦的中间件

 /**
     * express框架对ip进行检测阻拦的中间件
     *
     * @param {IpBlock} ipBlock 创建的IpBlock对象
     * @returns {(req: any, res: any, next:any) => void}
     * @memberof IPBlock
     */
    ipBlockMiddleware(ipBlock: IpBlock): (req: any, res: any, next:any) => void

snowFlakeID类方法使用说明

引入 import { snowFlakeID } from "mitch-tool"

创建雪花算法对象

 /**
     * 创建雪花算法对象 对象中调用generate方法来获取ID
     *
     * @param {string} name 单列对象名称
     * @param {*} [mid] 机器id或任何随机数。如果您是在分布式系统中生成id，强烈建议您提供一个适合不同机器的mid
     * @param {number} [offset] 这是一个时间偏移量，它将从当前时间中减去以获得id的前42位。这将有助于生成更小的id
     * @returns {string} 返回ID
     * @memberof snowFlakeID
     */
    createSnowFlake(name: string, mid?: any, offset?: number): string