<div id="readability-page-1" class="page"><p><cite>개 발자국</cite>
                  <span> 2023. 3. 23. 09:04</span>
                </p><div>
                                <h2 data-ke-size="size26">컴포넌트내에서의 상태 갱신</h2>
<figure data-ke-mobilestyle="widthOrigin" data-origin-width="768" data-origin-height="500">
    <span data-url="https://blog.kakaocdn.net/dn/crhVFM/btr5orzzGXO/qct9Xo5PuqHzfEfhkSDGik/img.png" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/crhVFM/btr5orzzGXO/qct9Xo5PuqHzfEfhkSDGik/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">React를 접하는 이들이 가장 먼저 사용해보는 <b>컴포넌트의 상태를 관리하는 Hook</b>이다. 아래의 간단한 코드를 보자. 아래의 예제는 두개의 버튼을 두어, numb라는 값을 1씩 증가시키거나, 감소시킨다.</p>
<pre><code>import React from 'react'

export default function App() {

    let numb = 0;

    return (
        &lt;div&gt;
            &lt;div className='numb'&gt;
                {numb}
            &lt;/div&gt;
            &lt;div className='buttons'&gt;
            &lt;button onClick={() =&gt; {
                numb += 1
                console.log(numb)
            }}&gt;
                Increase
            &lt;/button&gt;
            &lt;button onClick={() =&gt; {
                numb -= 1
                console.log(numb)
            }}&gt;
                Decrease
            &lt;/button&gt;
            &lt;/div&gt;
        &lt;/div&gt;
    )
}</code></pre>
<p data-ke-size="size16">아래는 결과이다. 우리는 화면에 numb가 버튼의 클릭에 따라 갱신되기를 기대했지만, 화면에 갱신은 되지 않지만, 값은 실제로 변하고 있다.</p>
<figure data-ke-mobilestyle="widthOrigin" data-origin-width="596" data-origin-height="412">
    <span data-url="https://blog.kakaocdn.net/dn/xrBeT/btr5rgDvmKz/5gIHFfL59vs9RYJ8qNzwz0/img.gif" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/xrBeT/btr5rgDvmKz/5gIHFfL59vs9RYJ8qNzwz0/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="596" data-origin-height="412">
    </span>
    
</figure>

<p data-ke-size="size16">함수형 컴포넌트에서 돔(화면)을 업데이트하는 것은 [“newProps”, “useState”,”useReducer”,”useContext”] 를 이용하는 것이다. 즉 컴포넌트내부에서 아무리 변수를 변경하여도, 위의 4가지 방법을 이용하지 않고는 컴포넌트가 다시 렌더링 되지 않는다.</p>

<figure data-ke-mobilestyle="widthOrigin" data-origin-width="1262" data-origin-height="1078">
    <span data-url="https://blog.kakaocdn.net/dn/nnia8/btr5vsQRvS4/9J1HiHb9fSY7UNOBJZQiS0/img.png" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/nnia8/btr5vsQRvS4/9J1HiHb9fSY7UNOBJZQiS0/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="1262" data-origin-height="1078">
    </span>
    
</figure>
<p data-ke-size="size16"><b>함수형 컴포넌트도 결국에는 함수이다.</b> 한번 돔을 리턴 한 함수는 다시 한번 호출하지 않으면, 돔을 새롭게 변경 할 수 없다. 그렇기에 다시 한번 함수형 컴포넌트를 호출 할 수 있는 방법을 사용해서, 새롭게 렌더링해야한다.</p>
<h2 data-ke-size="size26">useState 사용해보기</h2>
<pre><code>import React,{useState} from 'react'

