배경 이미지
728x90
반응형

1. Hooks란 무엇인가?

Hooks는 React 16.8 버전에서 도입된 기능으로, 함수형 컴포넌트에서도 상태와 생명 주기를 쉽게 관리할 수 있게 해준다. 가장 자주 쓰는 두 가지 Hooks를 소개해보자(이 외에도 useMemo, useContext 등이 있다)

  1. useState: 컴포넌트의 상태(state)를 관리할 수 있는 hook . 클래스 컴포넌트에서 this.state 대신 쓰는 기능이다.
const [name, setName] = useState(''); // name이라는 상태를 만들고 초기값을 ''로 설정

 

2. useEffect: 렌더링 후 side effects를 처리할 수 있도록 설계된  hook. 컴포넌트가 처음 나타날 때나 업데이트될 때, 또는 사라질 때 특정 작업을 할 수 있게 해준다. 생명 주기를 대신한다고 생각하면 된다.useEffect는 두 번째 인자로 빈 배열([])을 넣으면 컴포넌트가 처음 나타날 때 한 번만 실행된다. 만약 상태가 변경될 때도 실행하고 싶다면, 그 상태를 배열에 넣으면 된다.

useEffect(() => { // 이 코드는 컴포넌트가 처음 나타날 때 실행된다. }, []);

 

2. React Hooks가 왜 필요한가?

먼저 React는 컴포넌트라는 작은 조각들을 모아서 화면을 만든다. 이 컴포넌트는 크게 두 가지 방식으로 만들 수 있다:

  1. 클래스 컴포넌트: 예전 방식으로 더 복잡하고 길지만, 다양한 기능을 제공한다.
  2. 함수형 컴포넌트: 더 간단하고 코드가 짧지만, 예전에는 기능이 제한적이었다.

React가 처음에는 클래스 컴포넌트만으로 복잡한 기능을 구현했지만, 코드가 길어지고 반복되는 부분이 많았다. 그래서 React 팀은 더 간단한 함수형 컴포넌트에서도 강력한 기능을 쓸 수 있도록 Hooks라는 기능을 만들었다.


3. 클래스 컴포넌트 vs 함수형 컴포넌트

클래스 컴포넌트 예시

import React, { Component } from 'react';
import Axios from 'axios';

export default class Hello extends Component {
  constructor(props) {
    super(props);
    this.state = { name: '' };  // state 초기화
  }

  // 컴포넌트가 처음 마운트될 때 (화면에 나타날 때)
  componentDidMount() {
    Axios.get('/api/user/name')
      .then(response => {
        this.setState({ name: response.data.name }); // API에서 받은 데이터를 state에 저장
      });
  }

  render() {
    return (
      <div>
        My name is {this.state.name}
      </div>
    );
  }
}

함수형 컴포넌트 + Hooks 예시

import React, { useState, useEffect } from 'react';
import Axios from 'axios';

export default function Hello() {
  const [name, setName] = useState(''); // useState로 상태 관리

  // useEffect로 생명 주기와 비슷한 기능 구현
  useEffect(() => {
    Axios.get('/api/user/name')
      .then(response => {
        setName(response.data.name);  // API에서 받은 데이터를 state에 저장
      });
  }, []); // 빈 배열을 넣으면 처음 한 번만 실행

  return (
    <div>
      My name is {name}
    </div>
  );
}

비교

  • 클래스 컴포넌트는 상태를 관리하기 위해 this.state, constructor, componentDidMount, render 와 같은 메서드를 각각 사용한다. 생명 주기 함수라는 개념도 필요하다.
  • 반면, Hooks를 사용하는 함수형 컴포넌트는 useState와 useEffect만 있으면 훨씬 짧고 간단한 코드로 같은 기능을 구현할 수 있다.

+) React 생명 주기란?

React 컴포넌트는 화면에 나타날 때, 업데이트될 때, 사라질 때 특정 작업을 할 수 있다. 이를 생명 주기라고 부른다.

  • Mounting(마운팅): 컴포넌트가 화면에 처음 나타날 때 (componentDidMount).
  • Updating(업데이트): 컴포넌트가 변경되거나 다시 그려질 때 (componentDidUpdate).
  • Unmounting(언마운팅): 컴포넌트가 화면에서 사라질 때 (componentWillUnmount).

이런 생명 주기를 클래스 컴포넌트에서는 각각의 함수로 관리했지만, Hooks를 사용하면 useEffect 하나로 해결할 수 있다.


4. Custom Hook (사용자 정의 훅)이란?

Custom Hook은 반복되는 로직을 하나의 함수로 만들어서, 여러 컴포넌트에서 쉽게 재사용할 수 있게 해주는 기능이다.

Custom Hook 예시: useAuth

import { useState, useEffect } from 'react';
import Axios from 'axios';

function useAuth() {
  const [user, setUser] = useState(null);

  useEffect(() => {
    Axios.get('/api/user')
      .then(response => {
        setUser(response.data);
      });
  }, []);

  return user;
}

// 이 Hook을 여러 컴포넌트에서 사용할 수 있다.
export default function Profile() {
  const user = useAuth();

  if (!user) return <div>Loading...</div>;

  return <div>Welcome, {user.name}!</div>;
}

Custom Hook의 장점

  • 여러 컴포넌트에서 같은 로직을 반복하지 않고 재사용할 수 있다.
  • 코드가 훨씬 깔끔해지고 유지보수가 쉬워진다.

5. 정리

  • React Hooks는 함수형 컴포넌트에서 상태와 생명 주기를 간단하게 관리할 수 있는 도구다.
  • 클래스 컴포넌트보다 코드가 짧고 이해하기 쉽다.
  • useState로 상태를 관리하고, useEffect로 생명 주기 작업을 처리할 수 있다.
  • Custom Hook을 이용하면 여러 컴포넌트에서 반복되는 코드를 재사용할 수 있다.

 

끝😊

728x90
반응형
728x90
반응형

[ for반복문]

  • 반복 횟수를 정확하게 제어할 때.
  • 배열의 인덱스를 직접 사용해서 반복할 때.

예시: 배열 순회

let fruits = ['apple', 'banana', 'orange'];

for (let i = 0; i < fruits.length; i++) {
    console.log(fruits[i]); // 'apple', 'banana', 'orange'
}

 

예시: 숫자 출력

for (let i = 1; i <= 5; i++) {
  console.log(i);  // 1, 2, 3, 4, 5 출력
}

 

 

[ for...in 반복문]

  • 객체의 키 또는 배열의 인덱스를 반복.
  • 객체배열의 프로퍼티 이름을 반복하고 싶을 때 사용.

예시: 객체의 키 순회

let person = {
  name: 'Alice',
  age: 25,
  city: 'New York'
};

for (let key in person) {
  console.log(key);         // 'name', 'age', 'city' 출력
  console.log(person[key]);  // 'Alice', 25, 'New York' 출력
}

 

예시: 배열의 인덱스 순회

let arr = ['a', 'b', 'c'];

for (let index in arr) {
  console.log(index);  // 0, 1, 2 출력 (인덱스)
  console.log(arr[index]);  // 'a', 'b', 'c' 출력 (값)
}

 

[for …of 반복문]

  • 배열, Set, Map 등 이터러블 객체의 값을 반복 ( for of 구문을 사용하기 위해선 컬렉션 객체가 [Symbol.iterator] 속성을 가지고 있어야 한다)
  • 을 직접 다루고 싶을 때 사용.
더보기

iterator는 반복자라는 말이에요. 요소 하나하나를 반복할 수 있도록 배열 또는 객체와 비슷한 형태로 열거되어있는 자료구조로 이해해주시면 돼요.

 

예시: 배열의 값 순회

let arr = ['a', 'b', 'c'];

for (let value of arr) {
  console.log(value);  // 'a', 'b', 'c' 출력
}

 

예시: Map 순회

const myMap = new Map();
myMap.set('one', 1);
myMap.set('two', 2);

for (const key of myMap.keys()) {
  console.log(key);   // 'one', 'two'
}

for (const value of myMap.values()) {
  console.log(value);  // 1, 2
}

for (const entry of myMap.entries()) {
  console.log(`${entry[0]}: ${entry[1]}`);     // 'one: 1', 'two: 2'
}

 

예시: Set 순회

const mySet = new Set();
mySet.add('value1');
mySet.add('value2');

for (const value of mySet.values()) {
  console.log(value);  			 // 'value1', 'value2'
}

 

예시: 객체 순회

let person = {
  name: 'Alice',
  age: 25,
  city: 'New York'
};

// 객체의 키 순회 (배열로 변환 후 순회)
for (let key of Object.keys(person)) {
  console.log(key);  // 출력: 'name', 'age', 'city'
}

// 객체의 값 순회 (배열로 변환 후 순회)
for (let value of Object.values(person)) {
  console.log(value);  // 출력: 'Alice', 25, 'New York'
}

// 객체의 키-값 쌍 순회 (배열로 변환 후 순회)
for (let [key, value] of Object.entries(person)) {
  console.log(`${key}: ${value}`);  // 출력: 'name: Alice', 'age: 25', 'city: New York'
}

 

요약

  • for 반복문: 특정 횟수나 인덱스를 기반으로 반복. 배열이나 숫자를 순회할 때 적합.
  • for...in 반복문: 객체의 키나 배열의 인덱스를 순회할 때 사용. 객체의 프로퍼티를 다루는 데 유용.
  • for...of 반복문: 배열, Set, Map 같은 이터러블 객체의 값을 직접 다룰 때 사용.
728x90
반응형

'JavaScript' 카테고리의 다른 글

[JS] 클로저  (1) 2024.09.22
[JS] this 정리  (0) 2024.09.15
[JS] Map 사용 방법  (1) 2024.09.08
[JS] 1-3) 객체와 객체 메소드, 그리고 객체를 순회하는 방법  (1) 2024.09.04
[JS] 1-1) JS 언어의 특징과 역사  (1) 2024.09.02
728x90
반응형

