Options
All
  • Public
  • Public/Protected
  • All
Menu

logo

NPM Version Build Status Coverage Status Size Gzip Size License

小巧实用的 JavaScript 工具类库。

https://fjc0k.github.io/vtils/

特性

  • 源于日常项目实践,更实用
  • 使用 TypeScript 编写,类型友好
  • 支持摇树优化(Tree Shaking),只引入使用到的工具
  • 浏览器、Node、小程序多端兼容

说明

vtils 自身并不包括一些已有成熟库的工具,如时间处理、网络请求等,在此做下推荐:

安装

# yarn
yarn add vtils

# or, npm
npm i vtils --save

你也可通过 CDN 安装,然后使用全局变量 vtils 访问相关工具:

<script src="https://cdn.jsdelivr.net/npm/vtils@2.26.1-beta.2/lib/index.umd.min.js" crossorigin="anonymous"></script>

<script>
  if (vtils.inBrowser()) {
    alert('您在浏览器中...')
  }
</script>

使用

在线体验:https://stackblitz.com/edit/vtils

import { inBrowser, shuffle } from 'vtils'

if (inBrowser()) {
  alert('您在浏览器中...')
}

alert(shuffle([1, 2, 3, 4]))

Index

Enumerations

Classes

Interfaces

Type aliases

Functions

Type aliases

AnyFunction

AnyFunction: function

任意函数类型。

Type declaration

    • (...args: any[]): any
    • Parameters

      • Rest ...args: any[]

      Returns any

AnyObject

AnyObject: Record<keyof any, any>

任意对象类型。

AsyncOrSync

AsyncOrSync<T>: PromiseLike<T> | T
example
// before
type X = PromiseLike<string> | string
// after
type X = AsyncOrSync<string>

Type parameters

  • T

AsyncReturnType

AsyncReturnType<T>: T extends (...args: any[]) => Promise<infer R> ? R : any

类似 ReturnType,不过会返回 Promise<R> 中的 R

example
type Result0 = ReturnType<() => Promise<number>> // => Promise<number>
type Result1 = AsyncReturnType<() => Promise<number>> // => number

Type parameters

  • T: function

Brand

Brand<T, B>: T & object

名义化类型。

example
type User = { id: Brand<number, User>, name: string }
type Post = { id: Brand<number, Post>, title: string }
type UserIdIsNumber = User['id'] extends number ? true: false // => true
type PostIdIsNumber = Post['id'] extends number ? true: false // => true
type PostIdIsNotUserId = Post['id'] extends User['id'] ? false : true // => true

Type parameters

  • T

  • B

Defined

Defined<T>: Exclude<T, undefined>

T 中排除 undefined 类型。

example
interface User {
  gender?: 'male' | 'female',
}
// before
type UserGender = Exclude<User['gender'], undefined>
// after
type UserGender = Defined<User['gender']>

Type parameters

  • T

DisposerItem

DisposerItem: function

待释放项目。

Type declaration

    • (): void | Promise<void>
    • Returns void | Promise<void>

EasyValidatorData

EasyValidatorData: Record<keyof any, any>

EasyValidatorRules

EasyValidatorRules<D>: Array<EasyValidatorRule<D>>

Type parameters

EventBusUnsubscribe

EventBusUnsubscribe: function

取消订阅

Type declaration

    • (): void
    • Returns void

GetTypeReturn

GetTypeReturn: LiteralUnion<"Undefined" | "Null" | "Array" | "String" | "Arguments" | "Function" | "Error" | "Boolean" | "Number" | "Date" | "RegExp" | "Object" | "JSON" | "Math" | "Symbol" | "Map" | "Set" | "WeakMap" | "WeakSet", string>

If

If<Condition, Then, Else>: If<Condition, Then, Else>

条件类型。

example
type X = 'x'
// before
type IsX = X extends 'x' ? true : false
// after
type IsX = If<X extends 'x', true, false>

Type parameters

  • Condition

  • Then

  • Else

IsNever

IsNever<T>: IsNever<T>

检查 T 是否是 never 类型。

example
type X = never
// before
type XIsNever = [X] extends [never] ? true : false
// after
type XIsNever = IsNever<X>

Type parameters

  • T

LiteralUnion

LiteralUnion<L, B>: L | Brand<B, never>

字面量联合类型。

example
// before: China, American 将得不到类型提示
type Country = 'China' | 'American' | string
// after: China, American 将得到类型提示
type Country = LiteralUnion<'China' | 'American', string>

Type parameters

  • L

  • B

MemoizeReturn

MemoizeReturn<T>: T & object

Type parameters

Merge

Merge<M, N>: Omit<M, Extract<keyof M, keyof N>> & N

合并两个类型,后一个类型的定义将覆盖前一个类型的定义。

example
type X = Merge<
  { x: number, y: number },
  { x: string, z: string }
>
// => { x: string, y: number, z: string }

Type parameters

  • M

  • N

Omit

Omit<T, K>: Pick<T, Exclude<keyof T, K>>

从接口 T 中去除指定的属性。

example
type X = Omit<
  { x: number, y: string, z: boolean },
  'x' | 'z'
>
// => { y: string }

Type parameters

  • T

  • K: keyof T

OneOrMore

OneOrMore<T>: T | T[]
example
// before
type X = number | number[]
// after
type X = OneOrMore<number>

Type parameters

  • T

OrderByRule

OrderByRule<T>: object

Type parameters

  • T

Type declaration

PartialBy

PartialBy<T, K>: Omit<T, K> & Partial<Pick<T, K>>

Type parameters

  • T

  • K: keyof T

ValueOf

ValueOf<T>: T[keyof T]

返回接口 T 属性值的类型。

example
type V = ValueOf<{ x: number, y: string, z: boolean }>
// => number | string | boolean

Type parameters

  • T

WechatErrorCallback

WechatErrorCallback: function

Type declaration

    • (err: any): void
    • Parameters

      • err: any

      Returns void

WechatJsApi

WechatJsApi: "checkJsApi" | "updateAppMessageShareData" | "updateTimelineShareData" | "onMenuShareTimeline" | "onMenuShareAppMessage" | "onMenuShareQQ" | "onMenuShareQZone" | "startRecord" | "stopRecord" | "onVoiceRecordEnd" | "playVoice" | "pauseVoice" | "stopVoice" | "onVoicePlayEnd" | "uploadVoice" | "downloadVoice" | "chooseImage" | "previewImage" | "uploadImage" | "downloadImage" | "translateVoice" | "getNetworkType" | "openLocation" | "getLocation" | "hideOptionMenu" | "showOptionMenu" | "hideMenuItems" | "showMenuItems" | "hideAllNonBaseMenuItem" | "showAllNonBaseMenuItem" | "closeWindow" | "scanQRCode" | "chooseWXPay" | "openProductSpecificView" | "addCard" | "chooseCard" | "openCard"

微信 JSSDK 支持的 API。

WechatNonBaseMenuItem

WechatNonBaseMenuItem: "menuItem:share:appMessage" | "menuItem:share:timeline" | "menuItem:share:qq" | "menuItem:share:weiboApp" | "menuItem:favorite" | "menuItem:share:facebook" | "menuItem:share:QZone" | "menuItem:editTag" | "menuItem:delete" | "menuItem:copyUrl" | "menuItem:originPage" | "menuItem:readMode" | "menuItem:openWithQQBrowser" | "menuItem:openWithSafari" | "menuItem:share:email" | "menuItem:share:brand"

微信内网页的非基础菜单列表。

Functions

