리액트 강좌: 컴포넌트와 상태

리액트(React)는 사용자 인터페이스를 구축하기 위한 JavaScript 라이브러리입니다. 리액트는 컴포넌트 기반 아키텍처를 채택하고 있으며, 이로 인해 개발자는 재사용 가능한 UI 구성 요소를 만들 수 있습니다. 본 강좌에서는 리액트의 핵심 개념인 ‘컴포넌트’와 ‘상태’에 대해 깊이 있게 다룰 것입니다.

1. 컴포넌트란?

컴포넌트는 리액트의 기본 빌딩 블록으로, UI를 구성하는 작은 조각입니다. 각 컴포넌트는 독립적으로 작동하며, 다른 컴포넌트와 결합하여 복잡한 사용자 인터페이스를 형성합니다.

1.1. 컴포넌트의 종류

리액트 컴포넌트는 크게 두 가지 종류로 분류됩니다.

  • 클래스 컴포넌트: ES6 클래스를 사용하여 정의된 컴포넌트입니다. 상태(state)를 관리할 수 있습니다.
  • 함수형 컴포넌트: JavaScript 함수로 정의된 컴포넌트입니다. 최근에는 훅(Hooks)이라는 기능을 도입하여 상태를 관리할 수 있게 되었습니다.

1.2. 컴포넌트 생성

리액트 컴포넌트는 다음과 같이 생성할 수 있습니다.

import React from 'react';

class MyComponent extends React.Component {
    render() {
        return <h1>안녕하세요, 리액트!</h1>;
    }
}

위의 예제는 클래스를 선언하여 ‘MyComponent’라는 컴포넌트를 정의하고, 이를 사용하여 “안녕하세요, 리액트!”라는 텍스트를 화면에 렌더링하는 간단한 컴포넌트입니다.

2. 상태(state)란?

상태는 컴포넌트의 데이터나 값을 의미합니다. 컴포넌트의 상태는 내부적으로 저장되며, 상태가 변경될 경우 컴포넌트는 자동으로 다시 렌더링됩니다.

2.1. 상태의 사용

클래스 컴포넌트에서 상태를 사용하려면, constructor 메서드에서 초기 상태를 정의하고, `this.setState()` 메서드를 사용하여 상태를 업데이트합니다.

class MyStateComponent extends React.Component {
    constructor(props) {
        super(props);
        this.state = { count: 0 };
    }
    
    increment = () => {
        this.setState({ count: this.state.count + 1 });
    }
    
    render() {
        return (
            <div>
                <p>현재 카운트: {this.state.count}</p>
                <button onClick={this.increment}>증가</button>
            </div>
        );
    }
}

위의 예제에서 ‘MyStateComponent’는 카운트를 증가시키는 기능을 가진 컴포넌트입니다. `increment` 메서드를 호출하면 상태가 변경되고, 이로 인해 컴포넌트가 다시 렌더링됩니다.

2.2. 함수형 컴포넌트에서의 상태 관리

함수형 컴포넌트에서 상태를 관리하기 위해 React의 `useState` Hook을 사용합니다. 아래는 상태를 사용하는 함수형 컴포넌트의 예시입니다.

import React, { useState } from 'react';

const MyFunctionalComponent = () => {
    const [count, setCount] = useState(0);
    
    const increment = () => {
        setCount(count + 1);
    }
    
    return (
        <div>
            <p>현재 카운트: {count}</p>
            <button onClick={increment}>증가</button>
        </div>
    );
}

3. 상태가 컴포넌트에 미치는 영향

상태는 컴포넌트의 UI를 동적으로 변화시키는 중요한 요소입니다. 상태가 바뀌면 컴포넌트와 관련된 모든 부분이 다시 렌더링되며, 이로 인해 최신 상태를 반영한 UI가 제공합니다.

3.1. Props와 State의 차이점

컴포넌트 간에 데이터 전달 시 사용되는 ‘props’와, 컴포넌트 내부의 데이터를 관리하는 ‘state’는 서로 다른 개념입니다. props는 부모 컴포넌트에서 자식 컴포넌트로 전달되는 읽기 전용 데이터이며, state는 컴포넌트가 자체적으로 관리하는 데이터입니다.