export default function App() {

    const [numb, setNumb] = useState(0);
        return (...)
}</code></pre>
<p data-ke-size="size16">useState는 react 라이브러리에서 가져와 사용 할 수 있다. **useState는 파라메터로 기본 값을 전달하고, 현재 상태의 값과 이 상태를 업데이트 할 수 있는 set 함수를 담은 배열을 반환한다. 보통 이 반환된 값과 함수의 명명 규칙은 <code>[상태, set상태]</code> 의 형태를 취한다.</p>
<p data-ke-size="size16">리턴되는 값이 배열(튜플)이기에 아래와 같이 사용 할 수 있지만, <b>배열 구조 할당을 이용해서, 훨씬 가독성이 좋은 코드를 쓸 수 있기 때문에,</b> 사용하지는 않는다.</p>
<pre><code>import React,{useState} from 'react'

export default function App() {

    const numbState = useState(0);


    return (
        &lt;div&gt;
            &lt;div className='numb'&gt;
                {numbState[0]}
            &lt;/div&gt;
            ...
            )
}</code></pre>
<p data-ke-size="size16">반환된 상태값과 업데이트 함수를 사용하여, 아래와 같이 예제를 완성 할 수 있다.</p>
<pre><code>import React,{useState} from 'react'

export default function App() {

    const [numb, setNumb] = useState(0);


    return (
        &lt;div&gt;
            &lt;div className='numb'&gt;
                {numb}
            &lt;/div&gt;
            &lt;div className='buttons'&gt;
            &lt;button onClick={() =&gt; {
                setNumb(numb + 1)
            }}&gt;
                Increase
            &lt;/button&gt;
            &lt;button onClick={() =&gt; {
                setNumb(numb - 1)
            }}&gt;
                Decrease
            &lt;/button&gt;
            &lt;/div&gt;
        &lt;/div&gt;
    )
}</code></pre>
<figure data-ke-mobilestyle="widthOrigin" data-origin-width="540" data-origin-height="292">
    <span data-url="https://blog.kakaocdn.net/dn/PXY8V/btr5oApm4iD/Fx4YRBCCn8Sbpg010WkMck/img.gif" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/PXY8V/btr5oApm4iD/Fx4YRBCCn8Sbpg010WkMck/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="540" data-origin-height="292">
    </span>
    
</figure>

<h2 data-ke-size="size26">useStatus로 배열다루기</h2>
<p data-ke-size="size16">useState로 배열을 다루는 것도 동일하다. 버튼을 클릭하여, 인풋에 전달된 값을 리스트로 표현해보자.</p>
<pre><code>import React,{useState} from 'react'

export default function App() {

    const [name, setName] = useState("");
    const [users,setUsers] = useState&lt;string[]&gt;(["Lee", "Kim"]);

    function userInsert(name : string){
        setUsers([...users,name])
    }

    return (
        &lt;div&gt;
            &lt;div&gt;
                &lt;input type='text' onChange={(e) =&gt; setName(e.target.value)}/&gt;
                &lt;button onClick={() =&gt; userInsert(name)}&gt;
                    Insert
                &lt;/button&gt;
            &lt;/div&gt;
            {users.map((v) =&gt; {
                return &lt;div&gt;{v}&lt;/div&gt;
            })}
        &lt;/div&gt;
    )
}</code></pre>
<h2 data-ke-size="size26">setState함수를 조금 더 함수형 프로그래밍에 맞게 작성해보자.</h2>
<p data-ke-size="size16">현재 배열을 다루기 위해, userInsert 함수는 파라매터로 새로운 name을 받지만 setUsers에서 이전 배열을 다루기위해서, 함수 외부에서 users를 불러와 이전 내용을 새로운 배열에 입력한다. 이처럼 함수내부에서 외부의 지역변수를 참조하는 것을 <b>클로저</b>라고 한다.</p>
<p data-ke-size="size16">클로저를 이용해 이전 값을 활용하는 것은 문제가 되지 않으나, 내부함수가 어딘가에서 계속 유지되고 있다면 이전 값은 스코프가 유지되어 메모리 해제가 발생하지 않을 수 있다. (물론 코드를 깔끔하게 유지하고 이를 신경쓴다면 문제 되지 않을 수 있다.)</p>
<p data-ke-size="size16">아래의 코드는 useState와 setState함수의 타입이다.</p>