assign

  • assign<T>(target: T, ...sources: object[]): T
  • 分配来源对象的可枚举属性到目标对象上。

    来源对象的应用规则是从左到右,随后的下一个对象的属性会覆盖上一个对象的属性。

    example
    assign(
      {},
      { x: 1 },
      { y: 2 },
      { x: 5, z: 9 },
    )
    // => { x: 5, y: 2, z: 9 }

    Type parameters

    • T: object

    Parameters

    • target: T

      目标对象

    • Rest ...sources: object[]

      来源对象序列

    Returns T

    返回扩展后的目标对象

base64Decode

  • base64Decode(input: string): string
  • 返回 base64 解码后的字符串。

    example
    base64Decode('dnRpbHM=') // => vtils
    base64Decode('5Lit5Zu9') // => 中国
    base64Decode('8J+RqOKAjfCfkrs=') // => 👨‍💻

    Parameters

    • input: string

      要解码的 base64 字符串

    Returns string

    返回解码后的字符串

base64Encode

  • base64Encode(input: string): string
  • 返回 base64 编码后的字符串。

    example
    base64Encode('vtils') // => dnRpbHM=
    base64Encode('中国') // => 5Lit5Zu9
    base64Encode('👨‍💻') // => 8J+RqOKAjfCfkrs=

    Parameters

    • input: string

      要编码的字符串

    Returns string

    返回编码后的 base64 字符串

base64UrlDecode

  • base64UrlDecode(input: string): string
  • 返回 base64url 解码后的字符串。

    see

    http://www.ietf.org/rfc/rfc4648.txt

    example
    base64UrlDecode('dnRpbHM') // => vtils
    base64UrlDecode('5Lit5Zu9') // => 中国
    base64UrlDecode('8J-RqOKAjfCfkrs') // => 👨‍💻

    Parameters

    • input: string

      要解码的 base64url 字符串

    Returns string

    返回解码后的字符串

base64UrlEncode

  • base64UrlEncode(input: string): string
  • 返回 base64url 编码后的字符串。

    see

    http://www.ietf.org/rfc/rfc4648.txt

    example
    base64UrlEncode('vtils') // => dnRpbHM
    base64UrlEncode('中国') // => 5Lit5Zu9
    base64UrlEncode('👨‍💻') // => 8J-RqOKAjfCfkrs

    Parameters

    • input: string

      要编码的字符串

    Returns string

    返回编码后的 base64url 字符串

castArray

  • castArray<T>(value: T | T[]): T[]
  • 如果 value 是数组,直接返回;如果 value 不是数组,返回 [value]

    example
    castArray([123, 456]) // => [123, 456]
    castArray(123) // => [123]
    castArray('hello') // => ['hello']
    castArray(null) // => [null]

    Type parameters

    • T

    Parameters

    • value: T | T[]

      要处理的值

    Returns T[]

    返回转换后的数组

chunk

  • chunk<T>(arr: T[], size: number, filler?: undefined | function): T[][]
  • arr 拆分成多个 size 长度的区块,并将它们组合成一个新数组返回。

    如果 arr 无法等分,且设置了 filler 函数,剩余的元素将被 filler 函数的返回值填充。

    example
    const arr = [1, 2, 3, 4, 5, 6]
    chunk(arr, 2) // => [[1, 2], [3, 4], [5, 6]]
    chunk(arr, 3) // => [[1, 2, 3], [4, 5, 6]]
    chunk(arr, 4) // => [[1, 2, 3, 4], [5, 6]]
    chunk(arr, 4, index => index) // => [[1, 2, 3, 4], [5, 6, 0, 1]]

    Type parameters

    • T

    Parameters

    • arr: T[]

      要处理的数组

    • size: number

      每个区块的长度

    • Optional filler: undefined | function

      返回填充物的函数,其接收当前填充物的索引,即第几个填充物(从 0 开始),并返回填充物

    Returns T[][]

    返回拆分后的新数组

clamp

  • clamp(value: number, min: number, max: number): number
  • 返回限制在最小值和最大值之间的值。

    example
    clamp(50, 0, 100) // => 50
    clamp(50, 0, 50) // => 50
    clamp(50, 0, 49) // => 49
    clamp(50, 51, 100) // => 51

    Parameters

    • value: number

      被限制的值

    • min: number

      最小值

    • max: number

      最大值

    Returns number

    返回结果值

combine

  • combine<K, V>(keys: K[], values: V[]): object
  • 创建一个对象,用一个数组的值作为其键名,另一个数组的值作为其值。

    example
    combine(
      [1, 'hi'],
      [0, false],
    ) // => { 1: 0, hi: false }

    Type parameters

    • K: keyof any

    • V

    Parameters

    • keys: K[]

      将被作为新对象的键

    • values: V[]

      将被作为新对象的值

    Returns object

    返回合并出的对象

createURIQuery

  • createURIQuery(parameters: AnyObject): string
  • 创建 URI 查询字符串。

    example
    createURIQuery({ x: 1, y: 'z' }) // => x=1&y=z

    Parameters

    Returns string

    返回 URI 查询字符串

debounce

  • debounce<T>(fn: T, wait: number): function
  • 创建一个去抖函数,将触发频繁的事件合并成一次执行。

    该函数被调用后,计时 wait 毫秒后调用 fn 函数。 若在 wait 毫秒内该函数再次被调用,则重新开始计时。

    一个应用场景:监听输入框的 input 事件发起网络请求。

    example
    document.querySelector('#input').oninput = debounce(
      e => {
        console.log(e.target.value)
      },
      500,
    )

    Type parameters

    Parameters

    • fn: T

      要去抖的函数

    • wait: number

      需要等待的毫秒数

    Returns function

    返回去抖后的函数

      • (...args: Parameters<T>): void
      • Parameters

        • Rest ...args: Parameters<T>

        Returns void

dedent

  • dedent(literals: TemplateStringsArray, ...interpolations: any[]): string
  • dedent(text: string): string
  • 首先,每一行紧跟前导空白的插入值为多行时,保持缩进。

    然后,移除每一行的公共前导空白。

    example
    const text = 'hello\nworld'
    dedent`
      ${text}
        -.-
    ` // => 'hello\nworld\n  -.-'

    Parameters

    • literals: TemplateStringsArray

      字面值

    • Rest ...interpolations: any[]

      插入值

    Returns string

    返回结果

  • 移除文本中每一行的公共前导空白。

    example
    dedent(`
      hello
      world
        -.-
    `) // => 'hello\nworld\n  -.-'

    Parameters

    • text: string

      要操作的文本

    Returns string

    返回操作后的文本

defaultTo

  • defaultTo<T>(value: T, defaultValue: T, extraPredictions?: any[]): T
  • 检查 value 是否是 nullundefinedNaN, 或者是否在 extraPredictions 中(若提供了 extraPredictions), 是则返回 defaultValue,否则返回 value

    example
    defaultTo(1, 2) // => 1
    defaultTo(1, 2, [1]) // => 2
    defaultTo(NaN, 2) // => 2
    defaultTo(null, 2) // => 2
    defaultTo(undefined, 2) // => 2

    Type parameters

    • T

    Parameters

    • value: T

      要检查的值

    • defaultValue: T

      默认值

    • Optional extraPredictions: any[]

      补充的判定值列表

    Returns T

    返回结果值

endsWith

  • endsWith(str: string, needle: string): boolean
  • 检查 str 是否以 needle 结尾。

    example
    endsWith('hello', 'llo') // => true
    endsWith('hello', 'he') // => false

    Parameters

    • str: string

      要检查的字符串

    • needle: string

      要检索的字符串

    Returns boolean

    strneedle 结尾返回 true,否则返回 false

