expectTypeOf

警告

実行時にこの関数は何も実行しません。タイプチェックを有効にするには、--typecheckフラグを渡すことを忘れないでください

タイプ: <T>(a: 未知値) => ExpectTypeOf

not

タイプ: ExpectTypeOf

.notプロパティを使用してすべての主張を否定できます。

toEqualTypeOf

タイプ: <T>(期待: T) => void

このマッチャーは、型が互いに完全に等しいかどうかを確認します。このマッチャーは、2つのオブジェクトの値が異なり同じ型であっても失敗しません。ただし、オブジェクトにプロパティがない場合は失敗します。

import {  } from 'vitest'

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

toMatchTypeOf

タイプ: <T>(期待: T) => void

このマッチャーは、想定される型が想定される型を拡張するかどうかを確認します。これはtoEqualとは異なり、expectのtoMatchObject()によく似ています。このマッチャーを使用すると、オブジェクトが型と「一致」するかどうかを確認できます。

import {  } from 'vitest'

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

extract

タイプ: ExpectTypeOf<抽出されたUnion>

.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<非除外Union>

.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<戻り値>

.returnsを使用して、関数の型から戻り値を抽出できます。

import {  } from 'vitest'

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

警告

関数以外の型で使用するとneverを返し、他のマッチャーと組み合わせることができなくなります。

parameters

タイプ: ExpectTypeOf<パラメーター>

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

警告

プロミス以外のタイプで使用された場合、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')..()

expectTypeOf ​

not ​

toEqualTypeOf ​

toMatchTypeOf ​

extract ​

exclude ​

returns ​

parameters ​

parameter ​

constructorParameters ​

instance ​

items ​

resolves ​

guards ​

asserts ​

toBeAny ​

toBeUnknown ​

toBeNever ​

toBeFunction ​

toBeObject ​

toBeArray ​

toBeString ​

toBeBoolean ​

toBeVoid ​

toBeSymbol ​

toBeNull ​

toBeUndefined ​

toBeNullable ​

toBeCallableWith ​

toBeConstructibleWith ​

toHaveProperty ​

expectTypeOf

not

toEqualTypeOf

toMatchTypeOf

extract

exclude

returns

parameters

parameter

constructorParameters

instance

items

resolves

guards

asserts

toBeAny

toBeUnknown

toBeNever

toBeFunction

toBeObject

toBeArray

toBeString

toBeBoolean

toBeVoid

toBeSymbol

toBeNull

toBeUndefined

toBeNullable

toBeCallableWith

toBeConstructibleWith

toHaveProperty