aokai-project-tools

v1.0.5

Published

2 years ago

ProjectTools 是基于Vue3封装的工具库。

Downloads

0High
0Medium
0Low

zboolean

什么是ProjectTools

ProjectTools 是基于Vue3封装的工具库。

特性

基于Vue3开发
基于TypeScript开发

公共类型

| 类型 | 注解 | |-------------------------|-------------| | VoidCallback | 空回调 | | Callback | 回调 | | RangeValue | 范围值 | | RangeOptionalRangeValue | 可选范围值 | | KeyInObject | 用于表示对象中的键类型 | | Coordinates | 坐标 |

如何安装

npm i aokai-project-tools

使用方法

import {useAdaptation,...} from "aokai-project-tools"

该库提供以下模块，每个模块都有各自的功能和类型：

Adaptation

AdaptationOptions - 适配配置
useAdaptation(option: AdaptationOptions) - 使用rem适配

import { AdaptationOptions, useAdaptation } from 'aokai-project-tools/adaptation';

const options: AdaptationOptions = {
    baseFontSize: 16,
    draftWidth: 1440,
}

const app = createApp(App)
app.use(useAdaptation(options))
app.mount('#app')

Validate utils

`getObjectType<T extends object = any>(value: T): string`

此函数以字符串形式返回给定值的类型。

import { getObjectType } from 'aokai-project-tools/validate-utils';
console.log(getObjectType({})) // Output "[object Object]"
console.log(getObjectType([])) // Output "[object Array]"
console.log(getObjectType(null)) // Output "[object Null]"
console.log(getObjectType(42)) // Output "[object Number]"
console.log(getObjectType(true)) // Output "[object Boolean]"
console.log(getObjectType('Hello')) // Output "[object String]"

`isObject(value: any): boolean`

此函数检查给定值是否为对象。

import { isObject } from 'aokai-project-tools/validate-utils';
console.log(isObject({})) // Output true
console.log(isObject([])) // Output false
console.log(isObject(null)) // Output false

`isArray<T = any>(value: any): boolean`

此函数检查给定值是否为数组。

import { isArray } from 'aokai-project-tools/validate-utils';
console.log(isArray([])) // Output true
console.log(isArray({})) // Output false
console.log(isArray(null)) // Output false

`isString(value: any): boolean`

此函数检查给定值是否为字符串。

import { isString } from 'aokai-project-tools/validate-utils';
console.log(isString('Hello')) // Output true
console.log(isString(42)) // Output false
console.log(isString(null)) // Output false

`isNumber(value: any): boolean`

此函数检查给定值是否为数字。

import { isNumber } from 'aokai-project-tools/validate-utils';
console.log(isNumber(42)) // Output true
console.log(isNumber('Hello')) // Output false
console.log(isNumber(null)) // Output false

`isBoolean(value: any): boolean`

此函数检查给定值是否为布尔值。

import { isBoolean } from 'aokai-project-tools/validate-utils';
console.log(isBoolean(true)) // Output true
console.log(isBoolean(false)) // Output true
console.log(isBoolean('Hello')) // Output false

`isNull(value: any): boolean`

此函数检查给定值是否为null。

import { isNull } from 'aokai-project-tools/validate-utils';
console.log(isNull(null)) // Output true
console.log(isNull(undefined)) // Output false
console.log(isNull('Hello')) // Output false

`isUndefined(value: any): boolean`

此函数检查给定值是否为undefined。

import { isUndefined } from 'aokai-project-tools/validate-utils';
console.log(isUndefined(undefined)) // Output true
console.log(isUndefined(null)) // Output false
console.log(isUndefined('Hello')) // Output false

`isFunction(value: any): boolean`

此函数检查给定值是否为函数。

import { isFunction } from 'aokai-project-tools/validate-utils';
console.log(isFunction(() => {})) // Output true
console.log(isFunction(null)) // Output false
console.log(isFunction('Hello')) // Output false

`isDate(value: any): boolean`

此函数检查给定值是否为日期。

import { isDate } from 'aokai-project-tools/validate-utils';
console.log(isDate(new Date())) // Output true
console.log(isDate('Hello')) // Output false
console.log(isDate(null)) // Output false

`isRegExp(value: any): boolean`

此函数检查给定值是否为正则表达式。

import { isRegExp } from 'aokai-project-tools/validate-utils';
console.log(isRegExp(/^[a-zA-Z0-9]+$/)) // Output true
console.log(isRegExp('Hello')) // Output false
console.log(isRegExp(null)) // Output false

`isError(value: any): boolean`

