amaranth.log
💻 개발

[기술부채] 왜 리액트는 클래스를 버리고 함수를 선택했을까(feat. React Hooks)

클래스형 컴포넌트와 함수형 컴포넌트

클래스형 컴포넌트

리액트 초창기부터 사용된 컴포넌트 정의 방식. ES6의 class 문법을 사용하며, 상태 관리와 생명주기 메서드를 활용하기 위해 사용되었다.
  • 상태 관리 방법: this.state를 사용. this.setState()로 상태를 업데이트한다.
  • 생명주기 정의 방식: componentDidMount, componentDidUpdate 등 특정 시점에 실행되는 클래스 메서드를 오버라이드하여 동작을 정의할 수 있다.

함수형 컴포넌트

현재 리액트 공식 문서에서 권장되는 컴포넌트 정의 방식. function 또는 화살표 함수로 선언한다.
  • 상태 관리 방법: useState Hook을 사용한다.
  • 생명주기 정의 방식: useEffect Hook 하나로 클래스형의 여러 생명주기 메서드를 통합해서 처리한다.
 

패러다임의 전환(React v16.8)

리액트 초창기의 함수형 컴포넌트는 상태를 정의할 수 없었기 때문에, Stateless Functional Component(SFC)라고 불렸다. 단순히 props를 받아 화면에 UI를 그리는 역할만 할 수 있었기 때문에, 복잡한 기능은 항상 클래스형 컴포넌트로 만들어야 했다.

기존 클래스형 컴포넌트의 문제

