安装
npm i mitch-tool --save 或者 yarn add mitch-tool
异步方法使用说明
- 引用 import {to} from 'mitch-tool'
- const [err,data] = await to(Promise);
crypto类加解密方法使用说明
- 引用 import {crypto} from 'mitch-tool'
- 使用方法示例: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类相关方法使用说明
- 引用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类相关方法使用说明
- 引用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