此函数检查给定值是否为错误。

import { isError } from 'aokai-project-tools/validate-utils';
console.log(isError(new Error('Hello'))) // Output true
console.log(isError('Hello')) // Output false
console.log(isError(null)) // Output false

`isSymbol(value: any): boolean`

此函数检查给定值是否为符号。

import { isSymbol } from 'aokai-project-tools/validate-utils';
console.log(isSymbol(Symbol('Hello'))) // Output true
console.log(isSymbol('Hello')) // Output false
console.log(isSymbol(null)) // Output false

`isSet<T = any>(value: any): boolean`

此函数检查给定值是否为Set。

import { isSet } from 'aokai-project-tools/validate-utils';
console.log(isSet(new Set([1, 2, 3]))) // Output true
console.log(isSet(new Map())) // Output false
console.log(isSet(null)) // Output false

`isMap<K = any, V = any>(value: any): boolean`

此函数检查给定值是否为Map。

import { isMap } from 'aokai-project-tools/validate-utils';
console.log(isMap(new Map([['a', 1], ['b', 2]]))) // Output true
console.log(isMap(new Set([1, 2, 3]))) // Output false
console.log(isMap(null)) // Output false

`isWeakSet<T extends object = any>(value: any): boolean`

此函数检查给定值是否为WeakSet。

import { isWeakSet } from 'aokai-project-tools/validate-utils';
console.log(isWeakSet(new WeakSet([{}]))) // Output true
console.log(isWeakSet(new WeakMap())) // Output false
console.log(isWeakSet(null)) // Output false

`isWeakMap<K extends object = any, V = any>(value: any): boolean`

此函数检查给定值是否为WeakMap。

import { isWeakMap } from 'aokai-project-tools/validate-utils';
console.log(isWeakMap(new WeakMap([[{}]]))) // Output true
console.log(isWeakMap(new WeakSet([{}]))) // Output false
console.log(isWeakMap(null)) // Output false

`isPromise<T = any>(value: any): boolean`

此函数检查给定值是否为Promise。

import { isPromise } from 'aokai-project-tools/validate-utils';
console.log(isPromise(Promise.resolve(42))) // Output true
console.log(isPromise(new Promise(() => {}))) // Output true
console.log(isPromise(null)) // Output false

`isGenerator(value: any): boolean`

此函数检查给定值是否为Generator。

import { isGenerator } from 'aokai-project-tools/validate-utils';
console.log(isGenerator(function* () {})) // Output true
console.log(isGenerator(function () {})) // Output false
console.log(isGenerator(null)) // Output false

`isAsyncFunction(value: any): boolean`

此函数检查给定值是否为async function。

import { isAsyncFunction } from 'aokai-project-tools/validate-utils';
console.log(isAsyncFunction(async () => {})) // Output true
console.log(isAsyncFunction(function () {})) // Output false
console.log(isAsyncFunction(null)) // Output false

`isDecimal(value: any): boolean`

此函数检查给定值是否为小数。

import { isDecimal } from 'aokai-project-tools/validate-utils';
console.log(isDecimal(3.14)) // Output true
console.log(isDecimal(42)) // Output false
console.log(isDecimal('Hello')) // Output false

`isInteger(value: any): boolean`

此函数检查给定值是否为整数。

import { isInteger } from 'aokai-project-tools/validate-utils';
console.log(isInteger(42)) // Output true
console.log(isInteger(3.14)) // Output false
console.log(isInteger('Hello')) // Output false

`isNegative(value: any): boolean`

此函数检查给定值是否为负数。

import { isNegative } from 'aokai-project-tools/validate-utils';
console.log(isNegative(-3.14)) // Output true
console.log(isNegative(42)) // Output false
console.log(isNegative('Hello')) // Output false

`validatePhoneNumber(phone: string, countries: CountryCode[]): boolean`

此函数检查给定的电话号码是否为有效的国际电话号码。

import { validatePhoneNumber } from 'aokai-project-tools/validate-utils';
console.log(validatePhoneNumber('+8612345678901', ['CN'])) // Output true
console.log(validatePhoneNumber('+8612345678901', ['US'])) // Output false
console.log(validatePhoneNumber('+8612345678901', ['CN', 'US'])) // Output true

`isEmail(value: string): boolean`

此函数检查给定的字符串是否为有效的电子邮件地址。

import { isEmail } from 'aokai-project-tools/validate-utils';
console.log(isEmail('')) // Output false
console.log(isEmail('[email protected]')) // Output true

`isUrl(value: string): boolean`

此函数检查给定的字符串是否为有效的URL。

