Type 특징

대수타입(Algebraic type) : 여러개의 타입을 합성해서 새롭게 만들어낸 타입

 

•  합집합 - Union type ("|" 사용): 어느 한쪽에만 포함되는 객체 또는 모두 포함되는 교집합에 위치하는 객체

// union 타입
let a: string | number | boolean | undefined | null | {};
a = 1;
a = "hello";
a = true;

let arr: (number | string | boolean)[] = [1, "hello", true];

type Dog = {
  name: string;
  color: string;
};

type Person = {
  name: string;
  language: string;
};

type Union1 = Dog | Person;
let union1: Union1 = {
  name: "",
  color: "",
};
let union2: Union1 = {
  name: "",
  language: "",
};
let union3: Union1 = {
  name: "",
  color: "",
  language: "",
};

//❌ 어느 한쪽에도 포함되어 있지 않음
let union4: Union1 = {
  name: "",
};

 

• 교집합 - Intersection type ("&" 사용) 모든 프로퍼티를 다 가진 객체만 교집합 타입으로 포함될수 있다.

// 교집합
let variable: number & string;

type Dog = {
  name: string;
  color: string;
};

type Person = {
  name: string;
  language: string;
};

type Intersection = Dog & Person;
let Intersection1: Intersection = {
  name: "",
  color: "",
  language: "",
};

 

---

 

타입추론 : 타입스크립트는 자동으로 변수의 타입을 추론(변수의 초깃값 기준)

let a = 10;          // number
let b = "hello";     // string
let c = {
  id: 1,
  name: "김동영",
  profile: {
    nickname: "김도영",
  },
  url: ["https:://inflearn.com"],
};

let { id, name, profile } = c;
let [one, two, three] = [1, "hello", true];

function func(message = "hello") {
  return "hello";
}

 

• any type의 진화 : 초깃값 없이 변수만 선언 -> any 타입으로 추론 -> 진화

let d;           // any
d = 10;          // number
d.toFixed();     // number

d = "hello";     // string
d.toUpperCase(); // string

 

• const로 선언한 변수는 리터럴 타입으로 추론(const는 상수라서 다른값 ❌)

const num = 10;
const str = "hello";

 

---

 

타입 단언 (type assertion) : 초기화 값의 타입을 단언

 

• 단언식 : 값 as 단언(A as B)
  A가 B의 슈퍼타입 이거나, A가 B의 서브타입이여야 함

type Person = {
  name: string;
  age: number;
};

let person = {} as Person;
person.name = "이제노";
person.age = 24;

type Dog = {
  name: string;
  color: string;
};

let dog = {
  name: "이제노",
  color: "beige",
  breed: "사모예드", // 초과 프로퍼티 검사
} as Dog;

let num1 = 10 as never;    // never는 모든 타입의 서브타입 A -> B
let num2 = 10 as unknown;  // unknown는 전체집합 타입    B <- A

let num3 = 10 as string;   // ❌ number 와 string 교집합이 없음
let num4 = 10 as unknown as string;  // 다중단언

 

• const 단언 : const로 선언한것과 동일한 효과를 보도록 만들어줌, 프로퍼티의 값을 수정할수 없음

let num5 = 10 as const;

let cat = {
  name: "사모예드", // readonly
  color: "baige", // readonly
} as const;

cat.name = ""; ❌

 

• Non Null 단언 : 값이 null / undefined이 아니라고 컴파일 해줌

type Post = {
  title: string;
  author?: string; // 선택적 프로퍼티
};

let post: Post = {
  title: "ISTJ",
  author: "kenzie",
};

const len: number = post.author!.length;  // "?" 옵셔널체이닝 => !

** "?" 옵셔널체이닝: 값이 null/undefined 일 경우 -> 값 전체를 undefined로 만들어주는 연산자

 

---

 

타입 좁히기 : 조건문 등을 이용해 넓은 타입에서 좁은 타입으로 타입을 상황에 따라 좁히는 방법

type Person = {
  name: string;
  age: number;
};

function func(value: number | string | Date | null | Person) {
  value;   // union type
  value.toUpperCase(); ❌
  value.toFixed(); ❌

  if (typeof value === "number") {    // 타입 가드
    console.log(value.toFixed());     // number
    
  } else if (typeof value === "string") {
    console.log(value.toUpperCase()); // string
    
  } else if (value instanceof Date) {
    //instanceof 왼쪽 값이 오른쪽 값(class)인지 확인, typeof는 null도 반환하기 때문에 사용
    console.log(value.getTime());
        
  } else if ("age" in value) {
    // Person은 객체타입
    console.log(`${value.name}은 ${value.age}살 입니다.`);
  }
}

 

• 서로소 유니온 타입 : 교집합이 없는 타입들로만 만든 유니온 타입

type Admin = {
  tag: "ADMIN";
  name: string;
  kickCount: number;
};

type Member = {
  tag: "MEMBER";
  name: string;
  point: number;
};

type Guest = {
  tag: "GUEST";
  name: string;
  visitCount: number;
};

type User = Admin | Member | Guest;

function login(user: User) {
  switch (user.tag) {
    case "ADMIN": {
      console.log(`${user.name}님 현재까지 ${user.kickCount}명 강퇴했습니다.`);
      break;
    }
    case "MEMBER": {
      console.log(`${user.name}님 현재까지 ${user.point}모았습니다.`);
      break;
    }
    case "GUEST": {
      console.log(`${user.name}님 현재까지 ${user.visitCount}번 방문하셨습니다.`);
      break;
    }
  }
}

** 프로퍼티의 타입을 리터럴 타입으로 각각 다르게 정의해주면 각각의 객체들이 서로소 집합의 관계를 가지게 됨