entries

  • entries<T>(data: T): Array<[keyof T, T[keyof T]]>
  • 创建一个 data 对象自身可枚举属性的键值对数组,但不保证每次创建的数组顺序一致。

    example
    entries({
      x: 1,
      y: 2,
    }) // => [['x', 1], ['y', 2]]

    Type parameters

    Parameters

    • data: T

      数据对象

    Returns Array<[keyof T, T[keyof T]]>

    返回键值对数组

escapeRegExp

  • escapeRegExp(str: string): string
  • 转义正则表达式中的特殊字符。

    example
    escapeRegExp('github.com') // => 'github\\.com'

    Parameters

    • str: string

      要转换的字符串

    Returns string

    返回转换后的字符串

expectType

  • expectType<T>(value: T): void

fill

  • fill<T>(arr: T[], returnValue: FillReturnValue<T>, start?: number, end?: number): T[]
  • 使用 value 来填充(替换) arr,从 start 位置开始, 到 end 位置结束(但不包括 end 位置)。

    example
    fill(Array(5), () => 1) // => [1, 1, 1, 1, 1]
    fill(Array(3), (value, index) => index) // => [0, 1, 2]

    Type parameters

    • T

    Parameters

    • arr: T[]

      要填充改变的数组

    • returnValue: FillReturnValue<T>

      生成填充(替换)值的函数

    • Default value start: number = 0

      开始位置

    • Default value end: number = arr.length

      结束位置

    Returns T[]

    返回填充改变后的数组

flat

  • flat<T>(arr: T[][]): T[]
  • 提取数组中所有子数组的元素合并为一个新数组返回。

    example
    flat([
      [1, 2, '3'],
      ['', 0],
    ]) // => [1, 2, '3', '', 0]

    Type parameters

    • T

    Parameters

    • arr: T[][]

      要处理的数组

    Returns T[]

    返回新数组

flexible

forOwn

  • 遍历对象的可枚举属性。若遍历函数返回 false,遍历会提前退出。

    注:基于你传入的 obj,遍历函数中 key 的类型可能为 number, 但在运行时,key 始终为 string, 因此,你应该始终把 key 当作 string 处理。 (为什么会这样?https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208)

    example
    forOwn(
      { x: '1', y: 2 },
      (value, key) => {
        console.log(key, value)
      }
    )

    Type parameters

    Parameters

    Returns void

getGlobal

  • getGlobal(): any
  • 获取全局对象。

    example
    // 浏览器中
    getGlobal() // => window
    // Node 中
    getGlobal() // => global

    Returns any

    返回全局对象

getType

groupBy

  • 根据 iteratee 返回的值对 data 进行分组。

    example
    groupBy(
      [
        { type: 1, name: '石头' },
        { type: 3, name: '花生' },
        { type: 2, name: '鲸鱼' },
        { type: 1, name: '树木' },
        { type: 2, name: '鲨鱼' },
      ],
      item => item.type,
    )
    // => {
    // =>   1: [
    // =>     { type: 1, name: '石头' },
    // =>     { type: 1, name: '树木' },
    // =>   ],
    // =>   2: [
    // =>     { type: 2, name: '鲸鱼' },
    // =>     { type: 2, name: '鲨鱼' },
    // =>   ],
    // =>   3: [
    // =>     { type: 3, name: '花生' },
    // =>   ],
    // => }

    Type parameters

    • T

    • K: keyof any

    Parameters

    • data: T[]

      要分组的数据

    • iteratee: GroupByIteratee<T, K>

      迭代函数

    Returns object

    返回分组结果

has

  • has<T>(obj: T, key: LiteralUnion<T extends any[] ? never : keyof T, string | number | symbol>): boolean
  • 检查 key 是否是对象 obj 自身的属性。

    example
    const obj = { x: 1, 2: 'y' }
    has(obj, 'x') // => true
    has(obj, 2) // => true
    has(obj, 'toString') // => false

    Type parameters

    • T

    Parameters

    • obj: T

      要检查的对象

    • key: LiteralUnion<T extends any[] ? never : keyof T, string | number | symbol>

      要检查的键

    Returns boolean

    keyobj 自身的属性返回 true,否则返回 false

ii

  • ii<F>(fn: F): ReturnType<F>
  • 立即调用函数并返回其返回值。

    注:ii = immediately invoke

    example
    ii(() => 1) // => 1

    Type parameters

    Parameters

    • fn: F

      要调用的函数

    Returns ReturnType<F>

    返回被调用函数的返回值

inAndroid

  • inAndroid(callback?: undefined | function): boolean
  • 检查是否在 Android 设备中。

    example
    // Android 设备中
    inAndroid() // => true
    inAndroid(
      () => console.log('你在 Android 设备中'),
    )

    Parameters

    • Optional callback: undefined | function

      Android 设备中执行的回调

    Returns boolean

    Android 设备中返回 true,否则返回 false

inBrowser

  • inBrowser(callback?: undefined | function): boolean
  • 检查是否在浏览器环境中。

    example
    // 浏览器中
    inBrowser() // => true
    inBrowser(
      () => console.log('你在浏览器中'),
    )

    Parameters

    • Optional callback: undefined | function

      在浏览器环境中执行的回调

    Returns boolean

    在浏览器环境中返回 true,否则返回 false

inIOS

  • inIOS(callback?: undefined | function): boolean
  • 检查是否在 iOS 设备中。

    example
    // iOS 设备中
    inIOS() // => true
    inIOS(
      () => console.log('你在 iOS 设备中'),
    )

    Parameters

    • Optional callback: undefined | function

      iOS 设备中执行的回调

    Returns boolean

    iOS 设备中返回 true,否则返回 false

inNode

  • inNode(callback?: undefined | function): boolean
  • 检查是否在 Node 环境中。

    example
    // Node 中
    inNode() // => true
    inNode(
      () => console.log('你在 Node 中'),
    )

    Parameters

    • Optional callback: undefined | function

      Node 环境中执行的回调

    Returns boolean

    Node 环境中返回 true,否则返回 false

inRange

  • inRange(value: number, start: number, end: number, intervalType: InRangeIntervalType): boolean
  • 检查 value 是否在某区间内。

    example
    // 2 是否在区间 (0, 2) 内
    inRange(2, 0, 2, InRangeIntervalType.open) // => false
    
    // 2 是否在区间 [0, 2] 内
    inRange(2, 0, 2, InRangeIntervalType.closed) // => true
    
    // 2 是否在区间 [0, 2) 内
    inRange(2, 0, 2, InRangeIntervalType.leftClosedRightOpen) // => false
    
    // 2 是否在区间 (0, 2] 内
    inRange(2, 0, 2, InRangeIntervalType.leftOpenRightClosed) // => true

    Parameters

    • value: number

      要检查的值

    • start: number

      开始值

    • end: number

      结束值

    • intervalType: InRangeIntervalType

      区间类型

    Returns boolean

    value 在区间内返回 true,否则返回 false

inWechatMiniProgram

  • inWechatMiniProgram(callback?: undefined | function): boolean
  • 检查是否在微信小程序环境中。

    example
    // 微信小程序中
    inWechatMiniProgram() // => true
    inWechatMiniProgram(
      () => console.log('你在微信小程序中'),
    )

    Parameters

    • Optional callback: undefined | function

      在微信小程序环境中执行的回调

    Returns boolean

    在微信小程序环境中返回 true,否则返回 false

inWechatWebview

  • inWechatWebview(callback?: undefined | function): boolean
  • 检查是否在微信浏览器环境中。

    example
    // 微信浏览器中
    inWechatWebview() // => true
    inWechatWebview(
      () => console.log('你在微信浏览器中'),
    )

    Parameters

    • Optional callback: undefined | function

      在微信浏览器环境中执行的回调

    Returns boolean

    在微信浏览器环境返回 true,否则返回 false

