코드 구조

for (int i = 0; i < a.length(); i++) {
    char ch = a.charAt(i);

    if (Character.isUpperCase(ch)) {
        ch = Character.toLowerCase(ch);
    } else {
        ch = Character.toUpperCase(ch);
    }

    System.out.print(ch);
}

실수했던 부분들

1. 반복 범위를 20으로 고정함

for (int i = 0; i < 20; i++)

문자열 길이는 매번 다르니까 실제 길이를 써야 했었다.

for (int i = 0; i < a.length(); i++)

charAt(i)는 인덱스가 문자열 길이를 넘어가면 에러가 난다.

2. 대소문자 변환 방향이 반대였음

문제는:

대문자 -> 소문자
소문자 -> 대문자

그래서:

if (Character.isUpperCase(ch)) {
    ch = Character.toLowerCase(ch);
} else {
    ch = Character.toUpperCase(ch);
}

3. Character.toLowerCase(ch)가 원본을 바꾸는 줄 알았음

이 코드는 ch를 직접 바꾸지 않는다.

Character.toLowerCase(ch);

변환된 값을 반환만 한다. 그래서 이렇게 써야 한다.

ch = Character.toLowerCase(ch);

또는 바로 출력:

System.out.print(Character.toLowerCase(ch));

4. 마지막에 원래 문자열 a를 출력함

System.out.println(a);

이러면 변환 결과가 아니라 원래 입력 문자열이 출력된다.
String a 자체는 바뀌지 않았기 때문

포인트

a.length() = 문자열 길이
a.charAt(i) = i번째 문자 꺼내기
Character.isUpperCase(ch) = 대문자인지 확인
Character.toLowerCase(ch) = 소문자로 바꾼 값을 반환
Character.toUpperCase(ch) = 대문자로 바꾼 값을 반환

변환 함수는 원본을 바꾸지 않는다.
변환된 결과를 변수에 저장하거나 바로 출력해야 한다.

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        // 실제 실행 코드는 여기
    }
}

class Solution은 코드가 들어가는 상자이다. Java는 코드를 기본적으로 클래스 안에 작성한다. 프로그래머스는 보통 Solution 클래스를 기준으로 실행.

main은 Java 프로그램의 시작점이다.

public static void main(String[] args)

의미는:

public = JVM이 밖에서 접근 가능
static = 객체 생성 없이 바로 실행 가능
void = 반환값 없음
main = Java가 시작점으로 찾는 이름
String[] args = 실행할 때 외부에서 받을 수 있는 문자열 배열

코딩테스트에서는 args는 거의 안 쓰지만, Java의 약속된 시작 함수 모양이라 넣는다.

static vs 일반 메서드

궁금증. static/dynamic 할때랑 같은 static 맞나? - 맞음 Java에서 static은 객체마다 따로 생기는 것이 아니라, 클래스가 메모리에 올라갈 때 클래스에 하나만 붙는것.

dynamic = 실행 중에 객체를 만들고, 객체별 상태를 가짐 static = 클래스 로딩 시점에 정해지고, 객체 없이 클래스에 붙음 static쓰면 객체 생성할 필요 없이 사용가능. 메서드 등이 클래스에 붙음 static 안 붙이면 객체를 만들 때 생성되는 인스턴스 멤버가 된다

main에 static이 붙어있는 이유도 프로그램 시작 전에 Solution 객체를 만들지 않아도 JVM이 Solution.main()을 바로 호출할 수 있어야 하니까

static 메서드 = 객체 없이 클래스 이름으로 바로 호출
일반 메서드 = 객체를 만든 다음 그 객체를 통해 호출

예:

Math.max(3, 5);

Math.max는 static이라서 new Math()를 안 한다.

반면:

Scanner sc = new Scanner(System.in);
sc.next();

Scanner는 실제 입력 상태를 관리해야 하니까 객체를 만들어서 사용한다.

Scanner

Scanner sc = new Scanner(System.in);

뜻:

표준 입력(System.in)을 읽는 Scanner 객체를 만들고,
그 객체를 sc라는 이름으로 쓰겠다.

문자열 입력:

String a = sc.next();

정수 입력:

int a = sc.nextInt();

출력

그냥 출력:

System.out.println(a);

문자열이랑 변수 같이 출력:

System.out.println("a = " + a);

+는 문자열과 변수를 이어 붙인다.

예를 들어 a가 4면:

"a = " + a

결과는:

a = 4

입력 도구 만들기: Scanner sc = new Scanner(System.in);
문자열 입력: sc.next()
정수 입력: sc.nextInt()
출력: System.out.println()
문자열 + 변수 출력: "a = " + a

엔터티란 업무에서 관리해야 할 정보의 덩어리(명사)다. 실제 테이블의 후보가 된다.

EX. 쇼핑몰이라면 회원/상품/주문/배송 같은 명사 하나하나가 엔터티. 각 엔터티의 개별 사례 ('김주안 고객')을 인스턴스라고 한다.

멤버라는 엔터티는 ORDER라는 엔터티를 여러개 만들 수 있음. 주안 고객님은 멤버 엔터티의 인스턴스. 주안고객의 주문1,2 들은 ORDER 엔터티의 인스턴스들.

엔터티와 테이블의 차이? 엔터티는 데이터 모델링 단계, 테이블은 실제 DB 구현 단계에 해당하는 것. 즉 SQL 구문으로 뽑아내고 하는건 테이블, 추상적 개념 학생 등은 엔터티임

엔터티의 구성

엔터티 = 테이블은 아님. 엔터티는 열과 행으로 이루어지며, 열=속성이고, 행=인스턴스임. 즉 속성을 가진 인스턴스들이 여러개가 있는것.

