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>()

萃取

• 類型： 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。

排除

• 類型： 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。

傳回

• 類型： ExpectTypeOf<ReturnValue>

您可以使用 .returns 來萃取函式類型的傳回值。

import {  } from 'vitest'

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

警告

如果用於非函式類型，它會傳回 never，因此您無法將它與其他比對器串接。

參數

• 類型： ExpectTypeOf<Parameters>

您可以使用 .parameters 萃取函式引數，以對其值進行斷言。參數會以陣列形式傳回。

import {  } from 'vitest'

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

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

警告

如果用於非函式類型，它會傳回 never，因此您無法將它與其他比對器串接。

提示

您也可以使用 .toBeCallableWith 比對器作為更具表達力的斷言。

參數

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

您可以使用 .parameter(number) 呼叫來萃取特定函式引數，並對其執行其他斷言。

import {  } from 'vitest'

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

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

警告

如果用於非函式類型，它會傳回 never，因此您無法將它與其他比對器串接。

建構函數參數

• 類型： ExpectTypeOf<ConstructorParameters>

您可以使用此方法將建構函數參數萃取為值陣列，並對它們執行斷言。

import {  } from 'vitest'

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

警告

如果用於非函式類型，它會傳回 never，因此您無法將它與其他比對器串接。

提示

您也可以使用 .toBeConstructibleWith 比對器作為更具表達力的斷言。

實例

• 類型： ExpectTypeOf<ConstructableInstance>

此屬性提供對可對所提供類別實例執行的比對器的存取權。

import {  } from 'vitest'

()..('toISOString')

警告

如果用於非函式類型，它會傳回 never，因此您無法將它與其他比對器串接。

項目

• 類型： ExpectTypeOf<T>

您可以使用 .items 取得陣列項目類型，以執行進一步的斷言。

import {  } from 'vitest'

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

解決

• 類型： ExpectTypeOf<ResolvedPromise>

此比對器會擷取 Promise 已解決的值，以便您可以對其執行其他斷言。

import {  } from 'vitest'

async function () {
  return 123
}

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

警告

如果用於非 Promise 類型，它會傳回 never，因此您無法將其與其他比對器串連。

防護

• 類型： ExpectTypeOf<Guard>

此比對器會擷取防護值（例如，v is number），以便您可以對其執行斷言。

import {  } from 'vitest'

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

警告

如果值不是防護函式，它會傳回 never，因此您無法將其與其他比對器串連。

斷言

• 類型： 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')..()