4. 리액트에서 컴포넌트와 상태 관리하기

리액트 애플리케이션은 보통 여러 개의 컴포넌트로 구성되며, 이들 간의 데이터 흐름은 상위 컴포넌트에서 하위 컴포넌트로 이루어집니다. 아래에서는 컴포넌트와 상태를 어떻게 효과적으로 관리할 수 있는지에 대해 설명하겠습니다.

4.1. 상태 끌어올리기

부모 컴포넌트에서 상태를 관리하고, 자식 컴포넌트에 props로 전달하는 방법을 ‘상태 끌어올리기’라고 합니다. 이렇게 하면 여러 자식 컴포넌트가 동일한 상태를 공유하며, 이를 통해 더욱 일관된 UI를 구축할 수 있습니다.

class ParentComponent extends React.Component {
    constructor(props) {
        super(props);
        this.state = { sharedState: 0 };
    }
    
    updateSharedState = (newValue) => {
        this.setState({ sharedState: newValue });
    }
    
    render() {
        return (
            <div>
                <ChildComponent sharedState={this.state.sharedState} updateSharedState={this.updateSharedState} />
            </div>
        );
    }
}

4.2. 상태 관리 라이브러리

프로젝트가 커지면서 상태 관리가 복잡해지면, Redux, MobX와 같은 상태 관리 라이브러리를 사용하는 것이 좋습니다. 이러한 라이브러리는 전역 상태를 관리하는데 유용하며, 복잡한 애플리케이션에서 상태 관리를 쉽게 할 수 있게 도와줍니다.

예를 들어, Redux를 사용하는 경우 다음과 같은 방식으로 상태를 관리할 수 있습니다.

import { createStore } from 'redux';

const initialState = { count: 0 };

const reducer = (state = initialState, action) => {
    switch (action.type) {
        case 'INCREMENT':
            return { count: state.count + 1 };
        default:
            return state;
    }
};

const store = createStore(reducer);

5. 리액트 컴포넌트의 라이프사이클

리액트 컴포넌트는 생성, 업데이트, 제거의 과정을 거치며, 이 각 단계에서 특정 메서드가 호출됩니다. 이를 ‘라이프사이클’이라고 합니다.

5.1. 라이프사이클 메서드

클래스 컴포넌트에서 사용할 수 있는 주요 라이프사이클 메서드로는 다음과 같은 것들이 있습니다.

  • componentDidMount: 컴포넌트가 첫 렌더링을 끝낸 후 호출됩니다.
  • componentDidUpdate: 컴포넌트가 업데이트된 후 호출됩니다.
  • componentWillUnmount: 컴포넌트가 언마운트(제거)될 때 호출됩니다.

6. 결론

리액트에서 컴포넌트와 상태는 애플리케이션의 구조와 동작에 매우 중요한 역할을 합니다. 컴포넌트를 통해 UI를 구성하고, 상태를 통해 동적인 사용자 경험을 제공하여, 최종 사용자가 만족하는 애플리케이션을 개발할 수 있습니다. 본 강좌를 통해 리액트의 기본 개념을 이해하고, 다양한 컴포넌트를 만들며, 상태를 관리하는 방법을 익히기를 바랍니다.

7. 추가 자료

리액트 공식 문서와 다양한 온라인 강의들을 통해 더 많은 정보를 찾아보실 수 있습니다. 아래는 유용한 링크입니다:

리액트 강좌: 함수

리액트는 사용자 인터페이스를 구축하기 위해 많이 사용되는 JavaScript 라이브러리입니다. 리액트를 이해하고 활용하기 위해서는 함수의 개념을 명확히 이해하는 것이 중요합니다. 본 강좌에서는 리액트에서 함수가 어떻게 사용되는지에 대해 자세히 다루고, 현대 웹 개발에서 함수형 프로그래밍이 어떻게 적용되는지에 대해 알아보겠습니다.

1. 리액트에서 함수의 정의