엔터티의 5가지 특징

1. 업무에서 필요

2. 식별가능

3. 인스턴스 >= 2

4. 속성 >= 2

5. 관계보유

1,2,5는 당연한거고,

엔터티는 반드시 2개 이상의 인스턴스를 가져야 한다.
→ 엔터티는 개별 데이터 하나가 아니라 인스턴스들의 집합이기 때문.

엔터티는 반드시 2개 이상의 속성을 가져야 한다.
→ 엔터티는 식별되고 설명될 수 있는 업무 정보를 가져야 하기 때문.

엔터티의 분류

유무형에 따른 분류

1. 유형 엔터티 - 물리적 존재 - 상품/사원/매장 등
2. 개념 엔터티 - 개념적 존재 - 부서/조직/학과 등
3. 사건 엔터티 - 행위로 발생 - 주문/결제/출입기록 등

발생 시점에 따른 분류

Step1. 기본 엔터티 - 다른 엔터티 없이도 성립 - 사원/부서/고객 Step2. 중심 엔터티 - 기본 엔터티에서 발생 - 주문/계약/매출 Step3. 행위 엔터티 - 2개 이상 엔터티의 관계에서 발생 - 주문상세/출고/입출금

정의

데이터 모델이란 현실 세계의 복잡한 정보를 컴퓨터에 저장하기 위해 그린 설계 도면이다

데이터 모델링의 3단계

추상적 개념 -> 구체적 구현 단계로 진행된다. 쉽게 암기 - '개-논-물'

Step1. 개념적 데이터 모델링 데이터 요구 사항을 분석해, 핵심 엔터티와 그들 간의 관계를 나타내는 ERD를 생성

Step2. 논리적 모델 속성, PK, FK 채움 + 정규화. DBMS와 무관

Step3. 물리적 모델 CREATE TABLE + 인덱스,파티션,자료형 명시

Step4. 데이터베이스 데이터가 차곡차곡 쌓인 상태. SQL로 조회,입력,수정

추가 개념 알 것들 - DBMS, 속성, PK, FK, 정규화화

DBMS란? DBMS = Database Management System
말 그대로 데이터베이스를 관리해주는 소프트웨어임. Oracle, MySQL 같은거

속성, PK, FK란? 속성 = 필드/칼럼 후보. 엔터티 세부 정보. (EX. 학생의 이름, 학과, 후보 등) PK = Primary Key = 주식별자. ID 정도로 기억해두면 됨 FK = Foreign Key = 외래식별자. 다른 테이블의 PK를 참조하는 컬럼

FK 상세 예시

학생 테이블

학생ID(PK) | 이름
----------|------
202401    | 김철수
202402    | 이영희

수강 테이블

수강ID(PK) | 학생ID(FK) | 과목명
----------|------------|------
1         | 202401     | 데이터베이스
2         | 202402     | 운영체제
3         | 202401     | 알고리즘

여기서 수강.학생ID는 FK.

정규화는? 정규화 = 테이블을 잘 쪼개서 중복과 이상현상을 줄이는 과정 한 테이블에 전부 때려박지 말고, 쪼개서 별도 테이블로 나누는 것.

정규화 상세 예시

수강정보라는 아래 테이블이 있다면

이를 학생/과목/수강 테이블로 쪼갤 수 있음

학생

학생ID(PK) | 학생명
----------|------
202401    | 김철수
202402    | 이영희
202403    | 박민수

과목

과목ID(PK) | 과목명       | 교수명
----------|--------------|------
C001      | 데이터베이스 | 홍길동
C002      | 운영체제     | 이몽룡

수강

학생ID(FK) | 과목ID(FK)
----------|----------
202401    | C001
202402    | C001
202403    | C002

정규화의 목적?

1. 데이터 중복 감소
2. 데이터 불일치 방지
3. 삽입 이상 방지
4. 삭제 이상 방지
5. 갱신 이상 방지

1,2는 위에서 다루었고,

3,4,5는

갱신 이상

같은 정보가 여러 곳에 있어서 하나만 수정되면 데이터가 불일치하는 문제.

C001 과목명이 어떤 행은 데이터베이스,어떤 행은 DB로 저장됨

삽입 이상

불필요한 정보가 없으면 필요한 정보를 넣지 못하는 문제.

아직 수강생이 없는 과목은 등록 못 함

삭제 이상

어떤 데이터를 삭제했더니 보존해야 할 정보까지 같이 사라지는 문제.

마지막 수강생을 삭제했더니 과목 정보도 사라짐

데이터 모델링의 3가지 관점

1. 데이터 관점
2. 프로세스 관점
3. 상관관계 관점

1은 무엇을 저장할지. 어떤 테이블? 컬럼? 테이블끼리의 관계? 를 생각하는 관점 2는 어떻게 처리할지. 이건 게시판으로 따지자면 글을 쓰고 수정하고 삭제될때의 유저 플로우 관점 3은 언제 데이터가 변하는지. 1과 2가 어우러져서, 어떤 프로세스에 어떤 데이터가 CRUD 되는지 보는 것임

좋은 데이터 모델의 특징

통합성 = 조직 전체에서 같은 의미의 데이터를 하나로 통합 관리하자

**업무 규칙 vs 의사소통**

업무 규칙 = 업무의 제약조건이 모델에 표현됨

의사소통 = 그 모델을 보고 사람들이 같은 의미로 이해함

### 3층 스키마 (ANSI/SPARC)

