expectTypeOf

警告

在运行时，此函数不会执行任何操作。要启用类型检查，请不要忘记传递--typecheck标志。

• 类型： <T>(a: unknown) => ExpectTypeOf

not

• 类型： ExpectTypeOf

您可以使用.not属性否定所有断言。

toEqualTypeOf

• 类型： <T>(expected: T) => void

此匹配器将检查类型是否完全相等。如果两个对象具有不同的值但类型相同，此匹配器不会失败。但是，如果一个对象缺少属性，它将失败。

import {  } from 'vitest'

({ : 1 }).<{ : number }>()
({ : 1 }).({ : 1 })
({ : 1 }).({ : 2 })
({ : 1, : 1 })..<{ : number }>()

toMatchTypeOf

• 类型： <T>(expected: T) => void

此匹配器检查期望类型是否扩展了提供的类型。它与toEqual不同，更类似于expect 的toMatchObject()。使用此匹配器，您可以检查对象是否“匹配”类型。

import {  } from 'vitest'

({ : 1, : 1 }).({ : 1 })
<number>().<string | number>()
<string | number>()..<number>()

extract

• 类型： ExpectTypeOf<ExtractedUnion>

您可以使用.extract来缩小类型以进行进一步测试。

import {  } from 'vitest'

type <> =  | [] | { ?: ; ?: ; ?:  }

interface CSSProperties { ?: string; ?: string }

function <>(: ): <> {
  return {}
}

const : CSSProperties = { : '1px', : '2px' }

(())
  .<{ ?: any }>() // extracts the last type from a union
  .<{ ?: CSSProperties; ?: CSSProperties; ?: CSSProperties }>()

(())
  .<unknown[]>() // extracts an array from a union
  .<CSSProperties[]>()

警告

如果在联合中找不到类型，.extract将返回never。

exclude

• 类型： ExpectTypeOf<NonExcludedUnion>

您可以使用.exclude从联合中删除类型以进行进一步测试。

import {  } from 'vitest'

type <> =  | [] | { ?: ; ?: ; ?:  }

interface CSSProperties { ?: string; ?: string }

function <>(: ): <> {
  return {}
}

const : CSSProperties = { : '1px', : '2px' }

(())
  .<unknown[]>()
  .<{ ?: unknown }>() // or just .exclude<unknown[] | { xs?: unknown }>()
  .<CSSProperties>()

警告

如果在联合中找不到类型，.exclude将返回never。

returns

• 类型： ExpectTypeOf<ReturnValue>

您可以使用.returns来提取函数类型的返回值。

import {  } from 'vitest'

(() => {})..()
((: number) => [, ])..([1, 2])

警告

如果在非函数类型上使用，它将返回never，因此您将无法将其与其他匹配器链接。

parameters

• 类型： ExpectTypeOf<Parameters>

您可以使用.parameters提取函数参数以对其值执行断言。参数作为数组返回。

import {  } from 'vitest'

type  = () => void
type  = (: string) => void

<>()..<[]>()
<>()..<[string]>()

警告

如果在非函数类型上使用，它将返回never，因此您将无法将其与其他匹配器链接。

提示

您还可以使用.toBeCallableWith匹配器作为更具表现力的断言。

parameter

• 类型： (nth: number) => ExpectTypeOf

您可以使用.parameter(number)调用提取特定函数参数以对其执行其他断言。

import {  } from 'vitest'

function (: number, : string) {
  return [, ]
}

().(0).()
().(1).()

警告

如果在非函数类型上使用，它将返回never，因此您将无法将其与其他匹配器链接。

constructorParameters

• 类型： ExpectTypeOf<ConstructorParameters>

您可以使用此方法提取构造函数参数作为一组值，并对其执行断言。

import {  } from 'vitest'

()..<[] | [string | number | Date]>()

警告

如果在非函数类型上使用，它将返回never，因此您将无法将其与其他匹配器链接。

提示

您还可以使用.toBeConstructibleWith匹配器作为更具表现力的断言。

instance

• 类型： ExpectTypeOf<ConstructableInstance>

此属性提供对可以在提供的类的实例上执行的匹配器的访问。

import {  } from 'vitest'

()..('toISOString')

警告

如果在非函数类型上使用，它将返回never，因此您将无法将其与其他匹配器链接。

items

• 类型： ExpectTypeOf<T>

您可以使用.items获取数组项类型以执行进一步的断言。

import {  } from 'vitest'

([1, 2, 3])..<number>()
([1, 2, 3])...<string>()