리액트에서 함수는 상태를 관리하거나 화면을 업데이트하는데 필요한 로직을 포함하는 기본 단위입니다. 리액트는 함수형 컴포넌트를 사용하여 UI를 정의할 수 있도록 지원합니다. 함수형 컴포넌트는 JavaScript 함수로, 이 함수에서 JSX를 반환하여 화면에 렌더링합니다. 함수형 컴포넌트는 간단하고 직관적이며, 리액트의 훅(Hook) 기능을 통해 상태와 생명주기 메서드를 사용할 수 있습니다.

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

리액트는 주로 두 가지 방식으로 컴포넌트를 정의할 수 있습니다: 클래스형 컴포넌트와 함수형 컴포넌트입니다. 클래스형 컴포넌트는 ES6 클래스를 사용하여 정의되며, 유지 관리 및 테스트가 어렵고 코드 양이 상대적으로 많아지는 경향이 있습니다. 반면, 함수형 컴포넌트는 단순하고 가벼우며, 코드가 짧아 유지 관리가 용이합니다.

함수형 컴포넌트는 다음과 같이 정의됩니다:


function MyComponent() {
    return <div>Hello, World!</div>;
}

클래스형 컴포넌트는 다음과 같이 정의됩니다:


class MyComponent extends React.Component {
    render() {
        return <div>Hello, World!</div>;
    }
}

3. 함수형 컴포넌트의 장점

  • 단순성: 함수형 컴포넌트는 더 적은 코드로 작성할 수 있으며, 이해하기 쉽습니다. 특히 복잡한 상태 관리 없이 UI를 간단하게 렌더링 할 수 있습니다.
  • 성능 최적화: 리액트는 함수형 컴포넌트를 메모이제이션(memoization)하여 최적화 할 수 있습니다. 이를 통해 다시 렌더링할 필요가 없는 경우 컴포넌트를 건너뛸 수 있어 성능을 크게 향상시킬 수 있습니다.
  • 사이드 이펙트 관리: 훅을 통해 부수 효과를 관리할 수 있어 상태 관리가 간편해집니다.

4. React Hook을 통한 상태 관리

리액트 16.8버전부터 도입된 훅(Hook)은 함수형 컴포넌트에서 상태를 관리할 수 있는 가장 효과적인 방법입니다. 가장 많이 사용하는 훅은 useState와 useEffect입니다.

4.1 useState 훅

useState는 상태 변수를 추가하고, 상태를 업데이트할 수 있는 함수를 반환합니다. 사용 방법은 다음과 같습니다:


import React, { useState } from 'react';

function Counter() {
    const [count, setCount] = useState(0);

    return (
        <div>
            <p>현재 카운트: {count}</p>
            <button onClick={() => setCount(count + 1)}>증가</button>
        </div>
    );
}

4.2 useEffect 훅

useEffect는 컴포넌트가 렌더링될 때마다 특정 작업을 수행할 수 있게 해주는 훅입니다. 다음은 useEffect를 사용하는 예시입니다.


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

function Timer() {
    const [seconds, setSeconds] = useState(0);

    useEffect(() => {
        const interval = setInterval(() => setSeconds(s => s + 1), 1000);
        return () => clearInterval(interval);
    }, []);

    return <p>경과 시간: {seconds}초</p>
}

5. 고급 Hooks

useReducer, useContext와 같은 고급 훅을 사용하면 더욱 복잡한 상태 관리가 필요할 때 유용합니다. 특히 useReducer는 복잡한 상태 로직이나 여러 하위 값을 관리할 때 유용합니다. 예를 들어, todo 리스트를 관리하는 데 사용할 수 있습니다.


import React, { useReducer } from 'react';

const initialState = { todos: [] };

function reducer(state, action) {
    switch (action.type) {
        case 'ADD_TODO':
            return { todos: [...state.todos, action.todo] };
        default:
            throw new Error();
    }
}

function TodoApp() {
    const [state, dispatch] = useReducer(reducer, initialState);
    
    const addTodo = todo => dispatch({ type: 'ADD_TODO', todo });

    return (
        <div>
            <h1>To Do List</h1>
            <button onClick={() => addTodo('새 할 일')}>추가</button>
            <ul>
                {state.todos.map((todo, index) => <li key={index}>{todo}</li>)}
            </ul>
        </div>
    );
}