3층 스키마 ├─ 외부 스키마 │ └─ 사용자별 관점, View │ ├─ 개념 스키마 │ └─ 전체 DB의 논리적 구조 │ └─ 내부 스키마 └─ 실제 저장 방식, 인덱스, 파일 구조

``` 이것도 같은 데이터베이스를 세 가지 관점에서 본 것이다.

외부 -> 개념 -> 내부로 갈 수록 말 그대로 외부 인터페이스에서 내부 시스템으로 들어가는 것임

외부 = 사용자별 관점 개념 = 데이터 아키텍처 내부 = 데이터 관계

정도로 생각하면 된다

데이터 독립성 2가지

1. 논리적 독립성 - 개념 스키마가 변경되어도 외부 스키마는 영향이 없어야 함
2. 물리적 독립성 - 내부 스키마가 변경되어도 개념/외부 스키마는 영향이 없어야 함함

Python 기초 문법 복구
├─ Chunk 1: 변수 / 객체 / 참조 개념
├─ Chunk 2: 숫자 / 문자열 / bool
├─ Chunk 3: list / tuple
├─ Chunk 4: dict / set
├─ Chunk 5: 조건문 / 반복문
├─ Chunk 6: 함수
├─ Chunk 7: comprehension
├─ Chunk 8: 파일 읽기 / CSV 감각
├─ Chunk 9: 예외처리
├─ Chunk 10: 클래스 아주 가볍게
├─ Chunk 11: pandas 들어가기 전 Python 패턴

Exclude 타입은 다음과 같이 T로부터 U를 제거하는 타입임.

type A = Exclude<string | boolean, string>;
// 결과: boolean

직접 구현하면 다음과 같음.

type Exclude<T, U> = T extends U ? never : T;

Extract<T, K>

Extract 타입은 다음과 같이 T로부터 U를 추출하는 타입임.

type B = Extract<string | boolean, boolean>;
// 결과: boolean

직접 구현하면 다음과 같음.

type Extract<T, U> = T extends U ? T : never;

ReturnType

ReturnType은 타입변수 T에 할당된 함수 타입의 반환값 타입을 추출하는 타입임. 이 타입은 infer를 활용해 구현할 수 있음.

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

예시

function funcA() {
  return "hello";
}

function funcB() {
  return 10;
}

type ReturnA = ReturnType<typeof funcA>;
// 결과: string

type ReturnB = ReturnType<typeof funcB>;
// 결과: number

Pick은 특정 객체 타입에서 일부 프로퍼티만 골라내는 유틸리티 타입임.

예제

interface Post {
  title: string;
  tags: string[];
  content: string;
  thumbnailURL?: string;
}

const legacyPost: Pick<Post, "title" | "content"> = {
  title: "",
  content: "",
};

직접 구현

type Pick<T, K extends keyof T> = {
  [key in K]: T[key];
};

Omit<T, K>

Omit은 특정 객체 타입에서 일부 프로퍼티만 제외하는 유틸리티 타입임.

예제

const noTitlePost: Omit<Post, "title"> = {
  content: "",
  tags: [],
  thumbnailURL: "",
};

직접 구현

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

Record<K, V>

Record는 키-값 쌍을 가지는 객체 타입을 생성할 때 사용함.

예제

type Thumbnail = Record<
  "large" | "medium" | "small",
  { url: string }
>;

직접 구현

type Record<K extends keyof any, V> = {
  [key in K]: V;
};

선요약

타입스크립트의 Partial<T>, Required<T>, Readonly<T>는 맵드 타입 기반의 유틸리티 타입으로, 객체 타입의 프로퍼티를 선택적, 필수, 읽기 전용으로 변환함. 이들은 제네릭 + keyof + 맵드 타입의 조합으로 구현할 수 있음.

Partial

목적

객체 타입의 모든 프로퍼티를 선택적(optional)으로 변환함.

예시

interface Post {
  title: string;
  tags: string[];
  content: string;
  thumbnailURL?: string;
}

const draft: Partial<Post> = {
  title: "제목 나중에 짓자",
  content: "초안...",
};

구현

type Partial<T> = {
  [key in keyof T]?: T[key];
};

Required

목적

객체 타입의 모든 프로퍼티를 필수(required)로 변환함.

예시

interface Post {
  title: string;
  tags: string[];
  content: string;
  thumbnailURL?: string;
}

const withThumbnailPost: Required<Post> = {
  title: "한입 타스 후기",
  tags: ["ts"],
  content: "",
  thumbnailURL: "https://...",
};

구현

type Required<T> = {
  [key in keyof T]-?: T[key];
};

Readonly

목적

객체 타입의 모든 프로퍼티를 읽기 전용(readonly)으로 변환함.

예시

interface Post {
  title: string;
  tags: string[];
  content: string;
  thumbnailURL?: string;
}

const readonlyPost: Readonly<Post> = {
  title: "보호된 게시글입니다.",
  tags: [],
  content: "",
};

readonlyPost.content = "해킹당함"; // 오류 발생

구현

type Readonly<T> = {
  readonly [key in keyof T]: T[key];
};

마지막 요약

• Partial<T>: 모든 프로퍼티를 선택적으로 만듦 (?).
• Required<T>: 모든 선택적 프로퍼티를 필수로 만듦 (-?).
• Readonly<T>: 모든 프로퍼티를 읽기 전용으로 만듦 (readonly).
• 이들 모두 맵드 타입 + keyof + 제네릭 조합으로 구현 가능함.

• 유틸리티 타입은 타입스크립트가 제공하는 특수한 타입 조합 도구임.
• 제네릭, 맵드 타입, 조건부 타입 등을 조합해 자주 쓰이는 형태의 타입을 미리 구현해둔 것임.
• 대표적인 유틸리티 타입으로는 Readonly<T>, Partial<T> 등이 있음.
• 이번 섹션에서는 이들 중 핵심적인 타입만 다루며, 직접 구현도 병행함.

유틸리티 타입 소개

타입스크립트에서는 제네릭, 맵드 타입, 조건부 타입 등을 기반으로 실무에서 자주 사용되는 타입 조작 패턴을 미리 구현해둔 유틸리티 타입(Utility Types)을 제공함.

이들은 복잡한 타입을 짧고 직관적으로 표현하게 해 주며, 타입 안전성과 생산성을 동시에 확보할 수 있음.

예시 1: Readonly

Readonly<T>는 객체의 모든 프로퍼티를 읽기 전용(readonly)으로 변환함.

interface Person {
  name: string;
  age: number;
}

const person: Readonly<Person> = {
  name: "이정환",
  age: 27
};

person.name = ""; // ❌ 오류: 읽기 전용 프로퍼티

예시 2: Partial

Partial<T>는 객체의 모든 프로퍼티를 선택적(optional)으로 변환함.

interface Person {
  name: string;
  age: number;
}

const person: Partial<Person> = {
  name: "이정환"
};
// age는 생략 가능

유틸리티 타입의 핵심

타입스크립트는 수십 가지 유틸리티 타입을 기본 제공함. 그중 자주 쓰이는 타입들부터 숙지하면 실무 적용에 큰 도움이 됨.

공식 문서: 👉 https://www.typescriptlang.org/docs/handbook/utility-types.html

학습 방향

이번 섹션에서는 다음과 같은 방향으로 진행함:

• 맵드 타입 기반 유틸리티 타입: Readonly<T>, Partial<T> 등
• 조건부 타입 기반 유틸리티 타입: Exclude<T, U>, Extract<T, U> 등
• 직접 구현을 통해 유틸리티 타입의 원리와 작동 방식 이해

🧾 마지막 요약

• 유틸리티 타입은 타입 조작 기능의 집약체로, 복잡한 타입을 효율적으로 다룰 수 있게 함.
• 대표적인 타입으로 Readonly, Partial, Exclude, ReturnType 등이 있음.
• 다음 시간부터 실전 유틸리티 타입 구현을 병행하여 타입스크립트 고급 문법 숙련도를 높일 예정임.

• infer는 조건부 타입 안에서 특정 타입을 추론할 수 있게 해주는 타입스크립트의 특수 문법임.
• infer는 보통 조건부 타입 내부에서 사용되며, 추론 가능한 타입이 있을 경우 해당 타입을 바탕으로 분기된 타입 결과를 생성함.
• 대표적인 활용 예시로는 ReturnType<T> 과 PromiseUnpack<T> 등의 유틸리티 타입 구현이 있음.

infer로 ReturnType 구현하기

type ReturnType<T> = T extends () => infer R ? R : never;

infer R은 함수 타입 T의 반환값을 추론해 R로 잡겠다는 의미임. 예시를 보자.

type FuncA = () => string;
type FuncB = () => number;

type A = ReturnType<FuncA>; // string
type B = ReturnType<FuncB>; // number

타입 변수 T에 함수 타입을 넣으면 해당 함수의 반환값 타입을 infer R이 추론하게 됨.
즉 FuncA는 () => string 타입이므로 R은 string이 되고, 따라서 A는 string 타입이 됨.

추론 실패 시

type C = ReturnType<number>; // never

이 경우에는 number 타입은 함수 타입이 아니므로 조건식을 만족하지 않음.
결과적으로 ReturnType<number>는 never 타입이 됨.

infer로 Promise의 결과 타입 추출하기

type PromiseUnpack<T> = T extends Promise<infer R> ? R : never;

PromiseUnpack은 Promise<T> 타입으로부터 내부의 T 타입을 꺼내오는 유틸리티 타입임.

예시:

type PromiseA = PromiseUnpack<Promise<number>>; // number
type PromiseB = PromiseUnpack<Promise<string>>; // string

infer R을 통해 Promise<number>는 number 타입이 추론되고, 최종적으로 PromiseUnpack<Promise<number>>는 number가 됨.

🧩 마지막 요약

• infer는 조건부 타입 내에서 특정 타입을 추론할 때 사용함.
• 일반적으로 유틸리티 타입에서 많이 활용됨 (예: ReturnType, Parameters, PromiseUnpack 등).
• 조건식이 성립하지 않으면 never 타입으로 수렴됨.

✅ 선요약

• 조건부 타입에 유니온 타입을 넣으면 각 요소에 대해 조건이 개별로 평가되는 분산 조건부 타입이 작동함.
• 이를 이용해 Exclude, Extract 등 다양한 유틸리티 타입을 직접 구현 가능함.

조건부 타입 복습

type StringNumberSwitch<T> = T extends number ? string : number;

let a: StringNumberSwitch<number>;  // string
let b: StringNumberSwitch<string>;  // number

분산 조건부 타입의 등장

type StringNumberSwitch<T> = T extends number ? string : number;

let c: StringNumberSwitch<number | string>; 
// 결과: string | number

❓ 왜 이런 결과가 나옴?

• 조건부 타입의 타입 변수에 Union 타입이 들어가면, 조건이 각 요소별로 분리되어 평가됨.
• 이를 분산 조건부 타입이라 함.

분산 과정:

1. 타입 분해:

   StringNumberSwitch<number>     // string
   StringNumberSwitch<string>     // number

2. 결과 결합:

   string | number

Exclude 조건부 타입 구현

type Exclude<T, U> = T extends U ? never : T;

type A = Exclude<number | string | boolean, string>; 
// 결과: number | boolean

계산 흐름:

1. 타입 분리:

   Exclude<number, string>   // number
   Exclude<string, string>   // never
   Exclude<boolean, string>  // boolean

2. 결과 결합:

   number | never | boolean → number | boolean

never는 공집합이므로 Union에서 자동 제거됨

🧠 마지막 요약

• 조건부 타입에 유니온을 전달하면 자동으로 분산 평가됨.
• 이를 활용하면 타입 연산에서 필터링, 매핑 같은 고급 기능을 구현할 수 있음.
• Exclude<T, U>는 T에서 U에 해당하는 타입만 제거함.

조건부 타입은 extends와 삼항 연산자(? :)를 활용해 타입을 상황에 따라 다르게 설정할 수 있게 해줌. 특히 제네릭과 함께 사용할 때 매우 강력하며, 값의 타입에 따라 반환 타입을 유연하게 조절할 수 있음. 타입스크립트의 타입 로직에 논리적 분기를 넣을 수 있다는 점이 핵심임.

1. 조건부 타입 기본 문법

type A = number extends string ? number : string; 
// A → string

number가 string의 서브타입인지 여부에 따라 결과가 달라짐. 위 예시는 false가 되어 A는 string이 됨.

type ObjA = { a: number };
type ObjB = { a: number; b: number };

type B = ObjB extends ObjA ? number : string;
// B → number (ObjB는 ObjA의 슈퍼셋)

2. 제네릭 조건부 타입

type StringNumberSwitch<T> = T extends number ? string : number;

let varA: StringNumberSwitch<number>; // string
let varB: StringNumberSwitch<string>; // number

타입 변수 T가 number면 결과는 string, 아니면 number가 됨.

3. 조건부 타입 실전 예제

function removeSpaces<T>(text: T): T extends string ? string : undefined {
  if (typeof text === "string") {
    return text.replaceAll(" ", "") as any;
  } else {
    return undefined as any;
  }
}

• removeSpaces("hello world") → string
• removeSpaces(undefined) → undefined

하지만 위 방식은 as any 때문에 타입 안정성이 깨질 수 있음. 예를 들어 string이 아닌 값을 반환해도 타입 검사를 통과함.

4. 함수 오버로딩으로 해결

function removeSpaces<T>(text: T): T extends string ? string : undefined;
function removeSpaces(text: any) {
  if (typeof text === "string") {
    return text.replaceAll(" ", "");
  } else {
    return undefined;
  }
}

let result = removeSpaces("hi im winterlood"); // string
let result2 = removeSpaces(undefined);         // undefined

오버로딩을 사용하면 조건부 타입의 결과를 실제로 타입스크립트가 추론할 수 있게 되므로, as any 없이도 타입 안정성을 확보할 수 있음.

🔁 마지막 정리

• 조건부 타입은 타입에 if-else 같은 논리를 넣을 수 있게 해주는 기능임.
• A extends B ? C : D 형식으로 작성하며, 특히 제네릭과 함께 강력함.
• as any보다는 함수 오버로딩을 통한 추론이 더 안전하고 실용적임.
• 실제 사용 예시로 입력 타입에 따라 다른 반환 타입을 가질 수 있는 함수를 구현할 수 있음.

선요약

템플릿 리터럴 타입은 문자열 패턴을 조합해 새로운 문자열 리터럴 유니온 타입을 만드는 타입스크립트의 타입 조작 기능임. 여러 문자열 유니온 타입을 조합할 때 반복적인 수작업 없이 효율적으로 조합 가능함.

템플릿 리터럴 타입이란?

템플릿 리터럴 타입은 타입 조작 기능 중 가장 단순한 기능으로, 템플릿 리터럴 문법을 이용해 특정 패턴을 갖는 문자열 타입을 만드는 기능임.

type Color = "red" | "black" | "green";
type Animal = "dog" | "cat" | "chicken";

위와 같은 코드에서 아래와 같이 모든 조합의 문자열 리터럴 타입을 만들고 싶다고 가정함:

type ColoredAnimal =
  | "red-dog"
  | "red-cat"
  | "red-chicken"
  | "black-dog"
  | "black-cat"
  | "black-chicken"
  | "green-dog"
  | "green-cat"
  | "green-chicken";

위처럼 수작업으로 만들면 타입이 늘어날수록 불편하고 오류 가능성도 커짐. 이럴 때 템플릿 리터럴 타입을 쓰면 다음처럼 간단하게 표현 가능함:

type ColoredAnimal = `${Color}-${Animal}`;

• Color의 모든 값과 Animal의 모든 값을 문자열로 조합한 유니온 타입이 자동으로 생성됨
• ${} 안에는 타입 변수 또는 타입 이름을 넣을 수 있음

예시 응용

특정 접두어 붙이기

type Prefix = "pre";
type Word = "load" | "view";

type PrefixedWord = `${Prefix}_${Word}`;
// "pre_load" | "pre_view"

이벤트 핸들러 이름 만들기

type Event = "click" | "hover";
type HandlerName = `on${Capitalize<Event>}`;
// "onClick" | "onHover"

• Capitalize<T>: 첫 글자를 대문자로 바꿔줌
• Uncapitalize<T>: 첫 글자를 소문자로 바꿔줌
• Uppercase<T>, Lowercase<T>: 대문자화, 소문자화

주의사항

• 템플릿 리터럴 타입은 컴파일 타임에 조합됨 → 런타임에는 영향을 주지 않음
• ${} 내부에 값(value)을 넣는 것이 아니라 타입을 넣는 것임
• 리터럴 유니온 타입이 너무 많아지면 타입 추론이 느려질 수 있음

마지막 요약

템플릿 리터럴 타입은 문자열 리터럴 조합을 자동화하여, 복잡한 유니온 타입을 간결하고 안전하게 생성할 수 있게 해주는 타입스크립트의 문법임. 반복적인 문자열 타입 정의를 줄이고, 패턴 기반의 타입 생성이 필요한 상황에서 특히 유용함.

요약

맵드 타입(mapped type)은 기존 객체 타입을 기반으로 새로운 객체 타입을 유연하게 생성할 수 있는 타입스크립트의 기능임. keyof, 인덱스드 엑세스 타입 등과 결합해 중복 없이 코드를 간결하게 유지할 수 있음.

기본 예시

interface User {
  id: number;
  name: string;
  age: number;
}

// 수정 가능한 필드를 선택적으로 만들고 싶을 때
type PartialUser = {
  [key in "id" | "name" | "age"]?: User[key];
};

이 맵드 타입은 다음과 같은 결과 타입이 됨:

{
  id?: number;
  name?: string;
  age?: number;
}

'keyof`와 결합