Maps (Key-value collections with order)

Map은 순서를 유지하면서 키-값 쌍을 저장하는 자료 구조에요. Object와는 다르게 모든 데이터 타입을 키로 사용할 수 있으며, 내부적으로 해시 테이블을 사용하기 때문에 대규모 데이터를 처리할 때 성능이 좋아요. 

 

Map 생성 및 사용

새로운 Map을 만들려면 Map() 생성자를 사용합니다.

const myMap = new Map();

 

이제 Map에 값을 추가하려면 set() 메소드를 사용합니다.

myMap.set('key', 'value');

 

Map에서 값을 검색하려면 get() 메소드를 사용합니다.

console.log(myMap.get('key')); // 'value' 출력

 

When to use Maps

  • 순서가 중요한 동시에 빠른 데이터 처리(접근, 삽입, 삭제)가 필요한 경우
  • 키로 다양한 데이터 타입을 사용해야 할 때 (객체, 배열 등)

 

Big O of Maps

  • Insertion - O(1): 맨 뒤에만 새로운 키-값 쌍이 추가가능하기 떄문에 상수 시간에 완료.( 중간에 직접 삽입하는 기능은 없음)
  • Removal - O(1): 특정 키를 삭제하는 작업도 상수 시간에 완료.
  • Searching -  O(N): 객체에서 특정 값(value)을 찾는 작업은 최악의 경우 모든 키를 확인해야 하므로 선형 시간(O(N))이 걸릴 수 있다.
  • Access - O(1): 키를 통해 값을 접근하는 작업은 상수 시간에 가능

 