6. 함수형 프로그래밍의 기본 원칙

리액트는 함수형 프로그래밍 패러다임을 따르는 경향이 있습니다. 여기 몇 가지 기본 원칙을 살펴보겠습니다.

  • 순수 함수: 출력이 항상 입력에만 의존해야 합니다. 외부 상태에 영향을 주어서는 안 됩니다.
  • 상태 불변성: 상태를 직접 변경하지 않고 새로운 상태를 반환합니다.
  • 고차 함수: 함수를 인자로 받거나 함수를 반환하는 함수를 의미합니다. 리액트에서는 props를 통해 컴포넌트를 전달하는 방식이 여기에 해당합니다.

7. 결론

리액트는 함수형 프로그래밍 패러다임을 따르며, 함수형 컴포넌트를 통해 UI를 정의하고 상태를 관리하는 데 많은 장점을 제공합니다. 이 강좌를 통해 함수형 컴포넌트의 정의와 장점, React Hooks, 그리고 함수형 프로그래밍의 주요 원칙을 살펴보았습니다. 리액트에서 함수를 잘 활용한다면, 더 효율적이고 관리하기 쉬운 애플리케이션을 구축할 수 있을 것입니다.

더 많은 정보를 원하시면 공식 리액트 문서(여기)를 참조하시기 바랍니다.

리액트 강좌: 컴포넌트에 값 전달하기

리액트(React)는 자바스크립트 라이브러리 중 하나로, 사용자 인터페이스를 구축하는데 효과적입니다. 특히, 컴포넌트 기반 아키텍처 덕분에 재사용 가능하고 유지보수가 용이한 구조로 애플리케이션을 개발할 수 있습니다. 이번 강좌에서는 리액트의 컴포넌트 간에 데이터를 전달하는 방법에 대해 심도 있게 알아보겠습니다.

1. 리액트의 기본 개념

리액트는 컴포넌트라는 독립적인 UI 조각으로 구성되어 있으며, 이러한 컴포넌트들이 모여서 복잡한 사용자 인터페이스를 형성합니다. 컴포넌트는 크게 두 가지 유형으로 나뉩니다: 함수형 컴포넌트클래스형 컴포넌트입니다.

1.1 함수형 컴포넌트

함수형 컴포넌트는 리액트의 최신 트렌드이며, 굉장히 간단하게 작성할 수 있습니다. 다음은 기본적인 함수형 컴포넌트의 예입니다:


function Greeting() {
    return <h1>안녕하세요!</h1>;
}
        

1.2 클래스형 컴포넌트

클래스형 컴포넌트는 JavaScript의 클래스를 사용하여 정의합니다. 아래는 클래스를 사용한 예입니다:


class Greeting extends React.Component {
    render() {
        return <h1>안녕하세요!</h1>;
    }
}
        

2. 컴포넌트 간의 값 전달하기

컴포넌트 간에 데이터를 전달하는 가장 일반적인 방법은 props를 사용하는 것입니다. Props는 상위 컴포넌트에서 하위 컴포넌트로 데이터를 전달할 때 사용되는 객체입니다.

2.1 Props의 정의와 사용

Props는 컴포넌트의 속성(properties)으로, 주로 하위 컴포넌트의 렌더링을 제어합니다. 먼저, 부모 컴포넌트에서 자식 컴포넌트에 props를 전달하는 기본적인 예를 살펴보겠습니다.


function ParentComponent() {
    const message = "안녕하세요! 리액트입니다.";
    return <ChildComponent message={message} />;
}

function ChildComponent(props) {
    return <p>{props.message}</p>;
}
        

위 예제에서는 ParentComponent에서 ChildComponentmessage라는 props를 전달하고 있습니다. 자식 컴포넌트는 이 값을 props.message를 통해 접근할 수 있습니다.

2.2 Props 타입 검사

리액트에서는 PropTypes를 사용하여 전달된 props의 데이터 타입을 검사할 수 있습니다. 이는 코드 안전성을 높이고, 디버깅을 쉽게 만듭니다. 예를 들어, 다음과 같이 사용할 수 있습니다:


