<div id="readability-page-1" class="page"><p><cite>개 발자국</cite>
                  <span> 2023. 3. 30. 09:38</span>
                </p><div>
                                <h2 data-ke-size="size26">useContext란 ?</h2>
<figure data-ke-mobilestyle="widthOrigin" data-origin-width="768" data-origin-height="500">
    <span data-url="https://blog.kakaocdn.net/dn/6kJTX/btr6Qr4KUB5/WKOo4dmh2zg0erbUBdLcJ0/img.png" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/6kJTX/btr6Qr4KUB5/WKOo4dmh2zg0erbUBdLcJ0/img.png" onerror="this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';" data-origin-width="768" data-origin-height="500">
    </span>
    
</figure>

<p data-ke-size="size16"><code>useContext</code>는 react에서 제공하는 훅으로, 하위 컴포넌트에게 <code>context</code>를 제공하는 훅입니다. “context”란 직역하면 환경이라는 의미이지만, 여기서는 리액트에서는 각 컴포넌트가 참조할 수 있는 데이터 모음이라고 생각하시면 될 것 같습니다.</p>
<p data-ke-size="size16">아래의 코드는 프롭스를 하위 컴포넌트로 전달하는 예시입니다.</p>

<pre><code>import React from 'react'

function End({text} : {text : string}){
    return (
        &lt;div&gt;
            {text}
        &lt;/div&gt;
    )
}

function Middle({text} : {text : string}){
    return (
        &lt;div&gt;
            &lt;End text={text}/&gt;
        &lt;/div&gt;
    )
}

export default function App() {

    const text = "Hello world";

    return (
        &lt;div&gt;
            &lt;Middle text={text}/&gt;
        &lt;/div&gt;
    )
}</code></pre>
<p data-ke-size="size16">위 코드를 보면 End 컴포넌트에서 text를 사용하기 위해서 App -&gt; Middle -&gt; End 순으로 props를 계속 전달해주어야 합니다. 이를 이미지로 표현 하면 다음과 같습니다.</p>

<figure data-ke-mobilestyle="widthOrigin" data-origin-width="264" data-origin-height="455">
    <span data-url="https://blog.kakaocdn.net/dn/dvknZb/btr6N3qh9vf/VT2YcgxngKPG5NPxGqtBS0/img.png" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/dvknZb/btr6N3qh9vf/VT2YcgxngKPG5NPxGqtBS0/img.png" onerror="this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';" data-origin-width="264" data-origin-height="455">
    </span>
    
</figure>

<p data-ke-size="size16">위의 코드에서는 한개의 노드를 거쳐 <code>text</code> 프롭스가 전달되지만, 실제로 앱을 구성하게 되면저렇게 단순한 구조를 가지는 것이 아니라, 굉장히 깊고 브런치들이 많습니다. 그렇기에 값을 사용하는 컴포넌트까지 값을 운반하는 것은 매우 불편하고 어렵습니다. 다음은 위 처럼 props를 계속해서 전달해주었을 때, 나타나는 단점 목록입니다.</p>
<ol data-ke-list-type="disc">
<li>중간 컴포넌트에서 데이터를 변환하여 전달할 가능성이 있다.</li>
<li>props를 계속 전달해주어야 하기 때문에 컴포넌트 가독성이 떨어진다.</li>
<li>컴포넌트가 다른 컴포넌트와 강한 의존성을 가질 수 있다.</li>
</ol>
<p data-ke-size="size16">위와 같은 문제점으로 인하여, <code>props</code>를 계속 전달하는 행위에서 벗어나, 상위 컴포넌트에서 하위 컴포넌트들을 상태와 함께 감싸 상태를 공유 할 수 있는 <code>context</code> 라는 개념이 발생되었다.</p>

<p data-ke-size="size16">아래는 <code>context</code>를 설명한 이미지이다.</p>