Map Methods

  • set - O(1): 새로운 키-값 쌍을 추가
  • get - O(1): 특정 키에 대한 값을 반환
  • delete - O(1): 특정 키-값 쌍을 삭제
  • has - O(1): 특정 키가 존재하는지 확인
  • size - O(1): Map의 크기(저장된 요소 수)를 반환
  • forEach - O(N): 저장된 모든 요소에 대해 반복 작업을 수행

 

Map의 이점

Map은 자바스크립트에서 Object의 단점을 보완하기 위해 등장한 자료구조에요. Object는 자바스크립트의 기본적인 자료구조로서 키-값 쌍을 저장하는 기능을 제공하지만, 몇 가지 한계점이 있어요. Map은 이러한 제약을 해결하고, 더 유연하고 효율적인 데이터 구조를 제공해요

 

☑️ 다양한 데이터 타입을 키로 사용 가능

  • Object에서는 문자열심볼로 사용할 수 있어요. 만약 숫자나 객체를 키로 사용하려면 자동으로 문자열로 변환됩니다.
  • Map은 숫자, 객체, 배열, 함수모든 데이터 타입로 사용할 수 있어요. 즉, 키로 더 많은 종류의 데이터를 사용할 수 있다는 장점이 있어요.

 

// Map에서는 객체를 키로 사용할 수 있음
let obj1 = { id: 1 };
let obj2 = { id: 2 };

let map = new Map();
map.set(obj1, "Object 1"); // 객체를 키로 사용
map.set(obj2, "Object 2");

console.log(map.get(obj1)); // "Object 1"
console.log(map.get(obj2)); // "Object 2"

 

 