import PropTypes from 'prop-types';

ChildComponent.propTypes = {
    message: PropTypes.string.isRequired,
};
        

위 예제에서 ChildComponentmessage가 문자열 타입이어야 하며, 필수 속성으로 설정되었습니다.

3. 컴포넌트 간 데이터 전달의 다양한 패턴

리액트에서 데이터 전달 방식은 props 외에도 몇 가지 다른 패턴을 통해 이뤄집니다. 이 장에서는 이러한 경우를 살펴보겠습니다.

3.1 상위-하위 컴포넌트 간 데이터 전달

상위 컴포넌트는 자식 컴포넌트에 props를 통해 데이터를 전달할 수 있습니다. 이 방식은 단방향 데이터 흐름을 보장하며, 상태를 관리하기 좋은 구조입니다.


function App() {
    const [count, setCount] = useState(0);

    return (
        <div>
            <Counter count={count} />
            <button onClick={() => setCount(count + 1)}>증가</button>
        </div>
    );
}

function Counter(props) {
    return <p>현재 카운트: {props.count}</p>;
}
        

3.2 하위-상위 컴포넌트 간 데이터 전달

하위 컴포넌트에서 상위 컴포넌트로 데이터를 전달하려면, 상위 컴포넌트에서 콜백 함수를 props로 자식에게 전달하는 방식이 일반적입니다.


function ParentComponent() {
    const handleChildData = (data) => {
        console.log(data);
    };

    return <ChildComponent onSendData={handleChildData} />;
}

function ChildComponent(props) {
    const sendData = () => {
        props.onSendData("자식 컴포넌트에서 보낸 데이터!");
    };

    return <button onClick={sendData}>데이터 보내기</button>;
}
        

3.3 Context API를 사용한 데이터 전달

여러 컴포넌트에 걸쳐 데이터를 전달해야 할 경우 Context API를 사용하는 것이 효율적입니다. Context API는 전역 상태 관리의 한 형태로, props를 통해 데이터를 일일이 전달하지 않고도 컴포넌트 트리 하위에서 데이터에 접근할 수 있게 해줍니다.


import React, { createContext, useContext } from 'react';

const MyContext = createContext();

function App() {
    return (
        <MyContext.Provider value={"전역 데이터"}>
            <ChildComponent />
        </MyContext.Provider>
    );
}

function ChildComponent() {
    const data = useContext(MyContext);
    return <p>{data}</p>;
}
        

4. 마무리

리액트에서 컴포넌트 간의 데이터 전달은 핵심적인 개념입니다. 이 강좌에서는 props를 사용한 데이터 전달 방법과 다양한 패턴에 대해 알아보았습니다. 각각의 경우에 따라 적절한 방법을 선택하고, 구조화된 프로그래밍 방식을 적용함으로써 효율적인 리액트 애플리케이션을 구축할 수 있습니다. 리액트를 배우는 과정에서 이 개념을 잘 익혀두면, 복잡한 애플리케이션을 다루는 데 큰 도움이 될 것입니다.

5. 참고 자료

리액트 강좌: 컴포넌트 트리에 데이터 공급하기, Context

리액트는 컴포넌트를 기반으로 한 사용자 인터페이스(UI)를 구축하는 데 사용되는 JavaScript 라이브러리입니다. 이 강좌에서는 React의 Context API를 활용하여 컴포넌트 트리에 데이터를 공급하는 방법에 대해 깊이 있게 다뤄보겠습니다. Context는 리액트의 강력한 기능 중 하나로, 컴포넌트 간에 데이터를 효율적으로 전달할 수 있도록 도와줍니다.

1. Context API란?

Context API는 리액트에서 데이터가 필요 없는 컴포넌트에게도 데이터를 전달할 수 있게 하는 도구입니다. 기본적으로 props drilling(프롭스를 아래로 전달하는 과정)을 피하는 데에 유용합니다. Context를 사용하면 상위 컴포넌트에서 하위 컴포넌트로 직접적으로 props를 전달할 필요 없이 데이터를 전달할 수 있습니다.