<figure data-ke-mobilestyle="widthOrigin" data-origin-width="640" data-origin-height="514">
    <span data-url="https://blog.kakaocdn.net/dn/buox0k/btr6K2lalMM/KKzrZzbdSlX5izWzkUlkhk/img.png" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/buox0k/btr6K2lalMM/KKzrZzbdSlX5izWzkUlkhk/img.png" onerror="this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';" data-origin-width="640" data-origin-height="514">
    </span>
    
</figure>
<h2 data-ke-size="size26">useContext 사용해보기</h2>
<p data-ke-size="size16">리액트에서는 “context”를 생성하기 위한 <code>createContext</code>와 하위 컴포넌트에서 “context”에서 값을 읽고 변화를 감지하기 위한 <code>useContext</code> 를 제공해주고 있다.</p>
<p data-ke-size="size16">먼저 “createContext”의 타입은 다음과 같다.</p>

<pre><code>  function createContext&lt;T&gt;(defaultValue: T): Context&lt;T&gt;;
    type Provider&lt;T&gt; = ProviderExoticComponent&lt;ProviderProps&lt;T&gt;&gt;;
    type Consumer&lt;T&gt; = ExoticComponent&lt;ConsumerProps&lt;T&gt;&gt;;
    interface Context&lt;T&gt; {
        Provider: Provider&lt;T&gt;;
        Consumer: Consumer&lt;T&gt;;
        displayName?: string | undefined;
    }
</code></pre>
<p data-ke-size="size16">createContext를 호출 할 때 인자로 “context”의 초기값을 전달 한 다음 리턴된 Context를 이용하여, 하위 컴포넌트를 감싸게 됩니다.</p>
<p data-ke-size="size16">아래는 “context”를 생성한 뒤 하위 컴포넌트를 “context”로 감싸는 예시 코드입니다. (설명을 위해서, <code>useContext</code>는 사용하지 않았습니다.)</p>

<pre><code>import React,{createContext} from 'react'

const TextContext = createContext("Hello world")

function End(){
    return (
        &lt;div&gt;
            {''}
        &lt;/div&gt;
    )
}

function Middle(){
    return (
        &lt;div&gt;
            &lt;End/&gt;
        &lt;/div&gt;
    )
}

export default function App() {

    return (
        &lt;div&gt;
            &lt;TextContext.Provider value={"Hello world"}&gt;
                &lt;Middle/&gt;
            &lt;/TextContext.Provider&gt;
        &lt;/div&gt;
    )
}</code></pre>
<p data-ke-size="size16">아직까지는 큰 변화는 없습니다. 단순히, “App”에서 “context”로 하위 컴포넌트를 감싼 형태입니다. 하위 컴포넌트에서 context에 접근하여 값을 사용하려면 context를 사용하는 component에서 <code>useContext</code>를 사용해야 합니다.</p>

<p data-ke-size="size16">다음은 “end”컴포넌트에서 useContext로 TextContext를 사용한 코드와 결과물 이미지 입니다.</p>
<pre><code>import React,{createContext, useContext} from 'react'

const TextContext = createContext("Hello world")

function End(){
    const text = useContext(TextContext);
    return (
        &lt;div&gt;
            {text}
        &lt;/div&gt;
    )
}

function Middle(){
    return (
        &lt;div&gt;
            &lt;End/&gt;
        &lt;/div&gt;
    )
}

export default function App() {
    return (
        &lt;div&gt;
            &lt;TextContext.Provider value={"Hello world"}&gt;
                &lt;Middle/&gt;
            &lt;/TextContext.Provider&gt;
        &lt;/div&gt;
    )
}</code></pre>

<figure data-ke-mobilestyle="widthOrigin" data-origin-width="457" data-origin-height="162">
    <span data-url="https://blog.kakaocdn.net/dn/lq6Md/btr6NksmFaR/8DQMgY7T7KyUbmsVoEkgm1/img.png" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/lq6Md/btr6NksmFaR/8DQMgY7T7KyUbmsVoEkgm1/img.png" onerror="this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';" data-origin-width="457" data-origin-height="162">
    </span>
    
</figure>


