기본 문법

TypeScript의 기본 문법을 정리해보겠습니다.

타입 지정

TypeScript는 변수, 함수, 매개변수 등에 타입을 명시적으로 지정할 수 있습니다.

  
function add(a: number, b: number): number {
  return a + b;
}

기본 타입

string, number, boolean, null, undefined 등

  
// 문자열
let name: string = "Alice";

// 숫자
let age: number = 25;

// 불리언
let isActive: boolean = true;

// null
let emptyValue: null = null;

// undefined
let notAssigned: undefined = undefined;

// bigint
let bigNumber: bigint = 9007199254740991n;

// symbol
let uniqueKey: symbol = Symbol("key");

객체 타입

[](array), {}(object) 등

  
// 배열
let arr1: number[] = [90, 80, 70];
let arr2: Array<number> = [90, 80, 70];

// 객체
let obj: object = { key: "value" };
let obj: { key: string } = { key: "value" };

// 튜플
let tuple: [string, number] = ["Alice", 25];

특수 타입

any : 모든 타입 허용
unknown : 모든 타입 허용. 단, 사전 타입 검사 필요
void : 반환 값이 없는 함수의 반환 타입
never : 값이 반환 되지 않는 함수

  
// any
let anything: any = "Hello";

// unknown
let data: unknown = 42;
if (typeof data === "number") {
  console.log(data + 1);
}

// void
function logMessage(): void {
  console.log("Hello, World!");
}

// never
function throwError(message: string): never {
  throw new Error(message);
}

유니언 타입 Union

여러 타입을 허용할 수 있습니다.

  
let value: string | number;

value = "Hello";
value = 42;

리터럴 타입

특정 값만 지정할 수

문자열 리터럴 타입

특정 문자열 값만 허용.

  
let direction: "left" | "right";

direction = "left";

숫자 리터럴 타입

특정 숫자 값만 허용.

  
let count: 1 | 2 | 3;

count = 2;

불리언 리터럴 타입
true 또는 false만 허용.
1 let isActive: true | false;

사용자 정의 타입

인터페이스 Interface

객체의 구조를 정의할 때 사용할 수 있습니다.

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

let user: User = { name: "Bob", age: 30 };

타입 별칭 Type Alias

반복되는 타입 정의를 별칭으로 사용할 수 있습니다.

  
type Point = { x: number; y: number };

let p: Point = { x: 10, y: 20 };

유틸리티 타입 Utility Types

TypeScript는 편리한 유틸리티 타입을 제공합니다.

Partial<T> : 모든 필드를 선택적으로 만듭니다.
Readonly<T> : 모든 필드를 읽기 전용으로 만듭니다.
Pick<T, K> : 객체에서 특정 타입 T에서 프로퍼티 K만 선택하여 새로운 타입을 생성합니다.
Omit<T, K> : 객체에서 특정 타입 T에서 프로퍼티 K를 제외한 새로운 타입을 생성합니다.

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

const partialUser: Partial<User> = { name: "Alice" }; // age 생략 가능

const readonlyUser: Readonly<User> = { name: "Alice", age: 30 };
readonlyUser.name = "Bob"; // error : 읽기 전용 속성

type UserName = Pick<User, "name" | "age">; // { name: string; age: number; }

type NonAgeUser = Omit<User, "age">; // { name: string; }

Partial, Pick, Omit 등은 목적이 명확하므로 적절히 사용하면 유용합니다.

제네릭 Generics

다양한 타입을 처리할 수 있는 재사용 가능한 구성 요소를 만드는 데 사용됩니다.

즉, 타입을 코드를 작성할 때 지정하지 않고, 사용할 때 제공할 수 있습니다.

  
function identity<T>(value: T): T {
  return value;
}

console.log(identity<number>(123)); // 123

function pair<T, U>(a: T, b: U): [T, U] {
  return [a, b];
}

const result = pair<string, number>("Alice", 30);
// result의 타입: [string, number]

T는 제네릭 타입 변수로, 호출 시 전달된 타입으로 대체됩니다.