Context는 주로 전역 상태관리나 다수의 하위 요소에 필요한 데이터를 공유할 때 유용합니다. 예를 들어, 사용자 인증 정보, UI 언어 설정, 테마 정보 등을 Context를 사용하여 관리할 수 있습니다.

2. Context API의 구성 요소

Context API는 다음의 주요 구성 요소로 이루어져 있습니다:

  • Context 생성하기: React.createContext() 함수를 사용하여 Context를 생성합니다.
  • Provider 컴포넌트: Context의 Provider 컴포넌트를 사용하여 하위 컴포넌트에 데이터를 공급합니다.
  • Consumer 컴포넌트: 하위 컴포넌트에서 데이터를 구독하기 위한 Consumer 컴포넌트입니다. 이 기술은 render props 패턴을 사용합니다.
  • Hooks: useContext 훅을 사용하여 함수형 컴포넌트에서 Context를 사용할 수 있습니다.

3. Context의 생성 및 기본 사용법

Context를 생성하는 방법을 첫 번째로 살펴보겠습니다. 다음 예제를 통해 간단한 Context를 만들어 사용할 수 있는 방법을 설명합니다:


import React, { createContext, useContext, useState } from 'react';

// 3.1. Context 생성
const MyContext = createContext();

// 3.2. Provider 컴포넌트 생성
const MyProvider = ({ children }) => {
    const [value, setValue] = useState('안녕하세요, 리액트!');

    return (
        
            {children}
        
    );
};

// 3.3. Consumer 사용 예시
const MyComponent = () => {
    const { value } = useContext(MyContext);
    return 

{value}

; }; // 3.4. App 컴포넌트 const App = () => ( );

이 예제에서 MyContext를 생성하고, MyProvider를 통해 하위 컴포넌트에게 데이터를 공급하고 있습니다. MyComponent에서는 useContext 훅을 사용하여 Context의 값을 가져옵니다.

4. 리액트 Context의 고급 사용법

Context API를 사용할 때는 기본적인 사용법 외에도 여러 가지 고려해야 될 사항들이 있습니다. 이 섹션에서는 Context를 더 효과적으로 사용하는 여러 전략들에 대해 설명합니다.

4.1. 다중 Context 사용하기

하나의 어플리케이션에서 여러 개의 Context를 사용하는 것이 가능합니다. 다양한 데이터를 각각의 Context로 분리하면 코드가 간결해지며 유지보수성이 높아집니다. 예를 들어, 사용자 설정과 테마 설정, 언어 설정을 각기 다른 Context로 관리할 수 있습니다.


const ThemeContext = createContext();
const LanguageContext = createContext();
            

4.2. Context의 성능 최적화

Context를 사용할 때는 성능이 저하될 수 있습니다. Context에 변경이 생기면 하위 컴포넌트가 모두 다시 렌더링됩니다. 이를 방지하기 위해 더 세분화된 Context로 나누거나, Memoization을 활용하는 방법이 있습니다.


const MyComponent = React.memo(() => {
    const { value } = useContext(MyContext);
    return 

{value}

; });

4.3. Context와 Redux 비교

Context API와 Redux는 모두 전역 상태 관리를 위한 방법입니다. 하지만 Redux는 복잡한 상태 관리를 위한 패턴을 제시하고, 미들웨어와 같은 추가적인 기능을 제공합니다. 간단한 상태 관리에는 Context API가 적합하지만, 애플리케이션이 복잡해질수록 Redux를 고려하는 것이 좋습니다.

5. 리액트 실습 예제

이제 실습을 통해 Context API를 활용해보겠습니다. 아래는 사용자 인증 상태를 관리하는 간단한 예제입니다.


const AuthContext = createContext();

const AuthProvider = ({ children }) => {
    const [isAuthenticated, setIsAuthenticated] = useState(false);

    const login = () => setIsAuthenticated(true);
    const logout = () => setIsAuthenticated(false);

    return (
        
            {children}
        
    );
};

const LoginButton = () => {
    const { login } = useContext(AuthContext);
    return ;
};

const LogoutButton = () => {
    const { logout } = useContext(AuthContext);
    return ;
};