☑️ 삽입 순서 유지

  • Object키-값 쌍을 저장하는 순서가 중요하지 않아요. 그래서 순서가 바뀌거나 무작위로 출력될 수 있어요.
  • 반면, Map은 삽입된 순서항상 기억해요. 순서대로 데이터를 관리할 때는 Map이 더 유용해요.
let map = new Map();
map.set(1, 'a');
map.set(2, 'b');
map.set(3, 'c');

for (let [key, value] of map) {
  console.log(key, value);
}
// 출력 순서: 1 'a', 2 'b', 3 'c'

 

 

☑️ 성능(특히 많은 데이터를 처리할 때)

  • Object는 적은 데이터를 처리할 때는 괜찮지만, 많은 데이터를 다룰 때는 속도가 느려질 수 있어요.
  • Map은 내부적으로 해시 테이블을 사용해서 더 빠르게 데이터를 추가하고 삭제할 수 있어요. 특히 많은 데이터를 저장하고 빠르게 찾을 때 유리해요.

 

let map = new Map();
for (let i = 0; i < 100000; i++) {
  map.set(i, `value${i}`);
}
console.log(map.get(50000));  // 'value50000', 큰 데이터셋에서도 빠르게 찾을 수 있음

 

 

그러면 Map을 쓰면 굳이 Object는 필요없는거 아닌가?

 

Map이 Object를 대체할 수 없는 경우

☑️ JSON 데이터 처리

  • JSON(JavaScript Object Notation)은 자바스크립트의 표준 데이터 형식으로, 대부분의 웹 API나 데이터 교환에서 많이 쓰여요. JSON은 Object 형태로만 표현됩니다.
  • 따라서 Map은 JSON 형식으로 직렬화(serialize)할 수 없고, 다시 Map으로 역직렬화(deserialize)할 수 없어요. 

 

☑️  프로토타입 기반 상속과 객체 구조

  • 자바스크립트는 프로토타입 기반 상속을 통해 객체(Object)의 기능을 확장할 수 있어요. 하지만 Map은 이런 프로토타입 상속 기능을 지원하지 않아요.
  • 즉, Map은 객체처럼 새로운 기능을 추가하거나 확장할 수 없어요. Map은 키-값 데이터를 저장하는 데에만 집중된 자료구조이기 때문에, 객체 지향 프로그래밍의 특성인 상속을 활용할 수 없어요.
// 'Person'이라는 함수를 정의하고, 이걸로 사람 객체를 만들 수 있음
function Person(name, age) {
  this.name = name;
  this.age = age;
}

// Person 객체가 사용할 수 있는 'greet' 메서드를 추가 (프로토타입 상속)
Person.prototype.greet = function() {
  console.log(`Hello, my name is ${this.name}`);
};

// John이라는 새로운 사람 객체를 만듦
let john = new Person('John', 18);

// John은 'greet' 메서드를 사용할 수 있음 (상속된 메서드)
john.greet(); // "Hello, my name is John"

 

이런 이유로, 객체 지향 프로그래밍의 특성을 사용하거나 객체의 상속을 활용해야 할 때는 여전히 Object가 필요해요.

 

 

☑️   간단한 구조에서는 Object가 더 직관적

  • Object에서는 점 표기법(.)을 사용해 속에 쉽게 접근할 수 있어 더 직관적이에요.
  • 반면 Map은 set(), get() 메서드를 통해 키에 접근해야 하므로, 코드가 조금 더 복잡해질 수 있어요.
let obj = { name: 'John', age: 18 }; // Object는 직관적
console.log(obj.name); // 'John'

// Map은 더 많은 메서드를 사용해야 함
let map = new Map();
map.set('name', 'John');
map.set('age', 18);
console.log(map.get('name')); // 'John'

 

728x90
반응형
728x90
반응형

1. 컴파일러란?

컴파일러는 우리가 쓰는 프로그래밍 언어 코드를 → 다른 언어로 변환하는 도구에요.

- C언어 컴파일러는 C언어 → 기계어 코드 변환을 해주고

- TypeScript 컴파일러는 TypeScript → JavaScript 코드 변환을 해줘요!

 

2. 컴파일러는 왜 등장했을까?

컴퓨터는 기본적으로 기계어로 작성된 프로그램만 이해할 수 있어요!

그런데, 위의 스크린샷을 보면 아시겠지만 기계어는 사람이 이해하거나 작성하기 어려워요