하지만 클래스형 컴포넌트는 여러 문제를 가지고 있었다.
  • 코드의 복잡성: this 바인딩이나 생성자(constructor) 등 신경 쓸 게 많았다.
    • 클래스 컴포넌트에서는 데이터/함수에 접근할 때 항상 this 키워드를 사용해야 했는데, 자바스크립트의 this는 호출되는 상황에 따라 가리키는 대상이 변하는 특성이 있다.
      class Counter extends React.Component { constructor(props) { super(props); this.state = { count: 0 }; // 1. 이 함수 안에서 this를 쓰려면 여기서 바인딩을 일일이 해줘야 함 this.increase = this.increase.bind(this); } increase() { // 2. 상태를 바꿀 때도 항상 this.setState... this.setState({ count: this.state.count + 1 }); } render() { return ( // 3. 값 하나 보여줄 때도 this.state.xxx... <button onClick={this.increase}>{this.state.count}</button> ); } }
    • 생성자의 늪: 상태를 하나 만들려고 해도 constructor를 열고 super(props)를 호출한 뒤 this.state를 정의해야 했다.(보일러 플레이트)
    • 바인딩 지옥: 이벤트 핸들러 함수를 만들면, this를 클래스에 일일이 바인딩해주어야 했다.
  • 로직 재사용의 어려움: 상태 관련 로직을 다른 컴포넌트에서 재사용하기가 까다로웠다.
    • 클래스는 상태와 로직이 클래스 내에 갇혀있었고, 이 상태와 로직을 다른 컴포넌트에서 사용하기 위해선 고차 컴포넌트(HOC) 또는 Render Props같은 복잡한 기법을 써야 했다.
      • 💡
        고차 컴포넌트(HOC, Higher-Order Component)
        : 컴포넌트를 인자로 받아 새로운 컴포넌트를 반환하는 함수
        • 자바스크립트의 고차 함수와 같은 개념
        • 주로 with라는 접두사를 붙여 만든다.
        • 장점: 공통 로직을 한 곳에서 관리하며 여러 컴포넌트에 주입하기 쉽다.
        • 단점: 컴포넌트를 여러 번 감싸면 구조가 복잡해지는 래퍼 지옥에 빠지기 쉽고, props가 어디서 오는지 파악하기 어려워짐
        /* 마우스 좌표를 추적하는 로직을 두 개의 다른 컴포넌트에서 사용한다고 가정 */ // 로직을 담은 wrapper 함수 (매우 복잡함) function withMouse(WrappedComponent) { return class extends React.Component { state = { x: 0, y: 0 }; /* 마우스 이동 로직 구현... */ render() { return <WrappedComponent {...this.props} mouse={this.state} />; } } } // 사용할 때 const MyComponentWithMouse = withMouse(MyComponent);
        💡
        Render Props
        : 무엇을 렌더링할지 결정하는 함수를 props로 넘겨주는 방식
        • 장점: HOC보다 동적으로 데이터를 다루기 쉽고, props의 출처가 명확하다.
        • 단점: 로직을 재사용할 때마다 중첩된 함수 구조가 생겨 코드가 지저분해 보일 수 있다.
        // Render Props 컴포넌트 class MouseTracker extends React.Component { state = { x: 0, y: 0 }; /* 마우스 위치 추적 로직... */ render() { // 렌더링 로직을 직접 정하지 않고, props로 받은 함수를 호출함 return this.props.render(this.state); } } // 사용 예시 <MouseTracker render={(mouse) => ( <p>마우스 위치는 {mouse.x}, {mouse.y}입니다.</p> )} />
        참고) 현대에 이르러 Render Props 패턴은 어떤 형태로 남았는가
        • Headless UI 도구의 핵심 메커니즘
          • 기능을 담당하는 Hook이 데이터를 제공하면 그 데이터를 받아 UI를 직접 렌더링한다.
          • // TanStack Table 예시 (Render Props의 변형된 형태) {table.getRowModel().rows.map(row => ( <tr key={row.id}> {row.getVisibleCells().map(cell => ( // 어떻게 그릴지는 사용자가 함수 형태로 결정 <td key={cell.id}> {flexRender(cell.column.columnDef.cell, cell.getContext())} </td> ))} </tr> ))}
        • Function as Child 패턴
          • 컴포넌트의 children을 엘리먼트가 아닌 함수로 받아 내부 상태를 외부로 전달한다. Formik이 대표적인 예.
          • <Formik initialValues={{ name: "" }} onSubmit={...}> {({ values, handleChange }) => ( <form> <input name="name" value={values.name} onChange={handleChange} /> </form> )} </Formik>
        • 슬롯 패턴(현대 디자인 시스템에서 자주 활용됨)
          • // 카드 컴포넌트 (틀만 제공) function Card({ header, content, footer }) { return ( <div className="card-container"> <div className="card-header">{header}</div> <div className="card-content">{content}</div> <div className="card-footer">{footer}</div> </div> ); } // 사용 예시 function App() { return ( <Card header={<h1>제목입니다</h1>} content={<p>여기에 본문 내용이 들어갑니다.</p>} footer={<button>확인</button>} /> ); }
  • 거대한 컴포넌트: 관련 없는 로직들이 생명주기 메서드(예: componentDidMount) 안에 뒤섞여 가독성이 떨어졌다.
    • 클래스 컴포넌트는 컴포넌트의 생명주기에 따라 로직을 배치해야 하기 때문에, 같은 기능단위의 로직이 곳곳에 흩어지게 되어 응집도가 떨어졌다. 반대로 아무 상관 없는 로직이 같은 생명 주기에 실행된다는 이유로 한 데 묶이게 되어 나중에 코드가 길어지면 특정 목적의 로직을 식별해내기 어려워지는 문제가 있었다.
      componentDidMount() { // A 로직: 사용자 데이터 가져오기 fetchUser().then(data => this.setState({ user: data })); // B 로직: 스크롤 이벤트 등록 (A와 아무 상관 없음) window.addEventListener('scroll', this.handleScroll); } componentWillUnmount() { // 정리(Clean-up)도 여기서 한꺼번에... window.removeEventListener('scroll', this.handleScroll); }
  • 컴파일 단계에서의 코드 최적화가 어려움.
    • Tree Shaking이 어렵다. 함수는 이 함수가 사용되는지 여부를 판단하기가 상대적으로 간단하다. 하지만 클래스는 내부에 수많은 메서드가 엉켜 있고, this를 통해 동적으로 연결될 수 있기 때문에 ‘삭제해도 되는 메서드’를 판별하기 어렵다. 그래서 실제로 사용되지 않는 코드가 번들에 포함되기 쉽다.
    • 코드 압축이 까다롭다. 함수형 컴포넌트의 변수나 함수 이름은 빌드 도구(Terser 등)가 마음대로 a, b처럼 짧게 줄일 수 있다. 하지만 클래스의 메서드는 어디서 어떻게 호출될지 알기 어렵기 때문에 함부로 줄일 수 없어 압축하기 까다롭고, 결국 빌드 번들의 크기가 커진다.

Hook의 등장

그러던 중 2019년 2월, React 16.8 버전에서 Hook이 등장하면서 패러다임이 바뀌게 된다.
Hook이란 함수형 컴포넌트에서도 리액트의 핵심 기능(상태 관리, 생명주기 등)을 사용할 수 있게 해주는 기술이다.

🚀 useState (상태 관리)

: 컴포넌트의 상태를 관리하는 가장 기본적인 훅. 함수형 컴포넌트에서도 가변적인 상태를 지니고 있을 수 있게 해준다.

🚀 useEffect (부수 효과 처리)

: useEffect는 리액트 컴포넌트가 렌더링될 때마다 특정 작업을 수행하도록 설정하는 Hook.
클래스형 컴포넌트의 componentDidMount와 componentDidUpdate, componentWillUnmount를 합친 형태로 볼 수 있다.

🚀 커스텀 Hook

만약 여러 컴포넌트에서 비슷한 기능을 공유해야 할 때, 우리만의 Hook을 작성해 로직을 재사용할 수 있다.
 
이렇게 Hook이 등장함으로써 함수형 컴포넌트가 클래스형 컴포넌트의 모든 기능을 대체할 수 있게 되었다.
💡
Hook을 사용할 때 주의사항
Hook은 반드시 컴포넌트 최상위에서 호출해야 한다.
리액트는 내부적으로 Hook이 호출된 순서를 기준으로 각 데이터를 저장한다.
함수형 컴포넌트가 처음 실행(Mount)될 때, 리액트는 해당 컴포넌트를 위한 메모리 공간에 배열을 하나 만들고, Hook이 호출될 때마다 그 배열을 하나씩 채운다.(정확히는 배열이 아니라 단일 연결 리스트 형태)
function MyComponent() { const [name, setName] = useState('Alice'); // 1번 칸: 'Alice' 저장 const [age, setAge] = useState(25); // 2번 칸: 25 저장 useEffect(() => { ... }, []); // 3번 칸: 이펙트 정보 저장 return ( ... ); }
이후 컴포넌트의 상태가 업데이트되어 함수가 다시 실행될 때(=재렌더링), 리액트는 이 내부 배열의 커서를 0으로 초기화하고 Hook을 다시 읽는다. 그 과정에서 update queue를 적용해 새로운 상태를 계산한다.
이후 useEffect가 호출되고, effect 객체를 생성한 뒤 의존성 배열의 상태를 컴포넌트 재실행 이전의 의존성 배열과 비교한다. 의존성 배열의 일치 여부에 따라 실행 필요 flag를 설정하고, 렌더링이 완료된 후 flag가 true인 effect 객체만 실행(커밋)한다.
💡
리액트가 변수명이 아니라 호출 순서에 의존하는 이유
함수형 컴포넌트가 ‘그냥 함수’이기 때문이다. 함수가 실행될 때마다 지역변수(=상태, 변수 등)는 함수 스택 프레임에 새로 만들어지고, 실행이 끝나면 해당 메모리가 제거된다. 그렇게 리액트는 함수 내부의 변수/식별자에 접근할 수가 없기 때문에, Hook 상태를 컴포넌트 노드에 별도로 저장하고 렌더링 중 Hook이 호출되는 순서를 기준으로 각 상태를 매핑한다.(호출 순서를 암묵적 식별자로 사용하는 것)
💡
Update Queue
setState가 호출되면 즉시 상태가 바뀌지 않는다.
setCount(prev => prev + 1)
대신 아래와 같은 객체가 만들어지고, 이것이 Hook의 update Queue에 연결된다.
update = { action: prev => prev + 1, next: null }
Hook memoizedState: 0 queue: pending → update1 → update2 → ...
렌더 단계에서 리액트는 다음의 과정을 거친다.
  1. update queue를 순회한다.
  1. action을 순서대로 적용한다.
  1. 새로운 state를 계산한다.
  1. memorizedState에 저장한다.
⇒ 이것이 값 기반 업데이트와 함수 기반 업데이트의 차이를 야기한다.
setCount(count + 1); setCount(count + 1); setCount(count + 1);
이 경우 count의 memoizedState는 0이기 때문에 update queue에는 다음과 같이 쌓인다.
update1: action = 1 update2: action = 1 update3: action = 1
그렇기 때문에 렌더 시 최종 값이 1이 된다.

함수형 컴포넌트의 장점

함수형 컴포넌트는 다음과 같은 장점을 갖는다.
  • 높은 가독성과 생산성: 클래스형 컴포넌트의 보일러 플레이트가 없다.
    • 클래스형에서는 this.state, this.handleClick.bind(this)처럼 매번 this를 붙여야 했고, 이게 가끔 엉뚱한 곳을 가리켜 버그를 만들기도 했다. 함수형 컴포넌트는 변수와 함수를 바로 사용하면 되기 때문에 훨씬 직관적이다.
    • 코드 줄 수가 확연히 줄어들어 상대적으로 읽기 편하고 유지보수가 쉽다.
  • 로직의 재사용성: 복잡한 로직을 분리해 Custom Hook으로 만들어 여러 곳에서 쉽게 재사용할 수 있다.
  • 기능의 응집도(useEffect): 생명주기 메서드의 파편화 문제를 해결한다.
    • 관련 있는 코드끼리 묶어둘 수 있기 때문에 훨씬 직관적이고 유지보수하기 편리하다.
  • 미래 지향적인 패러다임: 리액트의 최신 기능에 친화적이다.
    • 예) 리액트 서버 컴포넌트(RSC), 동시성 렌더링(Concurrent Rendering) 등 리액트의 최신 기술들은 함수형 구조를 기반으로 설계됨.
 

결론

클래스형 컴포넌트에서 함수형 컴포넌트로의 전환은 단순한 문법적 변화가 아니라, 리액트가 “객체 중심 UI 설계”에서 “함수 중심 렌더링 모델”로 이동한 사건이었다.
Hook의 도입은 상태와 생명주기를 함수 단위로 분해할 수 있게 만들었고, 이를 통해 로직의 재사용성과 응집도를 획기적으로 개선했다. 더 나아가 이는 Concurrent Rendering(동시성 렌더링), Server Component(서버 컴포넌트)와 같은 최신 기능의 기반이 되었다.
결국 함수형 컴포넌트는 단순히 더 간결한 문법이 아니라, 리액트가 지향하는 렌더링 아키텍처에 가장 적합한 형태라고 볼 수 있다.
📚 기술 부채26 / 31
  1. 1편[기술부채] 우테코 5기 레벨1 - 6주차: 블랙잭 미션, RDD와 try-with-resources2023년 3월 20일
  2. 2편[기술부채] 우테코 5기 레벨1 - 7주차: 체스 미션, 방어적 복사와 커맨드 패턴2023년 3월 27일
  3. 3편[기술부채] 우테코 5기 레벨1 - 8주차: 체스 미션, 테스트 더블과 커넥션 풀2023년 4월 14일
  4. 4편[기술부채] 우테코 5기 레벨2 - 1주차: 웹 자동차 경주, 스프링 MVC 매핑과 DI2023년 4월 16일
  5. 5편[기술부채] 우테코 5기 레벨2 - 2주차: @Valid와 Dirty Checking2023년 5월 1일
  6. 6편[기술부채] 우테코 5기 레벨2 - 3주차: 장바구니 미션, MockMvc vs RestAssured와 PRG 패턴2023년 5월 3일
  7. 7편[기술부채] 우테코 5기 레벨2 - 5주차: Mockito와 동적 쿼리2023년 5월 14일
  8. 8편[기술부채] 우테코 5기 레벨2 - 6주차: 지하철 미션, Profile과 JPA 연관관계2023년 5월 23일
  9. 9편[기술부채] 우테코 5기 레벨2 - 9주차: CORS Preflight와 멱등성, 필드 주입2023년 6월 12일
  10. 10편[기술부채] 우테코 5기 레벨2 - 8주차: 장바구니 협업 미션, LocalDateTime 직렬화와 시맨틱 버저닝2023년 6월 12일
  11. 11편[기술부채] 우테코 5기 레벨2 - 7주차: OSIV와 영속성 컨텍스트, CORS 인증2023년 6월 30일
  12. 12편[기술부채] 우테코 5기 레벨3 - 3주차: 오프셋·커서 페이지네이션과 @ElementCollection2023년 7월 18일
  13. 13편[기술부채] 우테코 5기 레벨3 - 7주차: Batch Insert와 @EventListener2023년 8월 12일
  14. 14편[기술부채] 우테코 5기 레벨3 - 8주차: JPQL Distinct와 MultipleBagFetchException2023년 8월 31일
  15. 15편[기술부채] 우테코 5기 레벨3 - 6주차: 동시성 이슈와 @Transient2023년 8월 31일
  16. 16편[기술부채] 우테코 5기 레벨3 - 1주차: 무결성과 정합성, Elastic Beanstalk2023년 8월 31일
  17. 17편[기술부채] 우테코 5기 레벨4 - 1주차: @TransactionalEventListener와 트랜잭션 전파2023년 9월 10일
  18. 18편[기술부채] 우테코 5기 레벨4 - 2주차: 톰캣 만들기와 Location 헤더2023년 9월 11일
  19. 19편[기술부채] 우테코 5기 레벨4 - 3주차: 로드밸런서, CQRS와 커버링 인덱스2023년 9월 18일
  20. 20편[기술부채] 우테코 5기 레벨4 - 4주차: @MVC 구현하기 미션2023년 9월 24일
  21. 21편[기술부채] 우테코 5기 레벨4 - 5주차: @MVC 구현하기 3단계와 JSON 응답2023년 10월 2일
  22. 22편[기술부채] 우테코 5기 레벨4 - 6주차: JDBC 라이브러리 구현하기 1~3단계2023년 10월 9일
  23. 23편[기술부채] 우테코 5기 레벨4 - 7주차: JDBC 라이브러리 구현하기 3단계2023년 10월 16일
  24. 24편[Spring] Spring DTO의 데이터 바인딩과 직렬화2023년 12월 5일
  25. 25편[기술부채] 클라이언트 사이드 라우팅2026년 2월 5일
  26. 26편[기술부채] 왜 리액트는 클래스를 버리고 함수를 선택했을까(feat. React Hooks)2026년 2월 12일
  27. 27편[기술부채] iframe과 postMessage2026년 2월 20일
  28. 28편[기술부채] Service Worker(서비스 워커)2026년 2월 24일
  29. 29편[기술부채] 커링의 어원과 함수형 프로그래밍2026년 3월 12일
  30. 30편[기술부채] AG-UI와 CopilotKit - 12026년 3월 27일
  31. 31편[기술부채] AG-UI와 CopilotKit - 22026년 3월 29일