const AuthStatus = () => {
    const { isAuthenticated } = useContext(AuthContext);
    return 

{isAuthenticated ? '로그인 상태입니다' : '로그인 해주세요'}

; }; const App = () => ( );

위의 예제에서는 AuthContext를 만들어 사용자 인증 상태를 관리하고, 관련된 컴포넌트들이 Context를 통해 로그인 및 로그아웃 기능을 제공합니다.

6. 결론

Context API는 리액트에서 컴포넌트 간 데이터를 효율적으로 전달할 수 있게 해주는 강력한 도구입니다. 간단한 데이터 전송부터 복잡한 상태 관리까지 다양한 시나리오에서 활용할 수 있습니다. 성능 문제를 고려하여 적절하게 사용한다면 개발 효율을 크게 증대시킬 수 있습니다. 이번 강좌가 리액트 개발에 도움이 되었기를 바랍니다.

리액트 강좌: 컴포넌트 트리에 데이터 공급하기 및 Context로 To Do 앱 리팩토링하기

리액트는 현대 웹 애플리케이션을 구축하는 데 있어 가장 인기 있는 라이브러리 중 하나입니다. 그 이유는 컴포넌트 기반의 아키텍처, 재사용성, 그리고 복잡한 UI를 쉽게 관리할 수 있는 방법 때문입니다. 이번 강좌에서는 리액트의 Context API를 활용하여 컴포넌트 트리에 데이터를 공급하는 방법과 이를 통해 간단한 To Do 애플리케이션을 리팩토링하는 방법에 대해 알아보겠습니다.

1. 리액트 기본 개념

리액트는 UI를 구성하는 컴포넌트의 집합입니다. 컴포넌트는 상태(state)와 속성(props)을 가지며, 이 둘을 통해 UI가 어떻게 렌더링될지를 결정합니다.

1.1 상태와 속성

상태는 컴포넌트의 내부 데이터를 나타내며, 사용자의 입력이나 네트워크 요청에 따라 변경될 수 있습니다. 반면, 속성은 부모 컴포넌트로부터 자식 컴포넌트로 전달되는 데이터입니다.

1.2 컴포넌트 트리

리액트 애플리케이션은 여러 개의 컴포넌트들로 구성된 트리 형태로 구성됩니다. 이 트리 구조를 통해 데이터가 부모에서 자식으로 흐르는 것을 관리하게 됩니다.

2. Context API 소개

Context API는 리액트에서 컴포넌트 트리의 깊은 곳에 있는 컴포넌트에 데이터를 전달하기 위해 사용됩니다. 여러 레벨을 거치지 않고도 데이터를 공급할 수 있도록 만들어져 있습니다. 이를 통해 속성(props) 전파의 복잡성을 줄일 수 있습니다.

2.1 Context 만들기

Context를 만들기 위해서는 먼저 React의 createContext 함수를 사용해야 합니다.

import React, { createContext, useContext, useState } from 'react';

const MyContext = createContext(); // Context 생성

2.2 Provider와 Consumer

Context의 Provider 컴포넌트를 사용하여 하위 컴포넌트로 데이터를 전달합니다. Provider는 모든 하위 컴포넌트에서 접근할 수 있는 데이터를 제공합니다.

<MyContext.Provider value={/* context value */}>
    {/* children */}
</MyContext.Provider>

2.3 Context 사용하기

하위 컴포넌트에서 Context를 사용하기 위해서는 useContext 훅을 사용하여 데이터를 가져옵니다.

const value = useContext(MyContext); // Context 사용

3. To Do 앱 구조 설정하기

이제 Context API를 활용하여 간단한 To Do 앱을 만들어 보겠습니다. 먼저 기본적인 컴포넌트 구조를 설정합니다.

3.1 기본 컴포넌트 구조

To Do 앱은 다음과 같은 컴포넌트로 구성됩니다.

  • App: 전체 앱을 감싸는 컴포넌트
  • TodoProvider: To Do 리스트의 상태를 관리하는 Provider 컴포넌트
  • TodoList: To Do 항목 리스트를 렌더링하는 컴포넌트
  • TodoItem: 개별 To Do 항목을 렌더링하는 컴포넌트
  • AddTodo: 새로운 To Do 항목을 추가하는 컴포넌트