<pre><code>    function useState&lt;S&gt;(initialState: S | (() =&gt; S)): [S, Dispatch&lt;SetStateAction&lt;S&gt;&gt;];
    // Unlike the class component setState, the updates are not allowed to be partial
    type SetStateAction&lt;S&gt; = S | ((prevState: S) =&gt; S);
    // this technically does accept a second argument, but it's already under a deprecation warning
    // and it's not even released so probably better to not define it.
    type Dispatch&lt;A&gt; = (value: A) =&gt; void;
    // Since action _can_ be undefined, dispatch may be called without any parameters.</code></pre>

<p data-ke-size="size16">위의 <code>dispatch</code>함수를 보면, 2가지의 활용 방법이 존재한다. 하나는 값을 바로 집어넣어 상태를 업데이트 하는 것이고 다른 한가지는 콜백함수를 이용해서, 이전 값을 파라메터로 받는 콜백함수를 전달 하는 것이다.</p>
<p data-ke-size="size16">콜백 함수를 이용해 이전 값에 접근하도록 함수를 변경해보자.</p>

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

export default function App() {

    const [name, setName] = useState("");
    const [users,setUsers] = useState&lt;string[]&gt;(["Lee", "Kim"]);

    function userInsert(name : string){
        setUsers((prevState) =&gt; [...prevState,name])
    }

    return (
        &lt;div&gt;
            &lt;div&gt;
                &lt;input type='text' onChange={(e) =&gt; setName(e.target.value)}/&gt;
                &lt;button onClick={() =&gt; userInsert(name)}&gt;
                    Insert
                &lt;/button&gt;
            &lt;/div&gt;
            {users.map((v) =&gt; {
                return &lt;div&gt;{v}&lt;/div&gt;
            })}
        &lt;/div&gt;
    )
}</code></pre>
<p data-ke-size="size16">이처럼 상태를 변경하기 위해 이전 값에 접근 하는 경우가 존재한다면, 콜백함수를 이용하도록 하자.</p>
<h2 data-ke-size="size26">초기 상태값 다루기</h2>
<p data-ke-size="size16">함수형 컴포넌트는 파라메터를 이용하여, 리액트 엘리먼트를 반환하는 <b>순수 함수</b>이기 때문에, <b>상태변화나 프롭스가 변경되어 리렌더링 된다는 의미는 함수를 다시 호출 한다는 의미이다.</b></p>
<p data-ke-size="size16">배열의 길이를 계산하는 함수를 O(n)으로 설정하고 이를 최초 초기값으로 넣어 보자.</p>
<pre><code>import React,{useState} from 'react'

function hardComputingFunction(arr : any[]){
    // O(n)의 시간이 걸리는 작업.

    console.log("Hard Computeing start")
    let count = 0;
    for(const _ of arr) count +=1;
    return count
}

const defaultUsers = ["Lee", "Kim"];

export default function App() {

    const [name, setName] = useState("");
    const [users,setUsers] = useState&lt;string[]&gt;(defaultUsers);
    const [userLength, setUserLength] = useState(hardComputingFunction(defaultUsers));

    function userInsert(name : string){
        setUsers((prevState) =&gt; [...prevState,name])
        setUserLength((prevState) =&gt; prevState + 1);
    }

    return (
        &lt;div&gt;
            &lt;div&gt;
                &lt;input type='text' onChange={(e) =&gt; setName(e.target.value)}/&gt;
                &lt;button onClick={() =&gt; userInsert(name)}&gt;
                    Insert
                &lt;/button&gt;
                Now : {userLength}
            &lt;/div&gt;

            {users.map((v) =&gt; {
                return &lt;div&gt;{v}&lt;/div&gt;
            })}
        &lt;/div&gt;
    )
}</code></pre>
<figure data-ke-mobilestyle="widthOrigin" data-origin-width="830" data-origin-height="282">
    <span data-url="https://blog.kakaocdn.net/dn/cZdCt4/btr5pyYUNj2/yI5Lxc9SoztSuTXVtqPnx0/img.gif" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/cZdCt4/btr5pyYUNj2/yI5Lxc9SoztSuTXVtqPnx0/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="830" data-origin-height="282">
    </span>
    