그래서 사람이 더 쉽게 사용할 수 있는 C언어 같은 고수준 프로그래밍 언어가 등장했어요.

하지만 컴퓨터가 C언어로 작성된 코드를 이해하려면 기계어로 변환이 필요했고, 이를 도와주는 컴파일러가 필요하게 되었죠!

 

3. TypeScript 컴파일러

TypeScript 컴파일러는 TypeScript → JavaScript 코드 변환을 해준다고 설명했었죠

☑️ 여기서 갑자기 궁금한 점 🤔 🤔

위에서 컴퓨터가 이해하기 위해서는 기계어로 변환되어야 한다고 했잖아요, 그럼 JavaScript도 결국에는 기계어로 변환 되어야할텐데, 왜 JavaScript는 컴파일러가 없나요?

JavaScript는 동적 언어(인터프리터 언어)라서, 기계어로 미리 변환할 필요가 없어요. 대신, 실행할 때 브라우저나 Node.js 같은 JavaScript 엔진이 그 코드를 한 줄씩 읽고 바로바로 기계어로 변환해서 실행해요.

  • Node.jsChrome 브라우저V8 엔진을 사용해서 JavaScript를 처리하고,
  • FirefoxSpiderMonkey 엔진을 사용해요.

 

4. 컴파일러와 인터프리터의 차이

정리하자면:

  • 정적 언어(컴파일 언어): C언어처럼 미리 기계어로 변환해야 실행할 수 있어요. 이때 변환을 도와주는 것이 컴파일러예요.
  • TypeScript: TypeScript는 컴파일러(tsc)를 통해 JavaScript로 변환되고, 변환된 JavaScript는 JavaScript 엔진이 실행하면서 기계어로 변환돼요.
  • 동적 언어(인터프리터 언어): JavaScript처럼 코드를 실행하면서 그때그때 해석하고 기계어로 변환해요. 컴파일러가 필요 없고, 인터프리터가 코드를 해석해서 바로 실행해줘요.

 

이제 정리가 되셨나요? 그렇다면, 왜 컴파일러를 알아야 할까요?

 

5. 컴파일러의 주요 역할 

☑️ 타입 검사

TypeScript 컴파일러(tsc)는 타입 오류를 미리 찾아줘요. 예를 들어, 숫자 변수에 문자를 넣으려고 하면 "잘못된 타입!"이라고 오류를 알려줘요. 이렇게 컴파일러는 오류를 미리 알려줘서, 개발자가 실행 전에 수정할 수 있게 도와주는 역할을 해요.

☑️ 코드 변환

컴파일러는 우리가 작성한 코드를 다른 언어로 변환해요. tscTypeScript 코드를 JavaScript로 변환하고, C언어 컴파일러C언어를 기계어로 변환해요. 이 과정이 있어야 코드가 컴퓨터에서 실행될 수 있죠.

 

☑️ 에러 처리와 디버깅 지원

컴파일러는 코드를 변환하면서 오류를 발견하면 에러 메시지를 출력해요. 개발자는 이 메시지를 보고 문제를 파악하고 빠르게 수정할 수 있어요. 컴파일러가 변환하는 과정을 잘 이해하면, 문제 발생 시 어떤 방식으로 해결할지 더 쉽게 예측할 수 있어요. 이를 통해 디버깅 과정에서 큰 도움이 돼요.

 

6. tsconfig.json 해부하기

tsconfig.json 이란?

  • TypeScript 프로젝트의 설정 파일이에요. 이 파일에서 여러 가지 옵션을 사용해서 TypeScript 코드가 어떻게 동작할지를 설정할 수 있어요.
  • tsc --init 명령어를 실행하면 이 파일이 생성돼요. 주로 컴파일할 파일컴파일 방법을 정의하는 데 쓰여요.

주요 옵션들

☑️  compilerOptions - target 옵션:

  • 코드를 어떤 JavaScript 버전으로 변환할지 정하는 옵션이에요.
  • es5 로 설정하면 CommonJS 버전으로 컴파일되구요!
  • es2016(=es7) 로 설정하면 ES2016 버전으로 컴파일이 됩니다!
    • 최신 브라우저는 보통 ES2016을 지원하니 이렇게 설정하시는 것을 추천드려요!
  • 단, 이것을 정할 때는 TypeScript가 어느 환경에서 실행이 되어야하는지를 고려하셔야 해요!
    • 만약, 내가 만든 프로젝트가 생각보다 레거시한 환경에서 동작해야 된다면? → es5
    • 그렇지 않다면 → es2016

 

