实现一个通用First<T>，它接受一个数组T并返回它的第一个元素的类型。

如果是空数组（也就是never[]）返回never，其他数组返回第一元素的类型

  1. type First<T extends any[]> = T extends never[] ? never : T[0]
  3. type cases = [
  4.   Expect<Equal<First<[3, 2, 1]>, 3>>,
  5.   Expect<Equal<First<[() => 123, { a: string }]>, () => 123>>,
  6.   Expect<Equal<First<[]>, never>>,
  7.   Expect<Equal<First<[undefined]>, undefined>>
  8. ]

获取元组长度

创建一个通用的Length，接受一个readonly的数组，返回这个数组的长度。

接受一个 readonly 数组，必需在泛型传入时约束，否则 test case 过不了

  1. type Length<T extends readonly unknown[]> = T['length']
  4. /* _____________ 测试用例 _____________ */
  5. import { Equal, Expect } from '@type-challenges/utils'
  7. const tesla = ['tesla', 'model 3', 'model X', 'model Y'] as const
  8. const spaceX = ['FALCON 9', 'FALCON HEAVY', 'DRAGON', 'STARSHIP', 'HUMAN SPACEFLIGHT'] as const
  10. type cases = [
  11.   Expect<Equal<Length<typeof tesla>, 4>>,
  12.   Expect<Equal<Length<typeof spaceX>, 5>>,
  13.   // @ts-expect-error
  14.   Length<5>,
  15.   // @ts-expect-error
  16.   Length<'hello world'>,
  17. ]

如果不是上面的 test case 的话

  1. type Length<T extends any> = T extends readonly any[] ? T['length'] : never

Exclude

实现内置的Exclude
从T中排除可分配给U的那些类型

T为联合类型的时候，会进行拆分 比如 “a” | “b” | “c”, “a” 会拆分为 a extends a，b extends a，c extends a

  1. type MyExclude<T, U> = T extends U ? never : T
  4. /* _____________ 测试用例 _____________ */
  5. import { Equal, Expect } from '@type-challenges/utils'
  7. type cases = [
  8.     Expect<Equal<MyExclude<"a" | "b" | "c", "a">, Exclude<"a" | "b" | "c", "a">>>,
  9.     Expect<Equal<MyExclude<"a" | "b" | "c", "a" | "b">, Exclude<"a" | "b" | "c", "a" | "b">>>,
  10.     Expect<Equal<MyExclude<string | number | (() => void), Function>, Exclude<string | number | (() => void), Function>>>,
  11. ]

Awaited

假如我们有一个 Promise 对象，这个 Promise 对象会返回一个类型。在 TS 中，我们用 Promise 中的 T 来描述这个 Promise 返回的类型。请你实现一个类型，可以获取这个类型。
比如：Promise<ExampleType>，请你返回 ExampleType 类型。

  1. /* _____________ 你的代码 _____________ */
  3. type Awaited<S extends unknown> = S extends Promise<infer Y > ? Y : S 
  4. type MyAwaited<T extends Promise<unknown>> = T extends Promise<infer U> ? Awaited<U> : T
  6. /* _____________ 测试用例 _____________ */
  7. import type { Equal, Expect } from '@type-challenges/utils'
  9. type X = Promise<string>
  10. type Y = Promise<{ field: number }>
  11. type Z = Promise<Promise<string | number>>
  13. type cases = [
  14.   Expect<Equal<MyAwaited<X>, string>>,
  15.   Expect<Equal<MyAwaited<Y>, { field: number }>>,
  16.   Expect<Equal<MyAwaited<Z>, string | number>>,
  17. ]
  19. // @ts-expect-error

If

Implement a utils If which accepts condition C, a truthy return type T, and a falsy return type F. C is expected to be either true or false while T and F can be any type.

For example:

  1. type A = If<true, 'a', 'b'>  // expected to be 'a'
  2. type B = If<false, 'a', 'b'> // expected to be 'b'

solutions:

  1. type If<T, U, R> = T extends boolean ? ( T extends true ? U : R ) : never
  4. /* _____________ Test Cases _____________ */
  5. import { Equal, Expect } from '@type-challenges/utils'
  7. type cases = [
  8.   Expect<Equal<If<true, 'a', 'b'>, 'a'>>,
  9.   Expect<Equal<If<false, 'a', 2>, 2>>,
  10. ]
  12. // @ts-expect-error
  13. type error = If<null, 'a', 'b'>
  1. type Concat<T extends unknown[], U extends unknown[]> = [...T,...U]
  3. type a  = Concat<[], []>
  4. type b = Concat<[], [1]>
  5. type c = Concat<[1, 2], [3, 4]>
  6. type d = Concat<['1', 2, '3'], [false, boolean, '4']>
  1. type Required1<T> = {
  2.     [P in keyof T]-?: T[P];
  3. };
  1. /* _____________ 你的代码 _____________ */
  3. type Includes<T extends readonly unknown[], U> = T extends [infer Head, ...infer Rest]
  4.   ? Equal<Head, U> extends true ? true : Includes<Rest, U>
  5.   : false
  8. /* _____________ 测试用例 _____________ */
  9. import type { Equal, Expect } from '@type-challenges/utils'
  11. type cases = [
  12.   Expect<Equal<Includes<['Kars', 'Esidisi', 'Wamuu', 'Santana'], 'Kars'>, true>>,
  13.   Expect<Equal<Includes<['Kars', 'Esidisi', 'Wamuu', 'Santana'], 'Dio'>, false>>,
  14.   Expect<Equal<Includes<[1, 2, 3, 5, 6, 7], 7>, true>>,
  15.   Expect<Equal<Includes<[1, 2, 3, 5, 6, 7], 4>, false>>,
  16.   Expect<Equal<Includes<[1, 2, 3], 2>, true>>,
  17.   Expect<Equal<Includes<[1, 2, 3], 1>, true>>,
  18.   Expect<Equal<Includes<[{}], { a: 'A' }>, false>>,
  19.   Expect<Equal<Includes<[boolean, 2, 3, 5, 6, 7], false>, false>>,
  20.   Expect<Equal<Includes<[true, 2, 3, 5, 6, 7], boolean>, false>>,
  21.   Expect<Equal<Includes<[false, 2, 3, 5, 6, 7], false>, true>>,
  22.   Expect<Equal<Includes<[{ a: 'A' }], { readonly a: 'A' }>, false>>,
  23.   Expect<Equal<Includes<[{ readonly a: 'A' }], { a: 'A' }>, false>>,
  24.   Expect<Equal<Includes<[1], 1 | 2>, false>>,
  25.   Expect<Equal<Includes<[1 | 2], 1>, false>>,
  26.   Expect<Equal<Includes<[null], undefined>, false>>,
  27.   Expect<Equal<Includes<[undefined], null>, false>>,
  28. ]
  1. type MyOmit<T, K extends keyof T> = { [P in keyof T as P extends K ? never : P]: T[P] }
  1. /* _____________ 你的代码 _____________ */
  3. type Last<T extends any[]> = [any , ...T][T['length']]
  6. /* _____________ 测试用例 _____________ */
  7. import type { Equal, Expect } from '@type-challenges/utils'
  9. type cases = [
  10.   Expect<Equal<Last<[3, 2, 1]>, 1>>,
  11.   Expect<Equal<Last<[() => 123, { a: string }]>, { a: string }>>,
  12. ]