</figure>

<p data-ke-size="size16">상태가 변경될 때 마다 계속해서, 초기값으로 전달했던 함수가 실행되는 것을 볼 수 있다. 이는 위에서 언급 하였듯이, 렌더링되는 과정에서 함수 컴포넌트를 호출 하고 함수내에 존재하는 모든 구문이 다시 시작되기 때문에 발생하는 것이다.</p>

<p data-ke-size="size16">위와 같은 문제를 해결하는 방법은 <code>lazy initializtion</code>을 사용하는 것이다. 뭔가 이름은 거창하지만 실제로는 적용하는데 어려움이 없다. <code>lazy initializtion</code>은 useState 초기값에 복잡한 연산을 포함할 때, 사용되는 것이며 <b>오직 state를 처음 만들어 질때만 실행된다.</b> 이를 사용한다면 다시 렌더링이 되어 초기값을 계산할 때, 함수를 호출하지 않는다.</p>

<p data-ke-size="size16"><b>이를 구현하는 방법은 함수의 값을 전달하는 것이아니라, 콜백을 전달하여 리턴 값으로 해당 함수를 반환하도록 하는 방법이다.</b></p>

<p data-ke-size="size16">아래는 “게으른 초기화”를 적용한 코드와 결과이다.</p>
<pre><code>import React,{useState} from 'react'

function hardComputingFunction(arr : any[]){
    // O(n)의 시간이 걸리는 작업.

    console.log("Hard Computeing start")
    let count = 0;
    for(const _ of arr) count +=1;
    return count
}

const defaultUsers = ["Lee", "Kim"];

export default function App() {

    const [name, setName] = useState("");
    const [users,setUsers] = useState&lt;string[]&gt;(defaultUsers);
    const [userLength, setUserLength] = useState(() =&gt; hardComputingFunction(defaultUsers));

    function userInsert(name : string){
        setUsers((prevState) =&gt; [...prevState,name])
        setUserLength((prevState) =&gt; prevState + 1);
    }

    return (
        &lt;div&gt;
            &lt;div&gt;
                &lt;input type='text' onChange={(e) =&gt; setName(e.target.value)}/&gt;
                &lt;button onClick={() =&gt; userInsert(name)}&gt;
                    Insert
                &lt;/button&gt;
                Now : {userLength}
            &lt;/div&gt;
            {users.map((v,i) =&gt; {
                return &lt;div key={i}&gt;{v}&lt;/div&gt;
            })}
        &lt;/div&gt;
    )
}</code></pre>
<p data-ke-size="size16"><code>lazy initialization</code>을 적용 했을 때, 상태가 변경되어 컴포넌트가 계속 렌더링되어도 <code>hardComputingFunction</code> 는 실행되지 않는다.</p>

<figure data-ke-mobilestyle="widthOrigin" data-origin-width="830" data-origin-height="282">
    <span data-url="https://blog.kakaocdn.net/dn/bzuGRr/btr5oO8KcPn/APROU23KlnVUUWhuFomN1K/img.gif" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/bzuGRr/btr5oO8KcPn/APROU23KlnVUUWhuFomN1K/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="830" data-origin-height="282">
    </span>
    