<h2 data-ke-size="size26">context 값 변경하기</h2>
<p data-ke-size="size16">“Context” 의 값을 변경하는 것은 매우 간단합니다. 바로 “provider”의 <code>value</code>를 업데이트를 하면 이를 구독하는 컴포넌트가 다시 렌더링합니다.</p>
<p data-ke-size="size16">아래의 코드는 “input”으로 변경된 상태 값을 provider의 value로 전달하는 예시와 결과입니다.</p>
<pre><code>import React,{createContext, useContext, useState} from 'react'

const TextContext = createContext("Hello world")

function End(){
    const text = useContext(TextContext);
    return (
        &lt;div&gt;
            {text}
        &lt;/div&gt;
    )
}

function Middle(){

    return (
        &lt;div&gt;
            &lt;End/&gt;
        &lt;/div&gt;
    )
}

export default function App() {

    const [text, setText] = useState("Hello world")

    return (
        &lt;div&gt;
            &lt;TextContext.Provider value={text}&gt;
                &lt;Middle/&gt;
            &lt;/TextContext.Provider&gt;
            &lt;input type="text" onChange={(e) =&gt; setText(e.target.value)} /&gt;
        &lt;/div&gt;
    )
}</code></pre>

<figure data-ke-mobilestyle="widthOrigin" data-origin-width="664" data-origin-height="156">
    <span data-url="https://blog.kakaocdn.net/dn/bm3Sfb/btr6K26ubEY/5FJlUS2qtllKfJfYR8xLGk/img.gif" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/bm3Sfb/btr6K26ubEY/5FJlUS2qtllKfJfYR8xLGk/img.gif" onerror="this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';" data-origin-width="664" data-origin-height="156">
    </span>
    
</figure>


<p data-ke-size="size16">이런 걱정이 들 수 있습니다. <code>Provider</code>로 감싸진 하위 컴포넌트들이 상위 컴포넌트가 변경된 경우 “useContext를 사용하지 않는 컴포넌트들도 렌더링이 일어나는 것이 아닌가” ? 라는 의문이 발생 할 수 있습니다. 결과부터 말씀드리면 <code>Provider</code>의 <b>상태가 변경되면 하위 컴포넌트는 모두 렌더링이 발생됩니다</b>.</p>

<p data-ke-size="size16">미들 컴포넌트에 렌더링 될 때 마다 <code>console.log</code>를 사용할 수 있도록 코드를 입력 후 결과를 확인해보겠습니다.</p>

<figure data-ke-mobilestyle="widthOrigin" data-origin-width="664" data-origin-height="156">
    <span data-url="https://blog.kakaocdn.net/dn/b0fJCN/btr6NXwSlWV/0IYXuFbGiFNSBchKMFuE50/img.gif" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/b0fJCN/btr6NXwSlWV/0IYXuFbGiFNSBchKMFuE50/img.gif" onerror="this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';" data-origin-width="664" data-origin-height="156">
    </span>
    
</figure>

<p data-ke-size="size16">provider가 변화하면 하위 컴포넌트가 모두 재 렌더링 되는 이유는 <code>contextAPI</code>는 하위 컴포넌트에게 <code>props</code>를 계속 전달해줘야하는 <code>props drilling</code>을 해결하기 위한 방법이기 때문입니다.</p>
<h2 data-ke-size="size26">context를 사용하는 컴포넌트만 업데이트 하기</h2>
<p data-ke-size="size16">만약 자주 변경될 여지가 있는 “context”가 많은 컴포넌트를 감싸고 있고, 하위 컴포넌트도 많은 컴포넌트를 하위로 두고 있다면, 다시 렌더링되는 과정에서 앱의 <b>성능하락</b>으로 이어질 것이다. 그렇기에 “context”를 직접 사용하지 않는 컴포넌트가 “context”에 의해서 다시 렌더링 되는 것은 지양해야합니다.</p>

<p data-ke-size="size16">위의 예제에서 “Midldle” 컴포넌트가 ‘TextContext”가 변경될 때 마다 렌더링 되는 이유는 상위 “App” 컴포넌트에서 context가 변화하여, 다시 “Middle” 컴포넌트를 호출하기 때문입니다.</p>