includes

  • includes<T>(arr: T[], value: T): boolean
  • includes<T>(obj: T, value: ValueOf<Omit<T, symbol>>): boolean
  • includes(str: string, value: string): boolean
  • 检索值 value 是否在数组 arr 中。

    example
    includes([1, 2, 3], 1) // => true
    includes([NaN, 2, 3], NaN) // => true
    includes([1, 2, 3], 4) // => false

    Type parameters

    • T

    Parameters

    • arr: T[]

      要检索的数组

    • value: T

      要检索的值

    Returns boolean

    valuearr 中返回 true,否则返回 false

  • 检索可枚举属性值 value 是否在对象 obj 中。

    example
    includes({ x: 1, y: 2 }, 1) // => true
    includes({ x: 1, y: 2 }, 3) // => false

    Type parameters

    Parameters

    • obj: T

      要检索的对象

    • value: ValueOf<Omit<T, symbol>>

      要检索的值

    Returns boolean

    valueobj 中返回 true,否则返回 false

  • 检索值 value 是否在字符串 str 中。

    example
    includes('hello', 'h') // => true
    includes('hello', 'll') // => true
    includes('hello', '123') // => false

    Parameters

    • str: string

      要检索的字符串

    • value: string

      要检索的值

    Returns boolean

    valuestr 中返回 true,否则返回 false

indent

  • indent(literals: TemplateStringsArray, ...interpolations: any[]): string
  • indent(text: string, leadingString: string): string
  • indent(text: string, callback: function): string
  • 每一行紧跟前导空白的插入值为多行时,保持缩进。

    example
    const text = 'hello\nworld'
    indent`  ${text}` // => '  hello\n  world'

    Parameters

    • literals: TemplateStringsArray

      字面值

    • Rest ...interpolations: any[]

      插入值

    Returns string

    返回结果

  • 给文本每一行的开始加上一个前导字符串。

    example
    indent('hello\nworld', '-> ')
    // => '-> hello\n-> world'

    Parameters

    • text: string

      要操作的文本

    • leadingString: string

      前导字符串

    Returns string

    返回结果

  • 给文本每一行的开始加上一个前导字符串,前导字符串由回调函数返回。

    example
    indent(
      'hello\nworld',
      (lineStr, lineIndex) => `${lineIndex + 1}. `,
    )
    // => '1. hello\n2. world'

    Parameters

    • text: string

      要操作的文本

    • callback: function

      回调函数

        • (lineString: string, lineIndex: number): string
        • Parameters

          • lineString: string
          • lineIndex: number

          Returns string

    Returns string

    返回结果

isArguments

  • isArguments(value: any): boolean
  • 检查 value 是否是一个 arguments 对象。

    example
    function myFunction() {
      console.log(isArguments(arguments)) // true
    }

    Parameters

    • value: any

      要检查的值

    Returns boolean

    valuearguments 对象返回 true,否则返回 false

isArray

  • isArray(value: any): boolean
  • 检查 value 是否是一个数组。

    example
    isArray(['x']) // => true
    isArray('x') // => false

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是数组返回 true,否则返回 false

isBoolean

  • isBoolean(value: any): boolean
  • 检查 value 是否是一个布尔值。

    example
    isBoolean(true) // => true
    isBoolean(false) // => true
    isBoolean('true') // => false

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是布尔值返回 true,否则返回 false

isChineseIDCardNumber

  • isChineseIDCardNumber(value: string): boolean

isDate

  • isDate(value: any): boolean
  • 检查 value 是否是一个日期。

    example
    isDate(new Date()) // => true

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是日期返回 true,否则返回 false

isEmail

  • isEmail(value: string): boolean
  • 检查 value 是否是一个邮件地址。

    see

    http://emailregex.com/

    example
    isEmail('hello@foo.bar') // => true
    isEmail('hello@foo') // => false

    Parameters

    • value: string

      要检查的值

    Returns boolean

    value 是邮件地址返回 true,否则返回 false

isEmpty

  • isEmpty(value: any): boolean
  • 检查 value 是否是空值,包括:undefinednull''falsetrue[]{}

    example
    isEmpty(undefined) // => true
    isEmpty(null) // => true
    isEmpty('') // => true
    isEmpty(false) // => true
    isEmpty(true) // => true
    isEmpty([]) // => true
    isEmpty({}) // => true

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是空值返回 true,否则返回 false

isEqualArray

  • isEqualArray(...arrs: any[][]): boolean
  • 检查给定的数组的各项是否相等。

    example
    isEqualArray([1], [1]) // => true
    isEqualArray([1], [5]) // => false

    Parameters

    • Rest ...arrs: any[][]

      要检查的数组

    Returns boolean

    给定的数组的各项都相等返回 true,否则返回 false

isFinite

  • isFinite(value: any): boolean
  • 检查 value 是否是原始有限数值。

    example
    isFinite(1) // => true
    isFinite(Infinity) // => false

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是原始有限数值返回 true,否则返回 false

isFunction

  • isFunction(value: any): boolean
  • 检查 value 是否是一个函数。

    example
    isFunction(() => {}) // => true
    isFunction(2000) // => false

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是函数返回 true,否则返回 false

isHan

  • isHan(value: string): boolean
  • 检查 value 是否全是汉字。

    example
    isHan('hello') // => false
    isHan('嗨咯') // => true

    Parameters

    • value: string

      要检查的值

    Returns boolean

    value 全是汉字返回 true,否则返回 false

isInteger

  • isInteger(value: any): boolean
  • 检查 value 是否是一个整数。

    example
    isInteger(1) // => true
    isInteger(1.2) // => false
    isInteger(-1) // => true

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是整数返回 true,否则返回 false

isNaN

  • isNaN(value: any): boolean
  • 检查 value 是否是 NaN

    example
    isNaN(NaN) // => true
    isNaN(2) // => false

    Parameters

    • value: any

      要检查的值

    Returns boolean

    valueNaN 返回 true,否则返回 false

isNegativeInteger

  • isNegativeInteger(value: any): boolean
  • 检查 value 是否是一个负整数。

    example
    isNegativeInteger(-1) // => true
    isNegativeInteger(1) // => false

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是负整数返回 true,否则返回 false

isNil

  • isNil(value: any): boolean
  • 检查 value 是否是 nullundefined

    example
    isNil(null) // => true
    isNil(undefined) // => true

    Parameters

    • value: any

      要检查的值

    Returns boolean

    valuenullundefined 返回 true,否则返回 false

isNull

  • isNull(value: any): boolean
  • 检查 value 是否是 null

    example
    isNull(null) // => true

    Parameters

    • value: any

      要检查的值

    Returns boolean

    valuenull 返回 true,否则返回 false

isNumber

  • isNumber(value: any): boolean
  • 检查 value 是否是一个数字。

    注:NaN 不被认为是数字。

    example
    isNumber(1) // => true
    isNumber(0.1) // => true
    isNumber(NaN) // => false

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是数字返回 true,否则返回 false

isNumeric

  • isNumeric(value: any): boolean
  • 检查 value 是否是一个数值。

    注:Infinity-InfinityNaN 不被认为是数值。

    example
    isNumeric(1) // => true
    isNumeric('1') // => true

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是数值返回 true,否则返回 false

isObject

  • isObject(value: any): boolean
  • 检查 value 是否是一个对象。

    example
    isObject({}) // => true
    isObject(() => {}) // => true
    isObject(null) // => false

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是对象返回 true,否则返回 false