type PartialUser = {
  [key in keyof User]?: User[key];
};

keyof User는 "id" | "name" | "age"와 같기 때문에 위와 동일한 결과 타입이 생성됨.

읽기 전용 타입 만들기

type ReadonlyUser = {
  readonly [key in keyof User]: User[key];
};

→ 모든 프로퍼티를 readonly로 변환한 새 타입이 생성됨.

활용 예시

기존 타입을 기반으로:

• 모든 프로퍼티를 선택적(optional) 으로 만들거나,
• 모든 프로퍼티를 읽기 전용(readonly) 으로 만들거나,
• 특정 키만 골라서 부분적으로 정의된 타입을 만들 수 있음.

이러한 방식으로 유지보수와 확장성이 매우 뛰어난 타입 정의가 가능해짐.

요약 정리

• 맵드 타입은 반복되는 타입 정의를 자동화함
• keyof, 인덱스드 엑세스 타입 등과 함께 사용하면 강력한 타입 변환기가 됨
• 실무에서 자주 사용되는 패턴임 (Partial, Readonly, Pick, Record 등이 전부 맵드 타입으로 구현되어 있음)

• keyof 연산자는 객체 타입에서 모든 프로퍼티 키를 문자열 리터럴 유니온 타입으로 추출함.
• 수동으로 "name" | "age" 같은 키 목록을 명시하지 않고, 타입에서 자동 추출할 수 있어 유지보수에 용이함.
• keyof는 타입에만 적용 가능하며, 값에는 사용할 수 없음.
• typeof와 함께 사용하면 실제 변수의 타입 구조로부터 키를 추출하는 것도 가능함.