<p data-ke-size="size16">“Middle” 컴포넌트가 사용하지 않는 <code>context</code> 때문에 다시 호출 되지 않기 위해서는 리액트에서 제공하는 <code>Memo</code> 함수를 사용하면 됩니다. “Memo”함수의 타입은 다음과 같습니다.</p>

<pre data-ke-language="javascript"><code>  function memo&lt;P extends object&gt;(
        Component: FunctionComponent&lt;P&gt;,
        propsAreEqual?: (prevProps: Readonly&lt;P&gt;, nextProps: Readonly&lt;P&gt;) =&gt; boolean
    ): NamedExoticComponent&lt;P&gt;;</code></pre>
<p data-ke-size="size16">이 함수는 첫번째 인자로 <code>함수형 컴포넌트</code> 를 제공 받고, 두번째 인자로는 이전 <code>props</code>와 새로 받은 <code>props</code>를 인자로 두고 <b>호출 여부를 반환</b>하는 콜백을 받습니다. 이 “memo” 함수를 요약하면 다음과 같습니다.</p>

<p data-ke-size="size16"><b>렌더링할 컴포넌트에 해당하는 props와 다음 props를 비교하여, 재 호출 여부를 결정하는 함수</b></p>

<p data-ke-size="size16">아래는 <code>memo</code>함수를 이용해서, “Middle” 컴포넌트를 감싼 코드 입니다.</p>
<pre><code>import React,{createContext, useContext, useState,memo} from 'react'

const TextContext = createContext("Hello world")

function End(){
    const text = useContext(TextContext);
    return (
        &lt;div&gt;
            {text}
        &lt;/div&gt;
    )
}

const MemoizedMiddle = memo(Middle);

function Middle(){
    console.log("Middle Render")
    return (
        &lt;div&gt;
            &lt;End/&gt;
        &lt;/div&gt;
    )
}

export default function App() {

    const [text, setText] = useState("Hello world")

    return (
        &lt;div&gt;
            &lt;TextContext.Provider value={text}&gt;
                &lt;MemoizedMiddle&gt;&lt;/MemoizedMiddle&gt;
            &lt;/TextContext.Provider&gt;
            &lt;input type="text" onChange={(e) =&gt; setText(e.target.value)} /&gt;
        &lt;/div&gt;
    )
}</code></pre>

<p data-ke-size="size16">memo 함수 두번째 인자로 콜백을 전달하지 않았습니다. 이로 인하여, “memo”로 감싸진 “Middle” 컴포넌트는 자신의 상태를 변경하지 않는 이상 다시 렌더링 되거나 상위에서 <b>다시 호출 되지 않습니다.&nbsp;</b>아래는 위 코드의 결과 입니다.</p>

<figure data-ke-mobilestyle="widthOrigin" data-origin-width="664" data-origin-height="156">
    <span data-url="https://blog.kakaocdn.net/dn/D48SB/btr6OlqIMTL/eMoSfqbbxRke6Ymj2D1HPk/img.gif" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/D48SB/btr6OlqIMTL/eMoSfqbbxRke6Ymj2D1HPk/img.gif" onerror="this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';" data-origin-width="664" data-origin-height="156">
    </span>
    
</figure>

<h2 data-ke-size="size26">결론</h2>
<p data-ke-size="size16">컨텍스트 api가 변경되면 하위 컴포넌트들이 모두 재 호출 되기 때문에, 쓸대없는 렌더링을 막기 위해서는 <code>memo</code>와 같은 방어수단이 필요하다. 이런 이유로 <code>contextAPI</code>를 사용하면 하위 컴포넌트의 재 호출을 막기위해서 컴포넌트를 감싸는 코드를 계속 생산해야 한다. 이는 <b>코드의 가독성을 해치고 생산성이 낮아지는 결과</b>를 불러옵니다.</p>