import { isUrl } from 'aokai-project-tools/validate-utils';
console.log(isUrl('')) // Output false
console.log(isUrl('https://www.google.com')) // Output true

`isEmpty(value: string): boolean`

此函数检查给定的字符串是否为空或null或undefined。

import { isEmpty } from 'aokai-project-tools/validate-utils';
console.log(isEmpty('')) // Output true
console.log(isEmpty(' ')) // Output true
console.log(isEmpty('Hello')) // Output false
console.log(isEmpty(null)) // Output true
console.log(isEmpty(undefined)) // Output true

Base utils

`debounce(func: Function, wait: number): Function`

函数防抖

返回一个新函数，该函数会推迟原函数的执行，最多等待指定的延迟时间。

主要用于限制函数的调用频率，避免因频繁调用而造成的性能问题。

import { debounce } from 'aokai-project-tools/base-utils';
const debouncedFunc = debounce(() => {
    console.log('Hello')
}, 1000)
setTimeout(() => {
    debouncedFunc() // 不会执行
    setTimeout(() => {
        debouncedFunc() // Output Hello
    }, 510)
}, 500)

`throttle(func: Function, wait: number): Function`

函数节流

限制函数调用的频率

import { throttle } from 'aokai-project-tools/base-utils';
const throttledFunc = throttle(() => {
    console.log('Hello')
}, 1000)
setTimeout(() => {
    debouncedFunc() // 不会执行
    setTimeout(() => {
        debouncedFunc() // 不会执行
        setTimeout(() => {
            debouncedFunc() // Output Hello
        }, 1000)
    }, 510)
}, 500)

`createSyncPipe()`

创建一个同步管道处理函数。

管道允许开发者定义一系列函数，这些函数将按顺序执行，每个函数的输出作为下一个函数的输入。

import { createSyncPipe } from 'aokai-project-tools/base-utils';
const pipe = createSyncPipe()
pipe.use((value) => {
    return value + 1
}, (value) => {
    return value * 2
})
pipe.use((value) => {
    return value + 1
})
console.log(pipe.run(1)) // Output 5

`createPipe()`

创建一个异步管道处理函数。

import { createPipe } from 'aokai-project-tools/base-utils';
const pipe = createPipe()
pipe.use(async (next, value) => {
    setTimeout(() => {
        next(value + 1)
    }, 500)
}, async (next, value) => {
    setTimeout(() => {
        next(value * 2)
    }, 500)
})
pipe.use(async (next, value) => {
    setTimeout(() => {
        next(value + 1)
    }, 500)
})
pipe.run(1).then((value) => {
    console.log(value) // Output 5
})

`formatPhoneNumber(phone: string, country: CountryCode): string`

此函数根据给定的国家代码和手机号码，返回格式化后的手机号码。

import { formatPhoneNumber } from 'aokai-project-tools/base-utils';
console.log(formatPhoneNumber('+8612345678901', 'CN')) // Output +86 123 4567 8901
console.log(formatPhoneNumber('+12242222222', 'US')) // Output +1 224 222 2222

`CodeCountries`

所有国家代码

`PhoneCallCodeList`

所有国家区号代码列表

Date utils

`convertLikeToDate(value: LikeDateValue): Date`

将类似日期的字符串、数值、日期对象、Dayjs对象转换为Date对象。

import { convertLikeToDate } from 'aokai-project-tools/date-utils';
console.log(convertLikeToDate('2023-01-01')) // Output 2023-01-01T00:00:00.000Z
console.log(convertLikeToDate(new Date('2023-01-01'))) // Output 2023-01-01T00:00:00.000Z
console.log(convertLikeToDate(1672531200000)) // Output 2023-01-01T00:00:00.000Z

`convertLikeToDayjs(value: LikeDateValue): dayjs.Dayjs`

将类似日期的字符串、数值、日期对象、Dayjs对象转换为Dayjs对象。

import { convertLikeToDayjs } from 'aokai-project-tools/date-utils';
console.log(convertLikeToDayjs('2023-01-01')) // Output Dayjs 2023-01-01T00:00:00.000Z
console.log(convertLikeToDayjs(new Date('2023-01-01'))) // Output Dayjs 2023-01-01T00:00:00.000Z
console.log(convertLikeToDayjs(1672531200000)) // Output Dayjs 2023-01-01T00:00:00.000Z

`convertLikeToTimestamp(value: LikeDateValue): number`

将类似日期的字符串、数值、日期对象、Dayjs对象转换为时间戳。