isPlainObject

  • isPlainObject(value: any): boolean
  • 检查 value 是否是一个普通对象。

    example
    isPlainObject({}) // => true
    isPlainObject(Object.create(null)) // => true
    isPlainObject(() => {}) // => false

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是普通对象返回 true,否则返回 false

isPositiveInteger

  • isPositiveInteger(value: any): boolean
  • 检查 value 是否是一个正整数。

    example
    isPositiveInteger(1) // => true
    isPositiveInteger(-1) // => false

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是正整数返回 true,否则返回 false

isPossibleChineseMobilePhoneNumber

  • isPossibleChineseMobilePhoneNumber(number: number | string): boolean
  • 检测 number 是否可能是中国的手机号码。

    example
    isPossibleChineseMobilePhoneNumber(18000030000) // => true
    isPossibleChineseMobilePhoneNumber(10086) // => false

    Parameters

    • number: number | string

      要检测的号码

    Returns boolean

    number 可能是中国的手机号码返回 true,否则返回 false

isPossibleChineseName

  • isPossibleChineseName(value: string): boolean
  • 检测 value 是否可能是中国人的姓名,支持少数名族姓名中间的 · 号。

    example
    isPossibleChineseName('鲁') // => false
    isPossibleChineseName('鲁迅') // => true
    isPossibleChineseName('买买提·吐尔逊') // => true

    Parameters

    • value: string

      要检测的值

    Returns boolean

    value 可能是中国人的姓名返回 true,否则返回 false

isPromiseLike

  • isPromiseLike(value: any): boolean
  • 检查 value 是否像 Promise

    example
    isPromiseLike(Promise.resolve()) // => true

    Parameters

    • value: any

      要检查的值

    Returns boolean

    valuePromise 返回 true,否则返回 false

isRegExp

  • isRegExp(value: any): boolean
  • 检查 value 是否是一个正则对象。

    example
    isRegExp(/hello/) // => true
    isRegExp(new RegExp('hello')) // => true

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是正则对象返回 true,否则返回 false

isString

  • isString(value: any): boolean
  • 检查 value 是否是一个字符串。

    example
    isString('') // => true
    isString('hello') // => true

    Parameters

    • value: any

      要检查的值

    Returns boolean

    value 是字符串返回 true,否则返回 false

isUndefined

  • isUndefined(value: any): boolean
  • 检查 value 是否等于 undefined

    example
    isUndefined(undefined) // => true
    isUndefined(void 0) // => true

    Parameters

    • value: any

      要检查的值

    Returns boolean

    valueundefined 返回 true,否则返回 false

isUrl

  • isUrl(value: string): boolean
  • 检查 value 是否是一个有效的网址,仅支持 httphttps 协议,支持 IP 域名。

    see

    http://urlregex.com/

    example
    isUrl('http://foo.bar') // => true
    isUrl('https://foo.bar/home') // => true

    Parameters

    • value: string

      要检查的值

    Returns boolean

    value 是有效的网址返回 true,否则返回 false

jestExpectEqual

  • jestExpectEqual<T>(actual: T, ...expected: T[]): void
  • 这是一个 jest 测试辅助函数,等同于 expect(actual).toEqual(expected),只不过是加上了类型。

    Type parameters

    • T

    Parameters

    • actual: T

      测试值

    • Rest ...expected: T[]

      期望值列表

    Returns void

keyBy

  • 根据 iteratee 返回的键对 data 进行分组,但只保留最后一个结果。

    example
    keyBy(
      [
        { type: 1, name: '石头' },
        { type: 3, name: '花生' },
        { type: 2, name: '鲸鱼' },
        { type: 1, name: '树木' },
        { type: 2, name: '鲨鱼' },
      ],
      item => item.type,
    )
    // => {
    // =>   1: { type: 1, name: '树木' },
    // =>   2: { type: 2, name: '鲨鱼' },
    // =>   3: { type: 3, name: '花生' },
    // => }

    Type parameters

    • T: any

    • K: keyof any

    Parameters

    • data: T[]

      要分组的数据

    • iteratee: KeyByIteratee<T, K>

      迭代函数

    Returns object

    返回分组结果

keys

  • keys<T>(obj: T): (string & object | number & object | Extract<keyof T, string | number>)[]
  • 返回 obj 的可枚举属性组成的数组。

    注:基于你传入的 obj,返回的 key 的类型可能为 number, 但在运行时,key 始终为 string, 因此,你应该始终把 key 当作 string 处理。 (为什么会这样?https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208)

    example
    keys({ x: 1, 2: 'y' }) // => ['x', '2'] 或 ['2', 'x']

    Type parameters

    Parameters

    • obj: T

      对象

    Returns (string & object | number & object | Extract<keyof T, string | number>)[]

    返回结果数组

last

  • last<T>(arr: T[]): If<IsNever<T>, undefined, T | undefined>
  • 返回数组 arr 的最后一项。

    example
    last([1, 2, 3]) // => 3

    Type parameters

    • T

    Parameters

    • arr: T[]

      数组

    Returns If<IsNever<T>, undefined, T | undefined>

    返回数组的最后一项

loadResource

  • loadResource(url: string | LoadResourceUrl | Array<string | LoadResourceUrl>): Promise<Array<HTMLScriptElement | HTMLLinkElement | HTMLImageElement>>
  • 加载图片、代码、样式等资源。

    example
    loadResource([
      'https://foo.bar/all.js',
      'https://foo.bar/all.css',
      'https://foo.bar/logo.png',
      {
        type: LoadResourceUrlType.js,
        path: 'https://s1.foo.bar/js/full',
        alternatePath: 'https://s2.foo.bar/js/full',
      },
    ]).then(() => {
      // 资源加载完成后的操作
    })

    Parameters

    Returns Promise<Array<HTMLScriptElement | HTMLLinkElement | HTMLImageElement>>

    返回各个资源的 HTMLElement 对象组成的数组

loop

  • loop(interval: number, callback: function): (Anonymous function)
  • 每隔 interval 毫秒执行一次 callback

    example
    // 每隔 1000 毫秒输出一次 hello
    const stop = loop(
      1000,
      () => console.log('hello'),
    )

    Parameters

    • interval: number

      间隔时间(毫秒)

    • callback: function

      回调

        • (...args: any[]): any
        • Parameters

          • Rest ...args: any[]

          Returns any

    Returns (Anonymous function)

    返回停止执行的函数

mapValues

  • 映射对象的可枚举属性值为一个新的值。

    example
    mapValues(
      { x: 1, y: 2 },
      value => value + 10,
    )
    // => { x: 11, y: 12 }

    Type parameters

    Parameters

    Returns object

    返回映射后的新对象

memoize

  • 函数结果缓存。

    example
    let i = 0
    const fn = memoize(() => i++)
    fn() // => 0
    fn() // => 0

    Type parameters

    Parameters

    • fn: T

      要缓存的函数

    • Default value options: MemoizeOptions<T> = {}

      选项

    Returns MemoizeReturn<T>

    返回缓存化后的函数

noop

  • noop(...args: any[]): any
  • 无操作函数。

    example
    noop() // => undefined

    Parameters

    • Rest ...args: any[]

    Returns any

omit

  • omit<T, K>(obj: T, props: K[]): object
  • 创建一个从 obj 中剔除选中的可枚举属性的对象。

    example
    omit({ x: 1, y: 2 }, ['x']) // => { y: 2 }

    Type parameters

    • T: AnyObject

    • K: Extract<keyof T, string | number>

    Parameters

    • obj: T

      来源对象

    • props: K[]

      要剔除的可枚举属性

    Returns object

    返回结果对象