Keyof 연산자

keyof 연산자는 객체 타입으로부터 프로퍼티의 모든 key들을 String Literal Union 타입으로 추출하는 연산자임.

다음은 keyof 연산자를 사용하는 예시임.

interface Person {
  name: string;
  age: number;
}

function getPropertyKey(person: Person, key: "name" | "age") {
  return person[key];
}

이렇게 키를 명시하면 Person 타입이 바뀔 때마다 "name" | "age"를 함께 바꿔줘야 하는 번거로움이 생김.

interface Person {
  name: string;
  age: number;
  location: string; // 추가됨
}

function getPropertyKey(person: Person, key: "name" | "age" | "location") {
  return person[key];
}

이럴 때 keyof 연산자를 쓰면 유지보수가 쉬워짐.

interface Person {
  name: string;
  age: number;
  location: string;
}

function getPropertyKey(person: Person, key: keyof Person) {
  return person[key];
}

keyof Person의 결과는 "name" | "age" | "location"이 됨.

주의할 점: keyof는 값이 아닌 타입에만 적용할 수 있음.

function getPropertyKey(person: Person, key: keyof person) { // ❌ 오류
  return person[key];
}

Typeof와 Keyof 함께 사용하기

typeof 연산자는 값을 기반으로 타입을 추론할 수 있게 해주는 타입스크립트의 기능임.