</figure>
<h2 data-ke-size="size26">잘못된 오해</h2>
<p data-ke-size="size16">이 포스트를 올리기위해, <b>useState</b>의 다양한 블로그 글들을 확인 하였는데 이상한 점이 많이 보였다. 바로 <code>useState 비동기</code>라는 제목으로 돌아다니는 포스트들인데, 대부분의 예시가 다음과 같다.아래는 userInsert 함수를 호출 한 뒤, “setUserLength” 함수에 <code>users.length + 1</code> 을 해서, 최신상태의 users의 길이에 1씩 연속적으로 더해 <code>users.length + 3</code>이 출력되게 끔 하는 목적의 코드이다.</p>
<pre><code>export default function App() {

    const [name, setName] = useState("");
    const [users,setUsers] = useState&lt;string[]&gt;(defaultUsers);
    const [userLength, setUserLength] = useState(() =&gt; hardComputingFunction(defaultUsers));

    function userInsert(name : string){
        setUsers((prevState) =&gt; [...prevState,name])
        setUserLength(users.length + 1);
        setUserLength(users.length + 1);
        setUserLength(users.length + 1);
    }

    return (
        &lt;div&gt;
            &lt;div&gt;
                &lt;input type='text' onChange={(e) =&gt; setName(e.target.value)}/&gt;
                &lt;button onClick={() =&gt; userInsert(name)}&gt;
                    Insert
                &lt;/button&gt;
                Now : {userLength}
            &lt;/div&gt;
            {users.map((v,i) =&gt; {
                return &lt;div key={i}&gt;{v}&lt;/div&gt;
            })}
        &lt;/div&gt;
    )
}</code></pre>

<p data-ke-size="size16">이 결과는 변경되기전 <code>users</code>의 업데이트 전 길이와 1을 더한 값이 setUsersLength로 업데이트 된다. 그 이유는 위에서도 언급 하였듯이 함수형 컴포넌트는 <code>함수</code> 일 뿐이며, 값이 변경되어 렌더링 된다는 의미는 <b>다시 한번 이 함수형 컴포넌트를 호출 한다는 의미이다.</b> 그렇기에 setUsers로 변경한 값은 현재 userInsert 함수 스코프내의 <code>users</code> 에 반영되지 않는 것이다.</p>

<p data-ke-size="size16">만약 위 목적처럼 새로운 users의 길이에 3을 연속적으로 setUserLength로 구현하기 위해서는 다음과 같이 코드를 작성하면 된다.</p>
<pre><code>
export default function App() {

    const [name, setName] = useState("");
    const [users,setUsers] = useState&lt;string[]&gt;(defaultUsers);
    const [userLength, setUserLength] = useState(() =&gt; hardComputingFunction(defaultUsers));

    function userInsert(name : string){
        setUsers((prevState) =&gt; [...prevState,name])
        setUserLength((prevState) =&gt; prevState + 1);
        setUserLength((prevState) =&gt; prevState + 1);
        setUserLength((prevState) =&gt; prevState + 1);
    }

    return (
       ...
    )
}</code></pre>

<figure data-ke-mobilestyle="widthOrigin" data-origin-width="816" data-origin-height="132">
    <span data-url="https://blog.kakaocdn.net/dn/SDJVq/btr5gvPZ5Wc/LjCIuheIA3msTUx8qahuK0/img.gif" data-lightbox="lightbox">
        <img src="https://blog.kakaocdn.net/dn/SDJVq/btr5gvPZ5Wc/LjCIuheIA3msTUx8qahuK0/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="816" data-origin-height="132">
    </span>
    
</figure>


<p data-ke-size="size16"><code>setState</code> 함수 내부는 비 동기적으로 작동한다. 이유는 setState 함수를 실행한뒤에 다시 렌더링 하는 함수를 호출 하기 위해 최초 상태 변화가 감지된 다음 <code>16ms</code> 동안 상태 변화를 모두 모아 렌더링 하기 때문이다. (이를 배칭이라 한다.) 그렇기 때문에, 위의 “userInsert” 함수가 모두 끝났을 때 한번만 렌더링 되는 것이다.</p>
            
            
                </div></div>

자스민

컴포넌트내에서의 상태 갱신
React를 접하는 이들이 가장 먼저 사용해보는 컴포넌트의 상태를 관리하는 Hook이다. 아래의 간단한 코드를 보자. 아래의 예제는 두개의 버튼을 두어, numb라는 값을 1씩 증가시키거나, 감소시킨다.
import React from 'react'
export default function App() {
    let numb = 0;
    return (
        <div>
            <div className='numb'>
                {numb}
            </div>
            <div className='buttons'>
            <button onClick={() => {
                numb += 1
                console.log(numb)
            }}>
                Increase
            </button>
            <button onClick={() => {
                numb -= 1
                console.log(numb)
            }}>
                Decrease
            </button>
            </div>
        </div>
    )
}
아래는 결과이다. 우리는 화면에 numb가 버튼의 클릭에 따라 갱신되기를 기대했지만, 화면에 갱신은 되지 않지만, 값은 실제로 변하고 있다.
 