orderBy

  • 允许指定一个或多个规则对数据进行排序。

    example
    orderBy(
      ['x', 'xyz', 'xy'],
      {
        iteratee: item => item.length,
        type: OrderByRuleType.desc,
      },
    )
    // => ['xyz', 'xy', 'x']

    Type parameters

    • T

    Parameters

    Returns T[]

    返回排序后的数据

padEnd

  • padEnd(str: string, length: number, chars?: string): string
  • str 右侧填充字符。

    example
    padEnd('姓名', 4, '*') // => 姓名**

    Parameters

    • str: string

      要填充的字符串

    • length: number

      目标长度

    • Default value chars: string = " "

      填充字符

    Returns string

    返回填充后的字符串

padStart

  • padStart(str: string, length: number, chars?: string): string
  • str 左侧填充字符。

    example
    padStart('姓名', 4, '*') // => **姓名

    Parameters

    • str: string

      要填充的字符串

    • length: number

      目标长度

    • Default value chars: string = " "

      填充字符

    Returns string

    返回填充后的字符串

parallel

  • parallel<T, R>(tasks: T[]): Promise<R[]>
  • 并行执行任务,同步任务异步任务 皆可。

    example
    parallel([
      () => 1,
      async () => 'hello',
    ]).then(res => {
      // => [1, 'hello']
    })

    Type parameters

    • T: AnyFunction

    • R: T extends (...args: any) => Promise<infer X> ? X : T extends (...args: any) => infer Y ? Y : any

    Parameters

    • tasks: T[]

      要执行的任务列表

    Returns Promise<R[]>

    返回全部任务执行结果组成的数组

parseCSSValue

  • parseCSSValue(value: string | number, defaultUnit?: string): CSSValue
  • 解析 CSS 值的数值和单位。

    example
    parseCSSValue('12px') // => { value: 12, unit: 'px' }
    parseCSSValue(12) // => { value: 12, unit: 'px' }
    parseCSSValue('12%') // => { value: 12, unit: '%' }

    Parameters

    • value: string | number

      要解析的值

    • Default value defaultUnit: string = "px"

      默认单位

    Returns CSSValue

    返回解析结果

parseURIQuery

  • 解析 URI 查询字符串。

    兼容以 ? 开头的查询字符串,因此你可以直接传入 location.search 的值。

    example
    parseURIQuery('x=1&y=z') // => { x: '1', y: 'z' }
    parseURIQuery('?x=1&y=z') // => { x: '1', y: 'z' }
    parseURIQuery(
      'x=1&y=z',
      parameters => ({
        ...parameters,
        x: Number(parameters.x),
      }),
    ) // => { x: 1, y: 'z' }

    Type parameters

    • T: Record<string, any>

    Parameters

    Returns T

    返回 URI 查询参数

partial

  • partial<T>(obj: T): Partial<T>
  • TypeScript 中 Partial 的函数版本。

    example
    partial({ x: 1 } as const) // => { x?: number }

    Type parameters

    Parameters

    • obj: T

      Partial 的对象

    Returns Partial<T>

    原封不动地返回对象,但对其类型进行了 Partial 操作

partialBy

  • partialBy<T, K>(obj: T, keys: K[]): PartialBy<T, K>
  • TypeScript 中 PartialBy 的函数版本。

    example
    partialBy(
      { x: 1, y: 2 } as const,
      ['x'],
    ) // => { x?: number, y: number }

    Type parameters

    Parameters

    • obj: T

      PartialBy 的对象

    • keys: K[]

    Returns PartialBy<T, K>

    原封不动地返回对象,但对其类型进行了 PartialBy 操作

pick

  • pick<T, K>(obj: T, props: K[]): object
  • 创建一个从 obj 中选中的可枚举属性的对象。

    example
    pick({ x: 1, y: 2 }, ['x']) // => { x: 1 }

    Type parameters

    • T: AnyObject

    • K: Extract<keyof T, string | number>

    Parameters

    • obj: T

      来源对象

    • props: K[]

      选中的可枚举属性

    Returns object

    返回结果对象

placeKitten

  • placeKitten(size: number): string
  • placeKitten(width: number, height: number): string
  • 给定大小获取占位猫咪图片,图片来自:https://placekitten.com/

    example
    placeKitten(100) // => https://placekitten.com/100/100

    Parameters

    • size: number

      占位图片大小(单位:px)

    Returns string

    返回占位图片链接

  • 给定宽高获取占位猫咪图片,图片来自:https://placekitten.com/

    example
    placeKitten(100, 200) // => https://placekitten.com/100/200

    Parameters

    • width: number

      占位图片宽(单位:px)

    • height: number

      占位图片高(单位:px)

    Returns string

    返回占位图片链接

pluck

  • 将数据中每一项的迭代值组合成一个数组返回。

    example
    pluck(
      [{ id: 1, name: 'Jay' }, { id: 2, name: 'Lily' }],
      item => item.name,
    ) // => ['Jay', 'Lily']

    Type parameters

    • T

    • V

    Parameters

    Returns V[]

    返回结果数组

  • 将数据中每一项的迭代值组合成一个对象返回。

    example
    pluck(
      [{ id: 1, name: 'Jay' }, { id: 2, name: 'Lily' }],
      item => item.name,
      item => item.id,
    ) // => { 1: 'Jay', 2: 'Lily' }

    Type parameters

    • T

    • V

    • K: keyof any

    Parameters

    Returns Record<K, V>

    返回结果对象

randomString

  • randomString(): string
  • 生成一个随机字符串。

    example
    randomString() // => m481rnmse1m

    Returns string

    返回生成的随机字符串

range

  • range(start: number, end: number, step?: number): number[]
  • 创建一个包含从 startend,但不包含 end 本身范围数字的数组。

    example
    range(0, 5) // => [0, 1, 2, 3, 4]
    range(0, -5, -1) // => [0, -1, -2, -3, -4]

    Parameters

    • start: number

      开始数字

    • end: number

      结束数字

    • Default value step: number = 1

      步进值

    Returns number[]

    返回开始到结束范围内数字组成的数组

remove

  • remove<T>(data: T, index: number): T
  • 根据索引原地删除数组中指定的值。

    example
    remove([1, 2, 3], 1) // => [1, 3]

    Type parameters

    • T: any[]

    Parameters

    • data: T

      要操作的数组

    • index: number

      要删除值的索引

    Returns T

    返回传入的数组

removeByValue

  • removeByValue<V>(data: V[], value: V): V[]
  • 原地删除数组中第一次出现的指定值。

    example
    removeByValue([1, 2, 3], 1) // => [2, 3]

    Type parameters

    • V

    Parameters

    • data: V[]

      要操作的数组

    • value: V

      要删除的值

    Returns V[]

    返回传入的数组

repeat

  • repeat(str: string, n: number): string
  • 重复 n 次给定字符串。

    example
    repeat('a', 5) // => aaaaa

    Parameters

    • str: string

      要重复的字符串

    • n: number

      重复的次数

    Returns string

    返回结果字符串

