[타입스크립트] 제네릭 클래스

//다른 타입으로 쓸 수 있게 바꾸기
//either: a or b
interface Either<T, U> {
  left: () => T;
  right: () => U;
}
class SimpleEither<T, U> implements Either<T, U> {
  constructor(private leftValue: T, private rightValue: U) {}
  left(): T {
    return this.leftValue;
  }
  right(): U {
    return this.rightValue;
  }
}

const either = new SimpleEither(4, { name: "홍길동", age: 18 });
console.log(either.left()); //4
console.log(either.right()); //홍길동​

//either: a or b
interface Either {
  left: () => number;
  right: () => number;
}
class SimpleEither implements Either {
  constructor(private leftValue: number, private rightValue: number) {}
  left(): number {
    return this.leftValue;
  }
  right(): number {
    return this.rightValue;
  }
}

const either = new SimpleEither(4, 5);
console.log(either.left()); //4
console.log(either.right()); //5

 

같은 타입으로 쓸 수 있게 바꾸기

{
  //같은 타입으로 쓸 수 있게 바꾸기
  //either: a or b
  interface Either<T> {
    left: () => T;
    right: () => T;
  }
  class SimpleEither<T> implements Either<T> {
    constructor(private leftValue: T, private rightValue: T) {}
    left(): T {
      return this.leftValue;
    }
    right(): T {
      return this.rightValue;
    }
  }

  const either: Either<string> = new SimpleEither("심청이", "황진이");
  console.log(either.left()); //심청이
  console.log(either.right()); //황진이
}

명시 안 해주어도 됨

{
  //같은 타입으로 쓸 수 있게 바꾸기
  //either: a or b
  interface Either<T> {
    left: () => T;
    right: () => T;
  }
  class SimpleEither<T> implements Either<T> {
    constructor(private leftValue: T, private rightValue: T) {}
    left(): T {
      return this.leftValue;
    }
    right(): T {
      return this.rightValue;
    }
  }

  const either = new SimpleEither("심청이", "황진이");
  console.log(either.left()); //심청이
  console.log(either.right()); //황진이
}

 

 

다른 타입으로 쓸 수 있게 바꾸기

{
  //다른 타입으로 쓸 수 있게 바꾸기
  //either: a or b
  interface Either<T, U> {
    left: () => T;
    right: () => U;
  }
  class SimpleEither<T, U> implements Either<T, U> {
    constructor(private leftValue: T, private rightValue: U) {}
    left(): T {
      return this.leftValue;
    }
    right(): U {
      return this.rightValue;
    }
  }

  const either: Either<number, string> = new SimpleEither(4, "홍길동");
  console.log(either.left()); //4
  console.log(either.right()); //홍길동

명시 안 해주어도 됨

  //다른 타입으로 쓸 수 있게 바꾸기
  //either: a or b
  interface Either<T, U> {
    left: () => T;
    right: () => U;
  }
  class SimpleEither<T, U> implements Either<T, U> {
    constructor(private leftValue: T, private rightValue: U) {}
    left(): T {
      return this.leftValue;
    }
    right(): U {
      return this.rightValue;
    }
  }

  const either = new SimpleEither(4, "홍길동");
  console.log(either.left()); //4
  console.log(either.right()); //홍길동
}

심지어 오브젝트 타입도 됨.

이처럼 제네릭을 이용하면 활용성 높은 함수와 활용성 높은 클래스를 만들어 낼 수 있다.