<p data-ke-size="size16">위의 이유말고도 context를 논리적으로 분리하였다면 context의 중첩은 필연적이게 되어 코드의 가독성을 해치게 됩니다. 아래는 중첩된 “context”의 예시 코드입니다.&nbsp;</p>

<pre><code>
const TextContext = createContext("Hello world")
const NumbContext = createContext(1);
const BoolContext = createContext(true)

export default function App() {

    const [text, setText] = useState("Hello world")

    return (
        &lt;div&gt;
            &lt;TextContext.Provider value={text}&gt;
                &lt;NumbContext.Provider value={1}&gt;
                    &lt;BoolContext.Provider value={true}&gt;
                        &lt;MemoizedMiddle&gt;&lt;/MemoizedMiddle&gt;
                    &lt;/BoolContext.Provider &gt;
                &lt;/NumbContext.Provider&gt;
            &lt;/TextContext.Provider&gt;
            &lt;input type="text" onChange={(e) =&gt; setText(e.target.value)} /&gt;
        &lt;/div&gt;
    )
}</code></pre>

<p data-ke-size="size16">위와 같은 이유들 때문에 <code>context</code>는 단점들이 많은 것 같지만 여전히 <code>props drilling</code>은 매력적이다. 그렇기에, <code>context api</code>는 상태변화가 거의 일어나지 않을 것으로 예상되는 테마와 같은 값을 전달하기에 적합합니다.</p>
            
            
                </div></div>

자스민

useContext란 ?
useContext는 react에서 제공하는 훅으로, 하위 컴포넌트에게 context를 제공하는 훅입니다. “context”란 직역하면 환경이라는 의미이지만, 여기서는 리액트에서는 각 컴포넌트가 참조할 수 있는 데이터 모음이라고 생각하시면 될 것 같습니다.
아래의 코드는 프롭스를 하위 컴포넌트로 전달하는 예시입니다.
 
import React from 'react'
function End({text} : {text : string}){
    return (
        <div>
            {text}
        </div>
    )
}
function Middle({text} : {text : string}){
    return (
        <div>
            <End text={text}/>
        </div>
    )
}
export default function App() {
    const text = "Hello world";
    return (
        <div>
            <Middle text={text}/>
        </div>
    )
}
위 코드를 보면 End 컴포넌트에서 text를 사용하기 위해서 App -> Middle -> End 순으로 props를 계속 전달해주어야 합니다. 이를 이미지로 표현 하면 다음과 같습니다.
 
 
위의 코드에서는 한개의 노드를 거쳐 text 프롭스가 전달되지만, 실제로 앱을 구성하게 되면저렇게 단순한 구조를 가지는 것이 아니라, 굉장히 깊고 브런치들이 많습니다. 그렇기에 값을 사용하는 컴포넌트까지 값을 운반하는 것은 매우 불편하고 어렵습니다. 다음은 위 처럼 props를 계속해서 전달해주었을 때, 나타나는 단점 목록입니다.
중간 컴포넌트에서 데이터를 변환하여 전달할 가능성이 있다.
props를 계속 전달해주어야 하기 때문에 컴포넌트 가독성이 떨어진다.
컴포넌트가 다른 컴포넌트와 강한 의존성을 가질 수 있다.
위와 같은 문제점으로 인하여, props를 계속 전달하는 행위에서 벗어나, 상위 컴포넌트에서 하위 컴포넌트들을 상태와 함께 감싸 상태를 공유 할 수 있는 context 라는 개념이 발생되었다.
 
아래는 context를 설명한 이미지이다.
 
useContext 사용해보기
리액트에서는 “context”를 생성하기 위한 createContext와 하위 컴포넌트에서 “context”에서 값을 읽고 변화를 감지하기 위한 useContext 를 제공해주고 있다.
먼저 “createContext”의 타입은 다음과 같다.
 
  function createContext<T>(defaultValue: T): Context<T>;
    type Provider<T> = ProviderExoticComponent<ProviderProps<T>>;
    type Consumer<T> = ExoticComponent<ConsumerProps<T>>;
    interface Context<T> {
        Provider: Provider<T>;
        Consumer: Consumer<T>;
        displayName?: string | undefined;
    }