☑️  compilerOptions - module 옵션:

  • JavaScript 모듈 형식을 지정하는 옵션이에요. 모듈을 어떻게 가져오고 내보낼지를 정해줘요.
  • target 옵션과는 서로 독립적인 관계로 프로젝트의 요구사항에 따라 옵션을 설정하시면 됩니다!

☑️  compilerOptions - outDir 옵션:

  • 컴파일된 JavaScript 파일들이 저장될 폴더를 정하는 옵션이에요.(출력 디렉터리를 지정)
  • 예를 들어, "outDir": "dist"로 설정하면 컴파일된 파일들이 dist 폴더에 저장돼요.

☑️  compilerOptions - strict

  • 엄격한 타입 검사 옵션을 모두 활성화하는 옵션이에요!
    • strictNullChecks
      • 잠재적으로 null(undefined)이 될 수 있는 값들에 대해서 엄격하게 확인하는 옵션이에요!
    • strictFunctionTypes
    • strictBindCallApply
    • strictPropertyInitialization
    • noImplicitAny
      • 함수의 인자 또는 변수의 타입이 명시적으로 선언되지 않은 경우에 컴파일러가 자동으로 any타입을 부여하지 않도록 해요.
      • 이 옵션을 활성화하면 개발자가 누락된 타입 선언을 확인하고 명시적으로 타입을 선언할 수 있죠!
    • noImplicitThis
    • alwaysStrict해당 옵션을 true로 설정하면 아래의 옵션들이 자동으로 true로 설정이 되어요.
  • 이 옵션을 꼭 true로 설정하는 것을 추천해요.

☑️  compilerOptions - sourceMap 옵션:

  • 소스 맵을 생성하는 옵션이에요. 소스 맵이 있으면 디버깅할 때 원래 TypeScript 코드를 쉽게 찾을 수 있어요.
  • 개발 중에는 꼭 true로 설정하는 게 좋아요. 하지만 배포할 때는 용량이나 성능상의 이유로 sourceMap을 사용하지 않는 것이 나을 수 있어요!

☑️  include, exclude 옵션:

  • 컴파일할 파일컴파일에서 제외할 파일을 정하는 옵션이에요.
  • “include": ["src/**/*"]
    • src 디렉토리 밑의 친구들을 컴파일 하겠다는 의미에요!
  • "exclude": ["node_modules", "dist"]
    • node_modules, dist 디렉토리 밑의 친구들은 컴파일 대상에서 제외하겠다는 의미에요!

 

7. d.ts 파일 알아보기

💡 .d.ts 파일JavaScript 라이브러리를 TypeScript에서 사용할 수 있게 도와주는 파일이에요.

 

왜 d.ts 파일이 필요할까요?

    • TypeScript가 나오기 전에는 당연히도 JavaScript로만 코드를 작성했겠죠?
    • 아직까지 이 세계에는 JavaScript 코드의 양 >>> TypeScript 코드의 양일 것입니다.
    • 그렇다면, 이미 작성된 다양한 JavaScript 라이브러리와 호환성을 유지할 수 있어야겠죠?
    • 어떻게 TypeScript 코드는 JavaScript 라이브러리와 호환성을 유지할 수 있을까요?

@types 라이브러리의 등장

  • 이 라이브러리는 외부 JavaScript 라이브러리에 대한 타입 정보를 TypeScript에 제공해줘요.
  • 실제로 @types 디렉터리에 들어가 보면, .d.ts 파일들이 잔뜩 있어요.

그렇다면 이 .d.ts 파일은 무엇일까요?

  • .d.ts 파일은 TypeScript 타입 정의 파일이에요.
  • 이 파일은 TypeScript가 JavaScript 라이브러리의 타입 정보를 알 수 있게 도와줘요. 예를 들어:
    • 외부 라이브러리의 함수가 어떤 타입을 반환하는지,
    • 클래스가 어떤 타입인지,
    • 객체가 어떤 타입인지 등을 알려주는 역할을 해요.
  • 뿐만 아니라 타입 추론도 가능하게 해줘요. 타입 추론이란, 타입이 명시가 되지 않았을 때 컴파일러가 알아서 해당 타입에 대해 추론을 하는 것이에요.

따라서 해 라이브러리에 대한 .d.ts 파일만 있으면 기존의 JavaScript 라이브러리를 TypeScript에서도 그대로 사용할 수 있어요

 

728x90
반응형

+ Recent posts