함수형 컴포넌트에서 돔(화면)을 업데이트하는 것은 [“newProps”, “useState”,”useReducer”,”useContext”] 를 이용하는 것이다. 즉 컴포넌트내부에서 아무리 변수를 변경하여도, 위의 4가지 방법을 이용하지 않고는 컴포넌트가 다시 렌더링 되지 않는다.
 
함수형 컴포넌트도 결국에는 함수이다. 한번 돔을 리턴 한 함수는 다시 한번 호출하지 않으면, 돔을 새롭게 변경 할 수 없다. 그렇기에 다시 한번 함수형 컴포넌트를 호출 할 수 있는 방법을 사용해서, 새롭게 렌더링해야한다.
useState 사용해보기
import React,{useState} from 'react'
export default function App() {
    const [numb, setNumb] = useState(0);
        return (...)
}
useState는 react 라이브러리에서 가져와 사용 할 수 있다. **useState는 파라메터로 기본 값을 전달하고, 현재 상태의 값과 이 상태를 업데이트 할 수 있는 set 함수를 담은 배열을 반환한다. 보통 이 반환된 값과 함수의 명명 규칙은 [상태, set상태] 의 형태를 취한다.
리턴되는 값이 배열(튜플)이기에 아래와 같이 사용 할 수 있지만, 배열 구조 할당을 이용해서, 훨씬 가독성이 좋은 코드를 쓸 수 있기 때문에, 사용하지는 않는다.
import React,{useState} from 'react'
export default function App() {
    const numbState = useState(0);
    return (
        <div>
            <div className='numb'>
                {numbState[0]}
            </div>
            ...
            )
}
반환된 상태값과 업데이트 함수를 사용하여, 아래와 같이 예제를 완성 할 수 있다.
import React,{useState} from 'react'
export default function App() {
    const [numb, setNumb] = useState(0);
    return (
        <div>
            <div className='numb'>
                {numb}
            </div>
            <div className='buttons'>
            <button onClick={() => {
                setNumb(numb + 1)
            }}>
                Increase
            </button>
            <button onClick={() => {
                setNumb(numb - 1)
            }}>
                Decrease
            </button>
            </div>
        </div>
    )
}
 
useStatus로 배열다루기
useState로 배열을 다루는 것도 동일하다. 버튼을 클릭하여, 인풋에 전달된 값을 리스트로 표현해보자.
import React,{useState} from 'react'
export default function App() {
    const [name, setName] = useState("");
    const [users,setUsers] = useState<string[]>(["Lee", "Kim"]);
    function userInsert(name : string){
        setUsers([...users,name])
    }
    return (
        <div>
            <div>
                <input type='text' onChange={(e) => setName(e.target.value)}/>
                <button onClick={() => userInsert(name)}>
                    Insert
                </button>
            </div>
            {users.map((v) => {
                return <div>{v}</div>
            })}
        </div>
    )
}
setState함수를 조금 더 함수형 프로그래밍에 맞게 작성해보자.
현재 배열을 다루기 위해, userInsert 함수는 파라매터로 새로운 name을 받지만 setUsers에서 이전 배열을 다루기위해서, 함수 외부에서 users를 불러와 이전 내용을 새로운 배열에 입력한다. 이처럼 함수내부에서 외부의 지역변수를 참조하는 것을 클로저라고 한다.
클로저를 이용해 이전 값을 활용하는 것은 문제가 되지 않으나, 내부함수가 어딘가에서 계속 유지되고 있다면 이전 값은 스코프가 유지되어 메모리 해제가 발생하지 않을 수 있다. (물론 코드를 깔끔하게 유지하고 이를 신경쓴다면 문제 되지 않을 수 있다.)
아래의 코드는 useState와 setState함수의 타입이다.
 
    function useState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
    // Unlike the class component setState, the updates are not allowed to be partial
    type SetStateAction<S> = S | ((prevState: S) => S);
    // this technically does accept a second argument, but it's already under a deprecation warning
    // and it's not even released so probably better to not define it.
    type Dispatch<A> = (value: A) => void;
    // Since action _can_ be undefined, dispatch may be called without any parameters.
 