resolves

• 类型： ExpectTypeOf<ResolvedPromise>

此匹配器提取Promise的解析值，因此您可以对其执行其他断言。

import {  } from 'vitest'

async function () {
  return 123
}

()...()
(.('string'))..()

警告

如果在非 Promise 类型上使用，它将返回never，因此您将无法将其与其他匹配器链接。

guards

• 类型： ExpectTypeOf<Guard>

此匹配器提取保护值（例如，v is number），因此您可以对其执行断言。

import {  } from 'vitest'

function (: any):  is string {
  return typeof  === 'string'
}
()..()

警告

如果该值不是保护函数，则返回never，因此您将无法将其与其他匹配器链接。

asserts

• 类型： ExpectTypeOf<Assert>

此匹配器提取断言值（例如，assert v is number），因此您可以对其执行断言。

import {  } from 'vitest'

function (: any): asserts  is number {
  if (typeof  !== 'number')
    throw new ('Nope !')
}

()..()

警告

如果该值不是断言函数，则返回never，因此您将无法将其与其他匹配器链接。

toBeAny

• 类型： () => void

使用此匹配器，您可以检查提供的类型是否为any类型。如果类型过于具体，测试将失败。

import {  } from 'vitest'

<any>().()
({} as any).()
('string')..()

toBeUnknown

• 类型： () => void

此匹配器检查提供的类型是否为unknown类型。

import {  } from 'vitest'

().()
({} as unknown).()
('string')..()

toBeNever

• 类型： () => void

此匹配器检查提供的类型是否为never类型。

import { expectTypeOf } from 'vitest'

expectTypeOf<never>().toBeNever()
expectTypeOf((): never => {}).returns.toBeNever()

toBeFunction

• 类型： () => void

此匹配器检查提供的类型是否为function。

import { expectTypeOf } from 'vitest'

expectTypeOf(42).not.toBeFunction()
expectTypeOf((): never => {}).toBeFunction()

toBeObject

• 类型： () => void

此匹配器检查提供的类型是否为object。

import {  } from 'vitest'

(42)..()
({}).()

toBeArray

• 类型： () => void

此匹配器检查提供的类型是否为Array<T>。

import {  } from 'vitest'

(42)..()
([]).()
([1, 2]).()
([{}, 42]).()

toBeString

• 类型： () => void

此匹配器检查提供的类型是否为string。

import {  } from 'vitest'

(42)..()
('').()
('a').()

toBeBoolean

• 类型： () => void

此匹配器检查提供的类型是否为boolean。

import {  } from 'vitest'

(42)..()
(true).()
<boolean>().()

toBeVoid

• 类型： () => void

此匹配器检查提供的类型是否为void。

import {  } from 'vitest'

(() => {})..()
<void>().()

toBeSymbol

• 类型： () => void

此匹配器检查提供的类型是否为symbol。

import {  } from 'vitest'

((1)).()
<symbol>().()

toBeNull

• 类型： () => void

此匹配器检查提供的类型是否为null。

import {  } from 'vitest'

(null).()
<null>().()
()..()

toBeUndefined

• 类型： () => void

此匹配器检查提供的类型是否为undefined。

import {  } from 'vitest'

().()
<undefined>().()
(null)..()

toBeNullable

• 类型： () => void

此匹配器检查您是否可以在提供的类型中使用null或undefined。

import {  } from 'vitest'

<1 | undefined>().()
<1 | null>().()
<1 | undefined | null>().()

toBeCallableWith

• 类型： () => void

此匹配器确保您可以使用一组参数调用提供的函数。

import {  } from 'vitest'

type  = () => void
type  = (: string) => void

<>().()
<>().('some string')

警告

如果在非函数类型上使用，它将返回never，因此您将无法将其与其他匹配器链接。

toBeConstructibleWith

• 类型： () => void

此匹配器确保您可以使用一组构造函数参数创建新实例。

import {  } from 'vitest'

().(new ())
().('01-01-2000')

警告

如果在非函数类型上使用，它将返回never，因此您将无法将其与其他匹配器链接。

toHaveProperty

• 类型： <K extends keyof T>(property: K) => ExpectTypeOf<T[K>

此匹配器检查提供的对象上是否存在属性。如果存在，它还会返回此属性类型的相同匹配器集，因此您可以将断言一个接一个地链接起来。

import {  } from 'vitest'

const  = { : 1, : '' }

().('a')
()..('c')

().('a').()
().('b').()
().('a')..()