TS 유형을 사용하는 방법 피보나치 풀기

포스트를 통해 많은 것을 배웠고, 이것이 첫 번째 포스트를 작성하기 위해 계정을 등록한 이유입니다.
https://medium.com/free-code-camp/typescript-curry-ramda-types-f747e99744ab

0x00 우리가 하고 싶은 것

우리는 이렇게 하고 싶습니다 ↓↓↓ TS Type 풀기 FIbonacci

type r0 = Fib<Zero>;
// type r10= 0
type r1 = Fib<One>;
// type r1 = 1

type r2 = Fib<Two>;
// type r2 = 1

type r3 = Fib<3>;
// type r3 = 2

type r4 = Fib<4>;
// type r4 = 3

type r5 = Fib<5>;
// type r5 = 5

type r6 = Fib<6>;
// type r6 = 8

1x00 우리가 이것을 할 수 있는 방법

1x01 먼저 몇 가지 util 유형이 필요합니다.

그들은 간단하고 이해하기 쉽습니다

범위: 목록 생성

길이: 목록의 크기 가져오기

Concat: 두 개의 목록을 연결

  type Length<T extends any[]> = T["length"];
  type Range<T extends Number = 0, P extends any[] = []> = {
    0: Range<T, [any, ...P]>;
    1: P;
  }[Length<P> extends T ? 1 : 0];
  type Concat<T extends any[], P extends any[]> = [...T, ...P];
  type t1 = Range<3>;
  // type t1 = [any, any, any]
  type Zero = Length<Range<0>>;
  // type Zero = 0
  type One = Length<Range<1>>;
  // type One = 1

  type Ten = Length<Range<10>>;
  // type Ten = 10
  type Five = Length<Range<5>>;
  // type Five = 5
  type Six = Length<Concat<Range<5>, Range<1>>>;
  // type Six = 6

추가도 쉽습니다

2개의 리스트를 생성한다

그들을 연결

결과 크기 가져오기

  type Add<T extends number, P extends number> = Length<
    Concat<Range<T>, Range<P>>
  >;

  type Two = Add<One, One>;
  //   type Two = 2
  type Three = Add<One, Two>;
  // type Three = 3

그러나 빼기를 구현하는 방법은 무엇입니까?

1x02 더 많은 유틸리티 유형이 필요합니다.

일부 배열 유형

추가: 목록 헤드에 요소 삽입

IsEmpty/NotEmpty: 판사 목록이 비어 있지 않음/비어 있음

꼬리: 첫 번째 요소 삭제

  type Append<T extends any[], E = any> = [...T, E];
  type IsEmpty<T extends any[]> = Length<T> extends 0 ? true : false;
  type NotEmpty<T extends any[]> = IsEmpty<T> extends true ? false : true;
  type t4 = IsEmpty<Range<0>>;
  // type t4 = true

  type t5 = IsEmpty<Range<1>>;
  // type t5 = false

  type Tail<T extends any[]> = ((...t: T) => any) extends (
    _: any,
    ...tail: infer P
  ) => any
    ? P
    : [];

  type t22 = Tail<[1, 2, 3]>;
  // type t22 = [2, 3]

  type t23 = Tail<[1]>;
  // type t23 = []

  type t24 = Tail<[]>;
  // type t24 = []

논리 유형

그리고: a && b

LessList: a.length <= b.length

덜: a <= b

  type And<T extends boolean, P extends boolean> = T extends false
    ? false
    : P extends false
    ? false
    : true;
  type t6 = And<true, true>;
  // type t6 = true

  type t7 = And<true, false>;
  // type t7 = false

  type t8 = And<false, false>;
  // type t8 = false

  type t9 = And<false, true>;
  // type t9 = false

  //   T <= P
  type LessList<T extends any[], P extends any[]> = {
    0: LessList<Tail<T>, Tail<P>>;
    1: true;
    2: false;
  }[And<NotEmpty<T>, NotEmpty<P>> extends true
    ? 0
    : IsEmpty<T> extends true
    ? 1
    : 2];
  type Less<T extends number, P extends number> = LessList<Range<T>, Range<P>>;
  type t10 = Less<Zero, One>;
  // type t10 = true
  type t11 = Less<One, Zero>;
  // type t11 = false

  type t12 = Less<One, One>;
  // type t12 = true

이제 js를 ts로 '번역'할 수 있습니다.

- 하위 목록:

const a = [1, 2, 3];
const b = [4, 5];
const c = [];
while (b.length !== a.length) {
  a.pop();
  c.push(1);
}
// c.length === a.length - b.length
console.log(c.length);

서브: a - b

  type SubList<T extends any[], P extends any[], R extends any[] = []> = {
    0: Length<R>;
    1: SubList<Tail<T>, P, Append<R>>;
  }[Length<T> extends Length<P> ? 0 : 1];
  type t13 = SubList<Range<10>, Range<5>>;
  // type t13 = 5

  // T - P
  type Sub<T extends number, P extends number> = {
    0: Sub<P, T>;
    1: SubList<Range<T>, Range<P>>;
  }[Less<T, P> extends true ? 0 : 1];

  type t14 = Sub<One, Zero>;
  //   type t14 = 1
  type t15 = Sub<Ten, Five>;
  // type t15 = 5

2x00 JS 기능 ==> TS 유형

js에서는 함수를 사용합니다.

const fib = (n) => (n <= 1 ? n : n++);

ts에서는 type을 사용합니다!!! 그들은 똑같이 보인다!

  type Fib<T extends number> = {
    0: T;
    1: Add<Fib<Sub<T, One>>, Fib<Sub<T, Two>>>;
  }[Less<T, One> extends true ? 0 : 1];

  type r0 = Fib<Zero>;
  // type r10= 0
  type r1 = Fib<One>;
  // type r1 = 1

  type r2 = Fib<Two>;
  // type r2 = 1

  type r3 = Fib<3>;
  // type r3 = 2

  type r4 = Fib<4>;
  // type r4 = 3

  type r5 = Fib<5>;
  //type r5 = 5

  type r6 = Fib<6>;
  //   type r6 = 8

마지막으로, 우리는 ts solve Fibonacci를 사용합니다. 이것은 놀랍습니다! 전에는 그런 생각을 해본 적이 없었어요. 천재적인 생각을 공유하는 사람들에게 감사합니다 💖~