TIL( TypeScript - Utility type )

 

💡TypeScript - 자주 사용하는 Utility type 정리

 

참조: https://velog.io/@njt6419/Typescirpt-%EC%9C%A0%ED%8B%B8%EB%A6%AC%ED%8B%B0-%ED%83%80%EC%9E%85

 

-  유틸리티 타입이란 타입스크립트에서 주로 사용되는 타입으로, 기존 타입을 변형하거나 새로운 타입을 만드는 데 사용되며, 여러 가지 유틸리티 타입을  사용하여 개발자가 타입을 쉽게 다룰 수 있도록 도와준다.

 

 

• Partial :  객체의 모든 속성을 선택적으로 만든다

interface Profile {
    name: string;
    age: number;
    married: boolean;
}
const newPerson: Partial<Profile> = {
    name: 'john',
    age: 29,
};

 

• Required: 모든 선택적 속성을 필수로 만든다.

interface Profile {
    name?: string;
    age?: number;
    married?: boolean;
}
//Required 구현
type R<T> = {
	[Key in Keyof T]-?: T[Key];
}
const newPerson: Partial<Profile> = {
    name: 'john',
    age: 29,
    married: true,
};

 

• Readonly: 모든 속성을 읽기 전용으로 만든다.

// Readonly<T> 구현
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};
interface Profile {
    name: string;
    age: number;
    married: boolean;
}
const readonlyProfile: Readonly<Profile> = {
    name: 'john',
    age: 29,
    married: true,
};

 

• Pick

- Pick<T, K> : T 타입에서 K 속성만 선택하여 새로운 타입을 만든다.

//pick<T, K> 구현
type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};
interface Profile {
    name: string;
    age: number;
    married: boolean;
}
type NameAndAge = Pick<Profile, 'name' | 'age'>;

const person: NameAndAge = {
    name: 'john',
    age: 29,
};

 

• Omit

- Omit<T, K> : T 타입에서 K 속성을 제외한 새로운 타입을 만든다.

//Omit 구현<T, K>
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
interface Profile {
    name: string;
    age: number;
    married: boolean;
}
const newPerson1: Omit<Profile, 'married'> = {
    name: 'jun',
    age: 30,
};

 

• Record

-  Record<K, T> : 특정 키 타입 K와 값 타입 T를 가지는 객체 타입을 만든다.

type R<T extends keyof any, S> = {   //extends keyof any=> key안에 제한조건을 넣어준다.
	[Key in T] : S;
}
const a: Record<string, number> = { a:3, b:5, c: 7};

 

•  Exclude

- Exclude<T, K > : T 타입에서 K 타입을 제외하여 새로운 타입을 만든다.

//Exclude<T, K> 구현
type Exclude<T, K> = T extends K ? never : T;

type Animal = 'Cat' | 'Dog' | 'Human';
type Mammal = Exclude<Animal, 'Human'>; // => Mammal 타입은 'Cat' | 'Dog'

 

•  Extract

- Extract<T, K > : T 타입에서 K 타입과 겹치는 타입을 추출하여 새로운 타입을 만든다.

//Extract<T, K>구현 
type Extract<T, K> = T extends K ? T : never;

type Animal = 'Cat' | 'Dog' | 'Human';
type DomesticAnimal = 'Dog' | 'Cat';

type CommonAnimal = Extract<Animal, DomesticAnimal>; // 'Cat' | 'Dog' // 두개의 타입에서 겹치는 타입!

 

•  ReturnType

- ReturnType<T> : 함수 타입 T의 반환 타입을 추출합니다.

//ReturnType<T> 구현
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

function getUser() {
    return {
        name: 'john',
        age: 29,
    };
}
type User = ReturnType<typeof getUser>; //=>  { name: string; age: number; }