위의 dispatch함수를 보면, 2가지의 활용 방법이 존재한다. 하나는 값을 바로 집어넣어 상태를 업데이트 하는 것이고 다른 한가지는 콜백함수를 이용해서, 이전 값을 파라메터로 받는 콜백함수를 전달 하는 것이다.
콜백 함수를 이용해 이전 값에 접근하도록 함수를 변경해보자.
 
import React,{useState} from 'react'
export default function App() {
    const [name, setName] = useState("");
    const [users,setUsers] = useState<string[]>(["Lee", "Kim"]);
    function userInsert(name : string){
        setUsers((prevState) => [...prevState,name])
    }
    return (
        <div>
            <div>
                <input type='text' onChange={(e) => setName(e.target.value)}/>
                <button onClick={() => userInsert(name)}>
                    Insert
                </button>
            </div>
            {users.map((v) => {
                return <div>{v}</div>
            })}
        </div>
    )
}
이처럼 상태를 변경하기 위해 이전 값에 접근 하는 경우가 존재한다면, 콜백함수를 이용하도록 하자.
초기 상태값 다루기
함수형 컴포넌트는 파라메터를 이용하여, 리액트 엘리먼트를 반환하는 순수 함수이기 때문에, 상태변화나 프롭스가 변경되어 리렌더링 된다는 의미는 함수를 다시 호출 한다는 의미이다.
배열의 길이를 계산하는 함수를 O(n)으로 설정하고 이를 최초 초기값으로 넣어 보자.
import React,{useState} from 'react'
function hardComputingFunction(arr : any[]){
    // O(n)의 시간이 걸리는 작업.
    console.log("Hard Computeing start")
    let count = 0;
    for(const _ of arr) count +=1;
    return count
}
const defaultUsers = ["Lee", "Kim"];
export default function App() {
    const [name, setName] = useState("");
    const [users,setUsers] = useState<string[]>(defaultUsers);
    const [userLength, setUserLength] = useState(hardComputingFunction(defaultUsers));
    function userInsert(name : string){
        setUsers((prevState) => [...prevState,name])
        setUserLength((prevState) => prevState + 1);
    }
    return (
        <div>
            <div>
                <input type='text' onChange={(e) => setName(e.target.value)}/>
                <button onClick={() => userInsert(name)}>
                    Insert
                </button>
                Now : {userLength}
            </div>
            {users.map((v) => {
                return <div>{v}</div>
            })}
        </div>
    )
}
 
상태가 변경될 때 마다 계속해서, 초기값으로 전달했던 함수가 실행되는 것을 볼 수 있다. 이는 위에서 언급 하였듯이, 렌더링되는 과정에서 함수 컴포넌트를 호출 하고 함수내에 존재하는 모든 구문이 다시 시작되기 때문에 발생하는 것이다.
 
위와 같은 문제를 해결하는 방법은 lazy initializtion을 사용하는 것이다. 뭔가 이름은 거창하지만 실제로는 적용하는데 어려움이 없다. lazy initializtion은 useState 초기값에 복잡한 연산을 포함할 때, 사용되는 것이며 오직 state를 처음 만들어 질때만 실행된다. 이를 사용한다면 다시 렌더링이 되어 초기값을 계산할 때, 함수를 호출하지 않는다.
 
이를 구현하는 방법은 함수의 값을 전달하는 것이아니라, 콜백을 전달하여 리턴 값으로 해당 함수를 반환하도록 하는 방법이다.
 