result

  • result<T>(action: T): Promise<[any, T extends PromiseLike<infer R> ? R : any]>
  • result<T, R>(action: T): Promise<[any, R extends PromiseLike<any> ? R extends PromiseLike<infer RR> ? RR : any : R]>
  • 以数组的方式返回异步操作的结果。

    example
    // 异步操作成功
    const [err, res] = await result(new Promise(resolve => resolve('ok'))) // => [null, 'ok']
    
    // 异步操作出错
    const [err, res] = await result(new Promise((resolve, reject) => reject('err'))) // => ['err']

    Type parameters

    • T: PromiseLike<any>

    Parameters

    • action: T

      要执行的异步操作

    Returns Promise<[any, T extends PromiseLike<infer R> ? R : any]>

    返回 [错误信息, 结果数据],错误信息为 null 表示没有错误

  • 以数组的方式返回函数执行的结果,如果函数返回一个异步操作,将会执行该异步操作并将其结果作为函数执行的结果返回。

    example
    // 函数执行成功
    const [err, res] = await result(() => 'ok') // => [null, 'ok']
    const [err, res] = await result(() => new Promise(resolve => resolve('ok'))) // => [null, 'ok']
    
    // 函数执行出错
    const [err, res] = await result(() => { throw 'err' }) // => ['err']
    const [err, res] = await result(() => new Promise((resolve, reject) => reject('err'))) // => ['err']

    Type parameters

    • T: function

    • R: ReturnType<T>

    Parameters

    • action: T

      要执行的函数

    Returns Promise<[any, R extends PromiseLike<any> ? R extends PromiseLike<infer RR> ? RR : any : R]>

    返回 [错误信息, 结果数据],错误信息为 null 表示没有错误

round

  • round(number: number, precision?: number): number
  • 对传入的数字按给定的精度四舍五入后返回。

    example
    round(3.456) // => 3
    round(3.456, 1) // => 3.5
    round(3.456, 2) // => 3.46
    round(345, -2) // => 300

    Parameters

    • number: number

      传入的数字

    • Default value precision: number = 0

      精度

    Returns number

    返回结果

roundDown

  • roundDown(number: number, precision?: number): number
  • 对传入的数字按给定的精度向下取值后返回。

    example
    roundDown(3.456) // => 3
    roundDown(3.456, 1) // => 3.4
    roundDown(3.456, 2) // => 3.45
    roundDown(345, -2) // => 300

    Parameters

    • number: number

      传入的数字

    • Default value precision: number = 0

      精度

    Returns number

    返回结果

roundUp

  • roundUp(number: number, precision?: number): number
  • 对传入的数字按给定的精度向上取值后返回。

    example
    roundUp(3.456) // => 4
    roundUp(3.456, 1) // => 3.5
    roundUp(3.456, 2) // => 3.46
    roundUp(345, -2) // => 400

    Parameters

    • number: number

      传入的数字

    • Default value precision: number = 0

      精度

    Returns number

    返回结果

safeGet

  • safeGet<T, K0>(obj: T, k0: K0): T[K0]
  • safeGet<T, K0, K1>(obj: T, k0: K0, k1: K1): T[K0][K1]
  • safeGet<T, K0, K1, K2>(obj: T, k0: K0, k1: K1, k2: K2): T[K0][K1][K2]
  • safeGet<T, K0, K1, K2, K3>(obj: T, k0: K0, k1: K1, k2: K2, k3: K3): T[K0][K1][K2][K3]
  • safeGet<T, K0, K1, K2, K3, K4>(obj: T, k0: K0, k1: K1, k2: K2, k3: K3, k4: K4): T[K0][K1][K2][K3][K4]
  • safeGet<T, K0, K1, K2, K3, K4, K5>(obj: T, k0: K0, k1: K1, k2: K2, k3: K3, k4: K4, k5: K5): T[K0][K1][K2][K3][K4][K5]
  • safeGet<T, K0, K1, K2, K3, K4, K5, K6>(obj: T, k0: K0, k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): T[K0][K1][K2][K3][K4][K5][K6]
  • safeGet<T, K0, K1, K2, K3, K4, K5, K6, K7>(obj: T, k0: K0, k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6, k7: K7): T[K0][K1][K2][K3][K4][K5][K6][K7]
  • safeGet<T, K0, K1, K2, K3, K4, K5, K6, K7, K8>(obj: T, k0: K0, k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6, k7: K7, k8: K8): T[K0][K1][K2][K3][K4][K5][K6][K7][K8]
  • safeGet<T, K0, K1, K2, K3, K4, K5, K6, K7, K8, K9>(obj: T, k0: K0, k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6, k7: K7, k8: K8, k9: K9): T[K0][K1][K2][K3][K4][K5][K6][K7][K8][K9]
  • Type parameters

    Parameters

    • obj: T
    • k0: K0

    Returns T[K0]

  • Type parameters

    Parameters

    • obj: T
    • k0: K0
    • k1: K1

    Returns T[K0][K1]

  • Type parameters

    • T: AnyObject

    • K0: keyof T

    • K1: keyof T[K0]

    • K2: keyof T[K0][K1]

    Parameters

    • obj: T
    • k0: K0
    • k1: K1
    • k2: K2

    Returns T[K0][K1][K2]

  • Type parameters

    • T: AnyObject

    • K0: keyof T

    • K1: keyof T[K0]

    • K2: keyof T[K0][K1]

    • K3: keyof T[K0][K1][K2]

    Parameters

    • obj: T
    • k0: K0
    • k1: K1
    • k2: K2
    • k3: K3

    Returns T[K0][K1][K2][K3]

  • Type parameters

    • T: AnyObject

    • K0: keyof T

    • K1: keyof T[K0]

    • K2: keyof T[K0][K1]

    • K3: keyof T[K0][K1][K2]

    • K4: keyof T[K0][K1][K2][K3]

    Parameters

    • obj: T
    • k0: K0
    • k1: K1
    • k2: K2
    • k3: K3
    • k4: K4

    Returns T[K0][K1][K2][K3][K4]

  • Type parameters

    • T: AnyObject

    • K0: keyof T

    • K1: keyof T[K0]

    • K2: keyof T[K0][K1]

    • K3: keyof T[K0][K1][K2]

    • K4: keyof T[K0][K1][K2][K3]

    • K5: keyof T[K0][K1][K2][K3][K4]

    Parameters

    • obj: T
    • k0: K0
    • k1: K1
    • k2: K2
    • k3: K3
    • k4: K4
    • k5: K5

    Returns T[K0][K1][K2][K3][K4][K5]

  • Type parameters

    • T: AnyObject

    • K0: keyof T

    • K1: keyof T[K0]

    • K2: keyof T[K0][K1]

    • K3: keyof T[K0][K1][K2]

    • K4: keyof T[K0][K1][K2][K3]

    • K5: keyof T[K0][K1][K2][K3][K4]

    • K6: keyof T[K0][K1][K2][K3][K4][K5]

    Parameters

    • obj: T
    • k0: K0
    • k1: K1
    • k2: K2
    • k3: K3
    • k4: K4
    • k5: K5
    • k6: K6

    Returns T[K0][K1][K2][K3][K4][K5][K6]

  • Type parameters

    • T: AnyObject

    • K0: keyof T

    • K1: keyof T[K0]

    • K2: keyof T[K0][K1]

    • K3: keyof T[K0][K1][K2]

    • K4: keyof T[K0][K1][K2][K3]

    • K5: keyof T[K0][K1][K2][K3][K4]

    • K6: keyof T[K0][K1][K2][K3][K4][K5]

    • K7: keyof T[K0][K1][K2][K3][K4][K5][K6]

    Parameters

    • obj: T
    • k0: K0
    • k1: K1
    • k2: K2
    • k3: K3
    • k4: K4
    • k5: K5
    • k6: K6
    • k7: K7

    Returns T[K0][K1][K2][K3][K4][K5][K6][K7]

  • Type parameters

    • T: AnyObject

    • K0: keyof T

    • K1: keyof T[K0]

    • K2: keyof T[K0][K1]

    • K3: keyof T[K0][K1][K2]

    • K4: keyof T[K0][K1][K2][K3]

    • K5: keyof T[K0][K1][K2][K3][K4]

    • K6: keyof T[K0][K1][K2][K3][K4][K5]

    • K7: keyof T[K0][K1][K2][K3][K4][K5][K6]

    • K8: keyof T[K0][K1][K2][K3][K4][K5][K6][K7]

    Parameters

    • obj: T
    • k0: K0
    • k1: K1
    • k2: K2
    • k3: K3
    • k4: K4
    • k5: K5
    • k6: K6
    • k7: K7
    • k8: K8

    Returns T[K0][K1][K2][K3][K4][K5][K6][K7][K8]

  • Type parameters

    • T: AnyObject

    • K0: keyof T

    • K1: keyof T[K0]

    • K2: keyof T[K0][K1]

    • K3: keyof T[K0][K1][K2]

    • K4: keyof T[K0][K1][K2][K3]

    • K5: keyof T[K0][K1][K2][K3][K4]

    • K6: keyof T[K0][K1][K2][K3][K4][K5]

    • K7: keyof T[K0][K1][K2][K3][K4][K5][K6]

    • K8: keyof T[K0][K1][K2][K3][K4][K5][K6][K7]

    • K9: keyof T[K0][K1][K2][K3][K4][K5][K6][K7][K8]

    Parameters

    • obj: T
    • k0: K0
    • k1: K1
    • k2: K2
    • k3: K3
    • k4: K4
    • k5: K5
    • k6: K6
    • k7: K7
    • k8: K8
    • k9: K9

    Returns T[K0][K1][K2][K3][K4][K5][K6][K7][K8][K9]