3.2 앱 코드 작성하기

먼저, TodoProvider 컴포넌트를 작성하여 To Do 리스트의 상태를 관리합니다.

const TodoProvider = ({ children }) => {
    const [todos, setTodos] = useState([]);

    const addTodo = (todo) => {
        setTodos([...todos, todo]);
    };

    const removeTodo = (id) => {
        setTodos(todos.filter(todo => todo.id !== id));
    };

    return (
        <MyContext.Provider value={{ todos, addTodo, removeTodo }}>
            {children}
        </MyContext.Provider>
    );
};

그리고 TodoListAddTodo 컴포넌트를 각각 작성합니다.

const TodoList = () => {
    const { todos, removeTodo } = useContext(MyContext);

    return (
        <ul>
            {todos.map(todo => (
                <TodoItem key={todo.id} todo={todo} onRemove={removeTodo} />
            ))}</ul>
    );
};

const AddTodo = () => {
    const { addTodo } = useContext(MyContext);
    const [inputValue, setInputValue] = useState('');

    const handleSubmit = (e) => {
        e.preventDefault();
        if (!inputValue) return;
        
        addTodo({ id: Date.now(), text: inputValue });
        setInputValue('');
    };

    return (
        <form onSubmit={handleSubmit}>
            <input 
                type="text" 
                value={inputValue} 
                onChange={(e) => setInputValue(e.target.value)} 
                placeholder="새 할 일 입력" 
            />
            <button type="submit">추가하기</button>
        </form>
    );
};

3.3 최종 앱 구조

최종적으로 App 컴포넌트에서 TodoProvider를 사용하여 다른 컴포넌트를 감싸줍니다.

const App = () => {
    return (
        <TodoProvider>
            <h1>할 일 리스트</h1>
            <AddTodo />
            <TodoList />
        </TodoProvider>
    );
};

4. 상태 관리 및 리팩토링

상태 관리는 리액트 애플리케이션에서 중요한 부분입니다. 이를 통해 나중에 데이터의 흐름과 연관성을 더욱 명확하게 할 수 있습니다. Context API를 사용하면 하위 컴포넌트에서 상태를 직접 접근할 수 있어 더욱 효율적으로 관리할 수 있습니다.

4.1 상태 관리 패턴

상태 관리를 위해 여러 가지 패턴을 사용할 수 있습니다. Context API와 함께 사용하는 경우, 컴포넌트가 서브스크라이브 하도록 설계해야 합니다. 이를 통해 재렌더링을 최소화할 수 있습니다.

4.2 리팩토링 예시

리팩토링을 통해 추가적인 기능을 안전하게 구현할 수 있습니다. 예를 들어, To Do 항목의 완료 여부를 처리하는 로직을 추가해 보겠습니다.

const toggleTodo = (id) => {
    setTodos(todos.map(todo => todo.id === id ? { ...todo, completed: !todo.completed } : todo));
};

4.3 완료된 To Do 항목 시각화하기

완료된 To Do 항목을 시각적으로 나타내기 위해 TodoItem 컴포넌트를 수정합니다.

const TodoItem = ({ todo, onRemove }) => {
    return (
        <li style={{ textDecoration: todo.completed ? 'line-through' : 'none' }}>
            {todo.text}
            <button onClick={() => onRemove(todo.id)}>삭제</button>
        </li>
    );
};

5. 결론

이번 강좌에서는 리액트의 Context API를 활용하여 컴포넌트 트리에 데이터를 공급하고 To Do 애플리케이션을 리팩토링하는 방법에 대해 배웠습니다. Context는 컴포넌트 간의 데이터 공유를 간편하게 하여 애플리케이션의 구조를 보다 깔끔하게 만들어 줍니다.

리액트를 활용한 상태 관리와 데이터 흐름의 이해는 앞으로 복잡한 애플리케이션을 구축하는 데 큰 도움이 될 것입니다. 이제 여러분도 직접 Context API를 활용하여 다양한 애플리케이션을 만들어 보시기를 권장합니다. 감사합니다!