createContext를 호출 할 때 인자로 “context”의 초기값을 전달 한 다음 리턴된 Context를 이용하여, 하위 컴포넌트를 감싸게 됩니다.
아래는 “context”를 생성한 뒤 하위 컴포넌트를 “context”로 감싸는 예시 코드입니다. (설명을 위해서, useContext는 사용하지 않았습니다.)
 
import React,{createContext} from 'react'
const TextContext = createContext("Hello world")
function End(){
    return (
        <div>
            {''}
        </div>
    )
}
function Middle(){
    return (
        <div>
            <End/>
        </div>
    )
}
export default function App() {
    return (
        <div>
            <TextContext.Provider value={"Hello world"}>
                <Middle/>
            </TextContext.Provider>
        </div>
    )
}
아직까지는 큰 변화는 없습니다. 단순히, “App”에서 “context”로 하위 컴포넌트를 감싼 형태입니다. 하위 컴포넌트에서 context에 접근하여 값을 사용하려면 context를 사용하는 component에서 useContext를 사용해야 합니다.
 
다음은 “end”컴포넌트에서 useContext로 TextContext를 사용한 코드와 결과물 이미지 입니다.
import React,{createContext, useContext} from 'react'
const TextContext = createContext("Hello world")
function End(){
    const text = useContext(TextContext);
    return (
        <div>
            {text}
        </div>
    )
}
function Middle(){
    return (
        <div>
            <End/>
        </div>
    )
}
export default function App() {
    return (
        <div>
            <TextContext.Provider value={"Hello world"}>
                <Middle/>
            </TextContext.Provider>
        </div>
    )
}
 
 
 
context 값 변경하기
“Context” 의 값을 변경하는 것은 매우 간단합니다. 바로 “provider”의 value를 업데이트를 하면 이를 구독하는 컴포넌트가 다시 렌더링합니다.
아래의 코드는 “input”으로 변경된 상태 값을 provider의 value로 전달하는 예시와 결과입니다.
import React,{createContext, useContext, useState} from 'react'
const TextContext = createContext("Hello world")
function End(){
    const text = useContext(TextContext);
    return (
        <div>
            {text}
        </div>
    )
}
function Middle(){
    return (
        <div>
            <End/>
        </div>
    )
}
export default function App() {
    const [text, setText] = useState("Hello world")
    return (
        <div>
            <TextContext.Provider value={text}>
                <Middle/>
            </TextContext.Provider>
            <input type="text" onChange={(e) => setText(e.target.value)} />
        </div>
    )
}
 
 
 
이런 걱정이 들 수 있습니다. Provider로 감싸진 하위 컴포넌트들이 상위 컴포넌트가 변경된 경우 “useContext를 사용하지 않는 컴포넌트들도 렌더링이 일어나는 것이 아닌가” ? 라는 의문이 발생 할 수 있습니다. 결과부터 말씀드리면 Provider의 상태가 변경되면 하위 컴포넌트는 모두 렌더링이 발생됩니다.
 
미들 컴포넌트에 렌더링 될 때 마다 console.log를 사용할 수 있도록 코드를 입력 후 결과를 확인해보겠습니다.
 
 
provider가 변화하면 하위 컴포넌트가 모두 재 렌더링 되는 이유는 contextAPI는 하위 컴포넌트에게 props를 계속 전달해줘야하는 props drilling을 해결하기 위한 방법이기 때문입니다.
context를 사용하는 컴포넌트만 업데이트 하기
만약 자주 변경될 여지가 있는 “context”가 많은 컴포넌트를 감싸고 있고, 하위 컴포넌트도 많은 컴포넌트를 하위로 두고 있다면, 다시 렌더링되는 과정에서 앱의 성능하락으로 이어질 것이다. 그렇기에 “context”를 직접 사용하지 않는 컴포넌트가 “context”에 의해서 다시 렌더링 되는 것은 지양해야합니다.
 