const person = {
  name: "이정환",
  age: 27,
  location: "서울"
};

type Person = typeof person;
// Person 타입은 { name: string; age: number; location: string }이 됨

이걸 활용해 keyof와 함께 쓰면 다음과 같이 사용 가능함.

function getPropertyKey(person: typeof person, key: keyof typeof person) {
  return person[key];
}

이렇게 하면 변수의 구조에 따라 자동으로 키 타입이 추출되므로 더 안정적이고 유연한 타입 선언이 가능함.

마지막 요약

• keyof는 타입으로부터 프로퍼티 키들을 추출해 유니온 타입으로 만듦.
• typeof는 변수로부터 타입을 추론함.
• 둘을 함께 사용하면 유지보수와 타입 안정성을 모두 챙길 수 있음.

• 인덱스드 엑세스 타입은 객체, 배열, 튜플에서 특정 속성의 타입을 추출할 때 사용함.
• 문법은 타입명["프로퍼티명"] 또는 타입명[숫자] 형태로 사용함.
• 객체 속성 변경 시 매개변수 타입도 자동 반영 가능함.
• 유효하지 않은 인덱스 사용 시 오류 발생함.
• 배열/튜플의 요소 타입을 추출하여 재사용하거나 제네릭화할 수 있음.

인덱스드 엑세스 타입

인덱스드 엑세스 타입은 인덱스를 이용해 다른 타입내의 특정 프로퍼티의 타입을 추출하는 타입임. 객체, 배열, 튜플에 모두 사용할 수 있음.

객체 프로퍼티의 타입 추출

