TypeScript / 기본 타입 호환성, 객체 타입 호환성 정리

 

 

타입 호환성 표 참조 .....!

 

https://www.typescriptlang.org/ko/docs/handbook/type-compatibility.html

Documentation - Type Compatibility

 

 

- 타입스크립트는 구조적 타이핑(Structural Typing)을 기반으로 하기 때문에 

  형태(구조)가 같거나 더 많은 속성을 가지고 있으면, 호환 가능하다는 규칙을 가진다.

 

기본 타입(Type) 호환성

 

1. 더 넓은 타입 -> 더 좁은 타입 (슈퍼 타입이 서브타입에 들어가는것) 은 호환이 불가능하다 

2. 더 좁은 타입 -> 더 넓은 타입 (서브 타입이 슈퍼타입에 들어가는 것) 은 가능하다.

 

let num: number = 10;
let str: string = num; // 불가능하다.
 
// String과 number는 같은 계층에 있지만 타입 값이 다르므로 호환되지 않는다.
 
type Gender = "male" | "female";
let g: Gender = "male";
 
let s: string = g;
 
// String은 모든 문자열을 포함할 수 있기 때문에
// "male" | "femail" 타입을 받을 수 있다.
 
let a: any = 123;
let b: number = a;
let c: string = a;
 
// any는 마스터 키 느낌이다 슈퍼타입이 될수도 있고, 서브타입이 될수도 있다.(치트키)
// 따라서 특수한 경우가 아니라면 잘 사용되지 않는다.
 
let u : unknown = "hello"
let s: string = u // 불가능하다.
 
// unknown타입은 모든 타입의 슈퍼타입 이기 때문에 해당 타입안으로 서브타입을 포함하는것은 가능하지만
// 해당 아래 서브타입안에 unknown 타입이 선언된 변수를 대입하는 것은 불가능하다.
 
 
let n: never;
let v: void;
 
v = n; // 가능하다.
n = v; // 불가능하다.
 
// void 타입이 never을 포함하는 슈퍼타입 never는 어느 타입을 가지지 않는 모든 타입의 최하위 타입이다.
// 슈퍼타입인 void 안에 해당 서브타입 never을 대입하는 것은 가능하지만, 
// 서브타입인 never안에 슈퍼타입인 void를 대입하는 것은 불가능하다.
 
 
 

 

객체 타입(Type) 호환성

 

- 타입 형태가 같으면 호환된다.

- 필드가 더 많은 객체는 더 적은 객체 타입에 할당 가능하다.

type A = {
    name: string;
};
 
type B = {
    name: string;
    age: number;
};
 
let a: A;
let b: B = { name: "철수", age: 20 };
 
a = b; // 가능하다. (B가 더 많은 속성을 가진다.)
 
// B는 A의 구조를 포함하므로, A에 할당 가능하다.
 
let a: A = {name: "철수"};
let b: B;
 
b = a; // 불가능하다. (age가 없음)
 
// A는 B의 구조를 포함하지 못하므로, B에 할당하지 못한다.
 
type Dog = {name: string};
type Person = {name: string};
 
let d: Dog = {name: "망고"};
let p: Person = d; 
 
// 구조가 같으므로, 서로 호환이 가능하다.
 
//****** 중요!!!! ******//
 
// 함수 타입의 호환성
 
// 함수는 매개변수는 적을수록, 반환값은 더 구체적일수록 호환됨.
 
// (1) 매개변수 : 적은 매개변수 -> 많은 매개변수 타입에 할당 가능.
let funcA = (a: number, b: number) => {};
let funcB = (a: number) => {};
 
funcA = funcB; // 가능하다.
funcB = funcA; // 불가능하다.
 
// (2) 반환값 : 더 많은 속성 반환 가능
 
type A = { name: string };
type B = { name: string; age: number; };
 
let f1 = (): A => ({name: "철수" });
let f2 = (): B => ({name: "철수", age: 20});
 
f1 = f2; // 반환값 B는 A보다 더 많은 속성을 가지고 있음
f2 = f1; // B가 기대하는 age 없음
 
// readonly는 비교에 영향을 끼치지 않는다.
 
type A = {readonly name: string};
type B = {name: string};
 
let a: A = { name: "철수" }
let b: B = a; // 가능하다.