위의 예제에서 “Midldle” 컴포넌트가 ‘TextContext”가 변경될 때 마다 렌더링 되는 이유는 상위 “App” 컴포넌트에서 context가 변화하여, 다시 “Middle” 컴포넌트를 호출하기 때문입니다.
 
“Middle” 컴포넌트가 사용하지 않는 context 때문에 다시 호출 되지 않기 위해서는 리액트에서 제공하는 Memo 함수를 사용하면 됩니다. “Memo”함수의 타입은 다음과 같습니다.
 
  function memo<P extends object>(
        Component: FunctionComponent<P>,
        propsAreEqual?: (prevProps: Readonly<P>, nextProps: Readonly<P>) => boolean
    ): NamedExoticComponent<P>;
이 함수는 첫번째 인자로 함수형 컴포넌트 를 제공 받고, 두번째 인자로는 이전 props와 새로 받은 props를 인자로 두고 호출 여부를 반환하는 콜백을 받습니다. 이 “memo” 함수를 요약하면 다음과 같습니다.
 
렌더링할 컴포넌트에 해당하는 props와 다음 props를 비교하여, 재 호출 여부를 결정하는 함수
 
아래는 memo함수를 이용해서, “Middle” 컴포넌트를 감싼 코드 입니다.
import React,{createContext, useContext, useState,memo} from 'react'
const TextContext = createContext("Hello world")
function End(){
    const text = useContext(TextContext);
    return (
        <div>
            {text}
        </div>
    )
}
const MemoizedMiddle = memo(Middle);
function Middle(){
    console.log("Middle Render")
    return (
        <div>
            <End/>
        </div>
    )
}
export default function App() {
    const [text, setText] = useState("Hello world")
    return (
        <div>
            <TextContext.Provider value={text}>
                <MemoizedMiddle></MemoizedMiddle>
            </TextContext.Provider>
            <input type="text" onChange={(e) => setText(e.target.value)} />
        </div>
    )
}
 
memo 함수 두번째 인자로 콜백을 전달하지 않았습니다. 이로 인하여, “memo”로 감싸진 “Middle” 컴포넌트는 자신의 상태를 변경하지 않는 이상 다시 렌더링 되거나 상위에서 다시 호출 되지 않습니다. 아래는 위 코드의 결과 입니다.
 
 
결론
컨텍스트 api가 변경되면 하위 컴포넌트들이 모두 재 호출 되기 때문에, 쓸대없는 렌더링을 막기 위해서는 memo와 같은 방어수단이 필요하다. 이런 이유로 contextAPI를 사용하면 하위 컴포넌트의 재 호출을 막기위해서 컴포넌트를 감싸는 코드를 계속 생산해야 한다. 이는 코드의 가독성을 해치고 생산성이 낮아지는 결과를 불러옵니다.
 
위의 이유말고도 context를 논리적으로 분리하였다면 context의 중첩은 필연적이게 되어 코드의 가독성을 해치게 됩니다. 아래는 중첩된 “context”의 예시 코드입니다. 
 
const TextContext = createContext("Hello world")
const NumbContext = createContext(1);
const BoolContext = createContext(true)
export default function App() {
    const [text, setText] = useState("Hello world")
    return (
        <div>
            <TextContext.Provider value={text}>
                <NumbContext.Provider value={1}>
                    <BoolContext.Provider value={true}>
                        <MemoizedMiddle></MemoizedMiddle>
                    </BoolContext.Provider >
                </NumbContext.Provider>
            </TextContext.Provider>
            <input type="text" onChange={(e) => setText(e.target.value)} />
        </div>
    )
}
 
위와 같은 이유들 때문에 context는 단점들이 많은 것 같지만 여전히 props drilling은 매력적이다. 그렇기에, context api는 상태변화가 거의 일어나지 않을 것으로 예상되는 테마와 같은 값을 전달하기에 적합합니다.

useContext 조금 더 자세히 사용해보기

댓글