interface Post {
  title: string;
  content: string;
  author: {
    id: number;
    name: string;
    age: number;
  };
}

function printAuthorInfo(author: Post["author"]) {
  console.log(`${author.id} - ${author.name}`);
}

• Post["author"]는 Post 타입에서 author 프로퍼티의 타입을 추출함.
• 인덱스는 문자열 리터럴 타입만 가능하며, 변수 사용은 불가함.

const authorKey = "author";
function printAuthorInfo(author: Post[authorKey]) { // ❌ 오류 발생
  console.log(`${author.id} - ${author.name}`);
}

• 존재하지 않는 프로퍼티에 접근하려고 하면 오류 발생함.

중첩 접근도 가능함.

function printAuthorInfo(authorId: Post["author"]["id"]) {
  console.log(authorId);
}

배열 요소 타입 추출

type PostList = Post[];
const post: PostList[number] = {
  title: "게시글 제목",
  content: "게시글 본문",
  author: {
    id: 1,
    name: "이정환",
    age: 27,
  },
};

• PostList[number]는 배열의 요소 타입을 추출함.
• PostList[0]처럼 숫자 리터럴을 써도 동일하게 동작함.

튜플의 요소 타입 추출

type Tup = [number, string, boolean];

type Tup0 = Tup[0]; // number
type Tup1 = Tup[1]; // string
type Tup2 = Tup[2]; // boolean
type Tup3 = Tup[number]; // number | string | boolean

• 튜플에 number 인덱스를 넣으면 모든 요소의 유니온 타입이 추출됨.

요약

• 인덱스드 엑세스 타입은 객체나 배열/튜플에서 타입을 추출하여 재사용할 때 유용함.
• 중복 정의를 피하고 타입 변화에 유연하게 대응할 수 있음.
• 배열 요소 타입은 [number], 튜플은 [숫자] 또는 [number]로 유니온 처리됨.

타입스크립트에서 타입 조작이란 기존 타입(기본 타입, 인터페이스, 타입 별칭 등)을 상황에 따라 동적으로 변형하는 기능을 의미함. 주요 도구로는 인덱스드 엑세스 타입, keyof 타입, 맵드 타입, 템플릿 리터럴 타입 등이 있으며, 제네릭 또한 타입 조작의 일부로 볼 수 있음. 이 기능들은 실무에서 유용하게 사용되며, 코드의 재사용성과 유연성을 크게 향상시킴.

타입 조작이란

타입을 조작한다는 것은 기존의 기본 타입이나 별칭, 인터페이스로 만들어진 타입들을 상황에 따라 유동적으로 다른 타입으로 변형하는 기능임. 이는 타입스크립트의 강력하고 독특한 기능 중 하나임.

이전에 배운 제네릭 또한 함수나 인터페이스, 타입 별칭, 클래스 등에 적용해서 상황에 따라 달라지는 타입을 정의할 수 있기 때문에 타입 조작 기능의 일종임. 다만 그 내용이 방대해 따로 분리해 학습했음.

타입스크립트는 제네릭 외에도 여러가지 타입 조작 기능을 제공함. 이번 섹션에서는 제네릭과 다음에 다룰 조건부 타입을 제외한 4가지 대표적 타입 조작 기능을 정리함:

1. 인덱스드 엑세스 타입

객체, 배열, 튜플 등의 타입에서 특정 프로퍼티나 요소의 타입만 추출할 수 있게 함.
예시: type NameType = User["name"] → User 타입의 name 프로퍼티 타입만 따로 추출함.

2. keyof 타입

객체 타입 내의 프로퍼티 이름들을 문자열 리터럴 유니온 타입으로 추출함.
예시: type UserKeys = keyof User → "name" | "age" | "email" 같은 유니온 타입이 됨.

3. 맵드 타입

기존 객체 타입을 기반으로 새로운 객체 타입을 정의함. 자바스크립트의 map 함수와 유사한 역할을 함.
예시: 모든 프로퍼티를 optional 하게 바꾸는 타입을 정의할 수 있음.
type Partial<T> = { [P in keyof T]?: T[P] }

4. 템플릿 리터럴 타입