sample

  • sample<T>(arr: T[]): T
  • sample<T>(obj: T): Extract<T[keyof T], string | number>
  • 从数组中随机获取一个元素。

    example
    sample([1, 2, 3]) // => 1 或 2 或 3

    Type parameters

    • T

    Parameters

    • arr: T[]

      要取样的数组

    Returns T

    返回随机获取的元素

  • 从对象中随机获取一个可枚举属性的值。

    example
    sample({ x: 1, y: 2, z: 3 }) // => 1 或 2 或 3

    Type parameters

    Parameters

    • obj: T

      要取样的对象

    Returns Extract<T[keyof T], string | number>

    返回随机获取的可枚举属性的值

sequential

  • sequential<T, R>(tasks: T[]): Promise<unknown>
  • 顺序执行任务,同步任务异步任务 皆可。

    example
    sequential([
      () => 1,
      async () => 'hello',
    ]).then(res => {
      // => [1, 'hello']
    })

    Type parameters

    • T: function

    • R: T extends (...args: any) => Promise<infer X> ? X : T extends (...args: any) => infer Y ? Y : any

    Parameters

    • tasks: T[]

      要执行的任务列表

    Returns Promise<unknown>

    返回全部任务执行结果组成的数组

shuffle

  • shuffle<T>(arr: T[]): T[]

startsWith

  • startsWith(str: string, needle: string): boolean
  • 检查 str 是否以 needle 开头。

    example
    startsWith('hello', 'he') // => true
    startsWith('hello', 'llo') // => false

    Parameters

    • str: string

      要检查的字符串

    • needle: string

      要检索的字符串

    Returns boolean

    strneedle 开头返回 true,否则返回 false

sum

  • sum(...numbers: Array<number | number[]>): number
  • 计算传入值的总和。

    example
    sum([1, 2, 3]) // => 6

    Parameters

    • Rest ...numbers: Array<number | number[]>

      传入的数字

    Returns number

    返回传入值的总和

sumBy

  • 根据 iteratee 返回的结果计算传入值的总和。

    example
    sumBy(
      [
        { count: 1 },
        { count: 2 },
        { count: 3 },
      ],
      item => item.count,
    )
    // => 6

    Type parameters

    • T

    Parameters

    • array: T[]

      传入的数组

    • iteratee: SumByIteratee<T>

      迭代函数

    Returns number

    返回总和

throttle

  • throttle<T>(fn: T, wait: number): function
  • 创建一个节流函数,给函数设置固定的执行速率。

    • 该函数首次被调用时,会立即调用 fn 函数,并记录首次调用时间。
      • 该函数第二次被调用时:
        • 如果该次调用时间在首次调用时间的 wait 区间内,timer = setTimeout(操作, 时间差)
          • 该函数再次被调用时:
            • 如果该次调用时间在首次调用时间的 wait 区间内,什么都不做;
            • 否则,清除首次调用时间和计时器,回到第一步。
        • 否则,清除首次调用时间,回到第一步。

    一个应用场景:监听窗口的 resize 事件响应相关操作。

    example
    window.addEventListener(
      'resize',
      throttle(
        () => console.log('窗口大小改变后的操作'),
        1000,
      ),
    )

    Type parameters

    Parameters

    • fn: T

      要节流的函数

    • wait: number

      需要等待的毫秒数

    Returns function

    返回节流后的函数

      • (...args: Parameters<T>): void
      • Parameters

        • Rest ...args: Parameters<T>

        Returns void

times

  • times<T>(n: number, fn: T): Array<ReturnType<T>>
  • 调用函数 n 次,将每次的调用结果存进数组并返回。

    example
    times(4, () => {
      // 这里将会执行 4 次
    })

    Type parameters

    • T: function

    Parameters

    • n: number

      调用次数

    • fn: T

      调用函数

    Returns Array<ReturnType<T>>

    返回每次的调用结果组成的数组

tryGet

  • 尝试执行 accessor 返回值,若其报错,返回默认值 defaultValue

    example
    const obj = { x: 1 }
    tryGet(() => obj.x, 2) // => 1
    tryGet(() => obj.x.y, 2) // => 2

    Type parameters

    • R

    Parameters

    Returns R

    返回结果值

  • 尝试执行 accessor 返回值,若其报错,返回 undefined

    example
    const obj = { x: 1 }
    tryGet(() => obj.x) // => 1
    tryGet(() => obj.x.y) // => undefined

    Type parameters

    • R

    Parameters

    Returns R | undefined

    返回结果值

unique

  • unique<T>(arr: T[]): T[]
  • 将给定的数组去重后返回。

    example
    unique([1, 2, 1, 3]) // => [1, 2, 3]

    Type parameters

    • T

    Parameters

    • arr: T[]

      要去重的数组

    Returns T[]

    返回去重后的数组

values

  • values<T>(obj: T): T[Extract<keyof T, string | number>][]
  • 返回 obj 自身可枚举属性值组成的数组。

    example
    values({ x: 1, 2: 'y' }) // => [1, 'y'] 或 ['y', 1]

    Type parameters

    Parameters

    • obj: T

      要检索的对象

    Returns T[Extract<keyof T, string | number>][]

    返回结果数组

wait

  • 等待一段时间。

    example
    wait(1000).then(() => {
      // 等待 1000 毫秒后执行
    })

    Parameters

    • milliseconds: number

      等待时间(单位:毫秒

    Returns WaitReturn

Legend

  • Module
  • Object literal
  • Variable
  • Function
  • Function with type parameter
  • Index signature
  • Type alias
  • Type alias with type parameter
  • Enumeration
  • Enumeration member
  • Property
  • Method
  • Interface
  • Interface with type parameter
  • Constructor
  • Property
  • Method
  • Index signature
  • Class
  • Class with type parameter
  • Constructor
  • Property
  • Method
  • Accessor
  • Index signature
  • Inherited constructor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Protected property
  • Protected method
  • Protected accessor
  • Private property
  • Private method
  • Private accessor
  • Static property
  • Static method

Generated using TypeDoc