import { convertLikeToTimestamp } from 'aokai-project-tools/date-utils';
console.log(convertLikeToTimestamp('2023-01-01')) // Output 1672531200000
console.log(convertLikeToTimestamp(new Date('2023-01-01'))) // Output 1672531200000
console.log(convertLikeToTimestamp(1672531200000)) // Output 1672531200000

`isInvalid(value: Date): boolean`

判断给定的日期是否为无效日期。

import { isInvalid } from 'aokai-project-tools/date-utils';
console.log(isInvalid(new Date('2023-01-01'))) // Output false
console.log(isInvalid(new Date('2023-01-32'))) // Output true
console.log(isInvalid(new Date('2023-02-29'))) // Output false
console.log(isInvalid(new Date('2023-02-30'))) // Output true

`getLikeTimestampRange(value: LikeDateValue = new Date()): RangeValue<number>`

获取给定日期的起始时间和结束时间戳。

import { getLikeTimestampRange } from 'aokai-project-tools/date-utils';
console.log(getLikeTimestampRange('2023-01-01')) // Output { start: 1672531200000, end: 1672617600000 }
console.log(getLikeTimestampRange(new Date('2023-01-01'))) // Output { start: 1672531200000, end: 1672617600000 }
console.log(getLikeTimestampRange(1672531200000)) // Output { start: 1672531200000, end: 1672617600000 }

`toUTC(value?: LikeDateValue): string`

将给定的日期转换为UTC时间。

import { toUTC } from 'aokai-project-tools/date-utils';
console.log(toUTC('2023-01-01')) // Output 2023-01-01 00:00:00
console.log(toUTC(new Date('2023-01-01'))) // Output 2023-01-01 00:00:00
console.log(toUTC(1672531200000)) // Output 2023-01-01 00:00:00

`getMonthDays(month: number = <now month>): number[]`

获取给定月份的日期列表。

import { getMonthDays } from 'aokai-project-tools/date-utils';
console.log(getMonthDays(1)) // Output [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]

`getYearType(year: number = <now year>): YearType`

获取给定年份的类型(平年, 闰年)。

import { getYearType } from 'aokai-project-tools/date-utils';
console.log(getYearType(2023)) // Output leap 闰年
console.log(getYearType(2024)) // Output normal 平年

`getAge(birthday: LikeDateValue): number`

获取给定生日的周岁数。

import { getAge } from 'aokai-project-tools/date-utils';
console.log(getAge('1990-01-01')) // Output 33
console.log(getAge(new Date('1990-01-01'))) // Output 33

Location utils

`degreesToRadians(degrees: number): number`

将角度转换为弧度。

import { degreesToRadians } from 'aokai-project-tools/location-utils';
console.log(degreesToRadians(180)) // Output 3.141592653589793

`EARTH_RADIUS`

地球半径，单位为米。

`getDistanceBetweenCoordinates(lat1: number, lng1: number, lat2: number, lng2: number): number`

计算两个坐标之间的距离，单位为米(可能会与实际测绘有误差)。

import { getDistanceBetweenCoordinates } from 'aokai-project-tools/location-utils';
console.log(getDistanceBetweenCoordinates(30.123456, 120.123456, 30.123457, 120.123457)) // Output 0.000000

Number utils

`getDecimalPrecision(value: number): number`

获取给定数字的小数位数。

import { getDecimalPrecision } from 'aokai-project-tools/number-utils';
console.log(getDecimalPrecision(1.234)) // Output 3

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme

什么是ProjectTools

特性

公共类型

如何安装

使用方法

Adaptation

Validate utils

getObjectType<T extends object = any>(value: T): string

isObject(value: any): boolean

isArray<T = any>(value: any): boolean

isString(value: any): boolean

isNumber(value: any): boolean

isBoolean(value: any): boolean

isNull(value: any): boolean

isUndefined(value: any): boolean

isFunction(value: any): boolean

isDate(value: any): boolean

isRegExp(value: any): boolean

isError(value: any): boolean

isSymbol(value: any): boolean

isSet<T = any>(value: any): boolean

isMap<K = any, V = any>(value: any): boolean

isWeakSet<T extends object = any>(value: any): boolean

isWeakMap<K extends object = any, V = any>(value: any): boolean

isPromise<T = any>(value: any): boolean

isGenerator(value: any): boolean

isAsyncFunction(value: any): boolean

isDecimal(value: any): boolean

isInteger(value: any): boolean

isNegative(value: any): boolean

validatePhoneNumber(phone: string, countries: CountryCode[]): boolean

isEmail(value: string): boolean

isUrl(value: string): boolean

isEmpty(value: string): boolean