기존 문자열 리터럴 타입을 기반으로 정해진 패턴의 문자열만 포함하는 타입을 만들 수 있음.
예시:
type Color = "red" | "blue"
type BrightColor = \bright-${Color}`→ "bright-red" | "bright-blue"

이러한 기능들은 단순한 문법 외에도, 실무에서 어떤 상황에 이 기능을 써야 효과적인지를 이해하는 것이 중요함. 각 기능들은 심플하지만 실전에서 자주 쓰일 수 있는 예제들과 함께 학습할 예정임.

요약

• 타입 조작이란 기존 타입들을 변형하여 새로운 타입을 만들어내는 기능임.
• 대표적 조작 도구: 인덱스드 엑세스 타입, keyof, 맵드 타입, 템플릿 리터럴 타입.
• 제네릭도 타입 조작의 일종으로 간주함.
• 이런 기능들은 코드의 유연성, 재사용성, 안전성을 높이는데 매우 유용함.

• Promise<T>는 제네릭 클래스로, resolve의 결과값 타입을 T로 설정할 수 있다.
• reject의 값은 타입을 지정할 수 없으며, 기본적으로 unknown이다.
• then() 메서드는 resolve 값을, catch() 메서드는 reject 값을 다룬다.
• 함수의 반환 타입으로 Promise<타입>을 명시하여 비동기 작업의 결과 타입을 선언할 수 있다.

Promise 사용하기

Promise는 제네릭 클래스로 구현되어 있다. 따라서 새로운 Promise를 생성할 때 다음과 같이 타입 변수에 할당할 타입을 직접 설정해 주면 해당 타입이 바로 resolve 결과값의 타입이 됨.

const promise = new Promise<number>((resolve, reject) => {
  setTimeout(() => {
    // 결과값 : 20
    resolve(20);
  }, 3000);
});

promise.then((response) => {
  // response는 number 타입
  console.log(response);
});

promise.catch((error) => {
  if (typeof error === "string") {
    console.log(error);
  }
});

❗ reject 함수에 전달된 값의 타입은 지정할 수 없고, 타입스크립트에서는 기본적으로 unknown으로 처리되므로, catch에서 타입 좁히기를 통해 안전하게 다뤄야 함.

함수에서 Promise 반환

어떤 함수가 Promise 객체를 반환한다면 함수의 반환 타입으로 Promise<타입>을 지정해야 함.

function fetchPost() {
  return new Promise<Post>((resolve, reject) => {
    setTimeout(() => {
      resolve({
        id: 1,
        title: "게시글 제목",
        content: "게시글 본문",
      });
    }, 3000);
  });
}

또는 더 명확하게 반환 타입을 다음과 같이 직접 명시해도 됨.

function fetchPost(): Promise<Post> {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve({
        id: 1,
        title: "게시글 제목",
        content: "게시글 본문",
      });
    }, 3000);
  });
}

요약

• Promise<T>는 비동기 작업의 성공 결과를 T로 선언할 수 있도록 해주는 제네릭 클래스이다.
• reject() 결과값은 unknown으로 취급되므로 타입 확인이 필요하다.
• 함수 반환 타입으로 Promise<타입>을 사용하면 타입 안정성이 높아진다.

class NumberList {
  constructor(private list: number[]) {}

  push(data: number) {
    this.list.push(data);
  }

  pop() {
    return this.list.pop();
  }

  print() {
    console.log(this.list);
  }
}

const numberList = new NumberList([1, 2, 3]);

❌ 비효율적인 클래스 중복 정의

StringList도 필요하다면 클래스 정의를 중복하게 됨.

class StringList {
  constructor(private list: string[]) {}

  push(data: string) {
    this.list.push(data);
  }

  pop() {
    return this.list.pop();
  }

  print() {
    console.log(this.list);
  }
}

const numberList = new NumberList([1, 2, 3]);
const stringList = new StringList(["1", "2", "3"]);

이렇게 되면 코드 중복이 심하고 유지보수도 어려워짐.

✅ 제네릭 클래스로 개선하기

다음과 같이 제네릭을 적용해 다양한 타입의 리스트를 처리할 수 있는 범용 클래스를 만들 수 있음.

class List<T> {
  constructor(private list: T[]) {}

  push(data: T) {
    this.list.push(data);
  }

  pop() {
    return this.list.pop();
  }

  print() {
    console.log(this.list);
  }
}

const numberList = new List([1, 2, 3]);
const stringList = new List(["1", "2"]);

🎯 타입 명시적으로 지정하기

타입 추론이 가능하지만 명시적으로 타입을 지정할 수도 있음.

const numberList = new List<number>([1, 2, 3]);
const stringList = new List<string>(["1", "2"]);

이처럼 제네릭 클래스는 코드 중복을 줄이고 다양한 타입을 유연하게 처리할 수 있어 효율적.

• 제네릭은 인터페이스, 타입 별칭, 함수 등에 적용 가능
• 제네릭 인터페이스는 다양한 타입을 유연하게 표현할 수 있음
• 인덱스 시그니처, 유니온 타입, 조건 분기, 함수 매개변수 제한 등 실용도가 높음
• 타입 추론은 불가하므로 반드시 타입 인자를 명시해야 함

📌 기본 제네릭 인터페이스

interface KeyPair<K, V> {
  key: K;
  value: V;
}

let keyPair: KeyPair<string, number> = {
  key: "key",
  value: 0,
};

let keyPair2: KeyPair<boolean, string[]> = {
  key: true,
  value: ["1"],
};

📌 인덱스 시그니처 + 제네릭

interface Map<V> {
  [key: string]: V;
}

let stringMap: Map<string> = {
  key: "value",
};

let booleanMap: Map<boolean> = {
  key: true,
};

📌 제네릭 타입 별칭

type Map2<V> = {
  [key: string]: V;
};

let stringMap2: Map2<string> = {
  key: "string",
};

✅ 제네릭 인터페이스 활용 예

타입 정의

interface Student {
  type: "student";
  school: string;
}

interface Developer {
  type: "developer";
  skill: string;
}

제네릭 적용 전

interface User {
  name: string;
  profile: Student | Developer;
}

function goToSchool(user: User) {
  if (user.profile.type !== "student") {
    console.log("잘 못 오셨습니다");
    return;
  }

  const school = user.profile.school;
  console.log(`${school}로 등교 완료`);
}

제네릭 적용 후

interface User<T> {
  name: string;
  profile: T;
}

function goToSchool(user: User<Student>) {
  const school = user.profile.school;
  console.log(`${school}로 등교 완료`);
}

const developerUser: User<Developer> = {
  name: "이정환",
  profile: {
    type: "developer",
    skill: "TypeScript",
  },
};

const studentUser: User<Student> = {
  name: "홍길동",
  profile: {
    type: "student",
    school: "가톨릭대학교",
  },
};

✅ 마무리

제네릭 인터페이스는 객체 설계 시
다양한 타입을 유연하고 안전하게 다룰 수 있게 해주는 도구다.
함수, 타입 별칭, 조건 분기, 인덱스 구조 등과 조합하여 쓰면 매우 강력하다.