아래는 “게으른 초기화”를 적용한 코드와 결과이다.
import React,{useState} from 'react'
function hardComputingFunction(arr : any[]){
    // O(n)의 시간이 걸리는 작업.
    console.log("Hard Computeing start")
    let count = 0;
    for(const _ of arr) count +=1;
    return count
}
const defaultUsers = ["Lee", "Kim"];
export default function App() {
    const [name, setName] = useState("");
    const [users,setUsers] = useState<string[]>(defaultUsers);
    const [userLength, setUserLength] = useState(() => hardComputingFunction(defaultUsers));
    function userInsert(name : string){
        setUsers((prevState) => [...prevState,name])
        setUserLength((prevState) => prevState + 1);
    }
    return (
        <div>
            <div>
                <input type='text' onChange={(e) => setName(e.target.value)}/>
                <button onClick={() => userInsert(name)}>
                    Insert
                </button>
                Now : {userLength}
            </div>
            {users.map((v,i) => {
                return <div key={i}>{v}</div>
            })}
        </div>
    )
}
lazy initialization을 적용 했을 때, 상태가 변경되어 컴포넌트가 계속 렌더링되어도 hardComputingFunction 는 실행되지 않는다.
 
잘못된 오해
이 포스트를 올리기위해, useState의 다양한 블로그 글들을 확인 하였는데 이상한 점이 많이 보였다. 바로 useState 비동기라는 제목으로 돌아다니는 포스트들인데, 대부분의 예시가 다음과 같다.아래는 userInsert 함수를 호출 한 뒤, “setUserLength” 함수에 users.length + 1 을 해서, 최신상태의 users의 길이에 1씩 연속적으로 더해 users.length + 3이 출력되게 끔 하는 목적의 코드이다.
export default function App() {
    const [name, setName] = useState("");
    const [users,setUsers] = useState<string[]>(defaultUsers);
    const [userLength, setUserLength] = useState(() => hardComputingFunction(defaultUsers));
    function userInsert(name : string){
        setUsers((prevState) => [...prevState,name])
        setUserLength(users.length + 1);
        setUserLength(users.length + 1);
        setUserLength(users.length + 1);
    }
    return (
        <div>
            <div>
                <input type='text' onChange={(e) => setName(e.target.value)}/>
                <button onClick={() => userInsert(name)}>
                    Insert
                </button>
                Now : {userLength}
            </div>
            {users.map((v,i) => {
                return <div key={i}>{v}</div>
            })}
        </div>
    )
}
 
이 결과는 변경되기전 users의 업데이트 전 길이와 1을 더한 값이 setUsersLength로 업데이트 된다. 그 이유는 위에서도 언급 하였듯이 함수형 컴포넌트는 함수 일 뿐이며, 값이 변경되어 렌더링 된다는 의미는 다시 한번 이 함수형 컴포넌트를 호출 한다는 의미이다. 그렇기에 setUsers로 변경한 값은 현재 userInsert 함수 스코프내의 users 에 반영되지 않는 것이다.
 
만약 위 목적처럼 새로운 users의 길이에 3을 연속적으로 setUserLength로 구현하기 위해서는 다음과 같이 코드를 작성하면 된다.
export default function App() {
    const [name, setName] = useState("");
    const [users,setUsers] = useState<string[]>(defaultUsers);
    const [userLength, setUserLength] = useState(() => hardComputingFunction(defaultUsers));
    function userInsert(name : string){
        setUsers((prevState) => [...prevState,name])
        setUserLength((prevState) => prevState + 1);
        setUserLength((prevState) => prevState + 1);
        setUserLength((prevState) => prevState + 1);
    }
    return (
       ...
    )
}
 
 
 
setState 함수 내부는 비 동기적으로 작동한다. 이유는 setState 함수를 실행한뒤에 다시 렌더링 하는 함수를 호출 하기 위해 최초 상태 변화가 감지된 다음 16ms 동안 상태 변화를 모두 모아 렌더링 하기 때문이다. (이를 배칭이라 한다.) 그렇기 때문에, 위의 “userInsert” 함수가 모두 끝났을 때 한번만 렌더링 되는 것이다.

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

댓글