<div id="readability-page-1" class="page"><div><h2>🌈 Hook의 개요</h2>
<blockquote>
<p>Hook가 React 버전 16.8에 새롭게 추가되었다. Hook를 이용하여 Class를 작성할 필요 없이 상태 값과 여러 React의 기능을 사용할 수 있다.</p>
</blockquote>
<h4>🔸 Hook를 만들게 된 동기</h4>
<blockquote>
<ol>
<li>컴포넌트 사이에서 상태와 관련된 로직을 재사용하기 어렵다.</li>
<li>복잡한 컴포넌트들은 이해하기 어렵다.</li>
<li>Class은 사람과 기계를 혼동시킨다.</li>
</ol>
</blockquote>
<ul>
<li>📌 <a href="https://ko.reactjs.org/docs/hooks-intro.html">자세한 내용 참조</a></li>
</ul>
<h2>🌈 Hook의 규칙</h2>
<blockquote>
<p>Hook을 사용할 때는 두 가지 규칙을 준수해야 한다.<br>이러한 규칙을 자동으로 지켜주는 <a href="https://www.npmjs.com/package/eslint-plugin-react-hooks">linter 플러그인</a>이 있다.<br>위 ESLint 플러그인은 create react app에 기본적으로 포함하고 있다.</p>
</blockquote>
<ol>
<li><b>1. 최상위에서만 Hook을 호출해야 한다.</b><br>반복문, 조건문 혹은 중첩된 함수 내에서 Hook을 호출하지 않는다.</li>
<li><b>2. 오직 React 함수 내에서 Hook을 호출해야 한다.</b><br>Hook을 일반적인 javascript 함수에서 호출하지 말아야 한다.</li>
</ol>
<h2>🌈 useState</h2>
<ul>
<li>
<p>가장 기본적인 Hook로 함수형 컴포넌트에서 가변적인 상태를 지닐 수 있게 해 준다.</p>
</li>
<li>
<p><code>useState</code> 함수의 파라미터에는 상태의 기본값을 넣어주는 것으로 초기 렌더링 시에 사용하는 값이다.</p>
</li>
<li>
<p>그 이후의 렌더링 시에는 이 값은 무시된다.</p>
<pre><code>const [value,setValue] = useState(0);</code></pre>
</li>
<li>
<p><code>useState</code> 함수는 호출되면 배열을 반환하는데 배열의 첫 번째 원소는 상태 값, 두 번째 원소는 상태를 설정하는 함수이다.</p>
</li>
<li>
<p><code>setValue</code> 함수는 <code>value</code>를 갱신할 때 사용한다.</p>
<pre><code>setValue(newValue);</code></pre>
</li>
<li>
<p>클래스 컴포넌트</p>
<pre><code>   class Example extends React.Component {
      constructor(props) {
        super(props);
        this.state = {
          value: 0
        };
      }
      render() {
        return (
          &lt;div&gt;
            &lt;p&gt; 카운터 값 {this.state.value} 입니다. &lt;/p&gt;
            &lt;button onClick={() =&gt; this.setState({ count: this.state.value + 1 })}&gt;+1&lt;/button&gt;
            &lt;button onClick={() =&gt; this.setState({ count: this.state.value - 1 })}&gt;-1&lt;/button&gt;
          &lt;/div&gt;
        );
      }
    }</code></pre>
</li>
<li>
<p>함수형 컴포넌트</p>
<pre><code>  const Counter = () =&gt; {
    const [value,setValue] = useState(0);

    return(
        &lt;div&gt;
            &lt;p&gt; 카운터 값은 &lt;b&gt;{value}&lt;/b&gt;입니다. &lt;/p&gt;
            &lt;button onClick={() =&gt; setValue(value+1)}&gt;+1&lt;/button&gt;
            &lt;button onClick={() =&gt; setValue(value-1)}&gt;-1&lt;/button&gt;
        &lt;/div&gt;
    )</code></pre>
</li>
<li>
<p>🔸 state 갱신의 취소<br>State Hook을 현재의 state와 동일한 값으로 갱신하는 경우 React는 자식을 렌더링 한다거나 무엇을 실행하는 것을 회피하고 그 처리를 종료한다.(React는 <a href="https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Object/is#Description">Object.is 비교 알고리즘</a>을 사용한다.)</p>
</li>
</ul>
<figure id="og_1592911008155" contenteditable="false" data-ke-type="opengraph" data-og-type="website" data-og-title="Object.is()" data-og-description="Object.is() 메서드는 두 값이 같은 값인지 결정합니다." data-og-host="developer.mozilla.org" data-og-source-url="https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Object/is#Description" data-og-url="https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Object/is" data-og-image="https://scrap.kakaocdn.net/dn/cMN4zO/hyGvzHVSpE/WvHjKKEyyTxtEzkzwKfzYK/img.png?width=600&amp;height=600&amp;face=0_0_600_600,https://scrap.kakaocdn.net/dn/cfvwDi/hyGvtVfjE0/xvVEsvCyiwZsSsakKKMOJ1/img.png?width=600&amp;height=600&amp;face=0_0_600_600"><a href="https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Object/is#Description" target="_blank" rel="noopener" data-source-url="https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Object/is#Description">

<div>
<p>Object.is()</p>
<p>Object.is() 메서드는 두 값이 같은 값인지 결정합니다.</p>
<p>developer.mozilla.org</p>
</div>
</a><img src="https://scrap.kakaocdn.net/dn/cMN4zO/hyGvzHVSpE/WvHjKKEyyTxtEzkzwKfzYK/img.png?width=600&amp;height=600&amp;face=0_0_600_600,https://scrap.kakaocdn.net/dn/cfvwDi/hyGvtVfjE0/xvVEsvCyiwZsSsakKKMOJ1/img.png?width=600&amp;height=600&amp;face=0_0_600_600"></figure>
<h2>🌈 useEffect</h2>
<ul>
<li>
<p><code>useEffect</code>에 전달된 함수는 화면에 렌더링이 완료된 후에 수행되게 된다.</p>
</li>
<li>
<p>리액트 컴포넌트가 렌더링 될 때마다 특정 작업을 수행하도록 설정할 수 있는 Hook이다.</p>
</li>
<li>
<p>클래스형 컴포넌트의 <code>componentDidMount</code>와 <code>componentDidUpdate</code>를 합친 형태랑 같다.</p>
</li>
<li>
<p><code>useEffect()</code>는 값이 업데이트될 때마다 실행되는데 화면에 맨 처음 렌더링 될 때만 실행하고, 업데이트될 때는 실행되지 않게 하려면 함수의 <b>두 번째 파라미터로 비어 있는 배열을 넣어 주면 된다.</b></p>
</li>
<li>
<p>이 배열은 effect가 종속되어 있는 값의 배열이지만, 빈 배열 시에 어떤 값에도 의존하지 않으므로, 다시 실행할 필요가 전혀 없어진다.</p>
<pre><code>  useEffect(() =&gt; {
      console.log({ name, nickName })
  },[])</code></pre>
</li>
<li>
<p>특정 값이 업데이트될 때만 실행하고 싶으면 <b>두 번째 파리미터로 전달되는 배열 안에 검사하고 싶은 값을 넣어 주면 된다.</b></p>
<pre><code>useEffect(() =&gt; {
console.log(name);
},[name])</code></pre>
</li>
</ul>
<h3>🔸 effect 정리</h3>
<ul>
<li>
<p>컴포넌트가 언마운트되기 전이나 업데이트되기 직전에 어떤 작업을 수행하고 싶다면 <code>useEffect</code>에서 정리(clean-up) 함수를 반환해 주어야 한다.</p>
</li>
<li>
<p>정리 함수는 메모리 누수 방지를 위해 UI에서 컴포넌트를 제거하기 전에 수행된다.</p>
</li>
<li>
<p>만약 컴포넌트가 여러 번 렌더링 된다면 다음 effect가 수행되기 전에 이전 effect는 정리된다.</p>
<pre><code>  useEffect(() =&gt; {
      console.log("effect");
      console.log({
          name, nickName
      })
      return () =&gt;{
          console.log('cleanUp');
          console.log(name);
      }
  },[])</code></pre>
</li>
<li>
<p>정리 함수가 호출될 때는 <b>업데이트되기 직전 값을 보여준다.</b></p>
</li>
</ul>
<h2>🌈 useContext</h2>
<ul>
<li>
<p>📌 <a href="https://ko.reactjs.org/docs/context.html">React context 참고</a></p>
<pre><code>const value = useContext(MyContext);</code></pre>
</li>
<li>
<p>context 객체(React.createContext에서 반환된 값)를 받아 그 context의 현재 값을 반환한다.</p>
</li>
<li>
<p>컴포넌트에서 가장 가까운 <code>&lt;MyContext.Provider&gt;</code>가 갱신되면 이 Hook은 그 MyContext.Provider에게 전달된 가장 최신의 context value를 사용하여 렌더러를 트리거한다.</p>
</li>
<li>
<p><code>useContext</code>로 전달된 인자는 <b>context 객체 그 자체이어야 한다.</b></p>
</li>
<li>
<p><code>useContext</code>를 호출한 컴포넌트는 <b>context 값이 변경되면 항상 리렌더링 된다.</b> 만약 <a href="https://github.com/facebook/react/issues/15156#issuecomment-474590693">컴포넌트를 리렌더링 하는 것에 복잡해진다면, 메모이제이션을 사용하여 최적화할 수 있다.</a></p>
<pre><code>  const themes = {
    light: {
      foreground: "#000000",
      background: "#eeeeee"
    },
    dark: {
      foreground: "#ffffff",
      background: "#222222"
    }
  };

  const ThemeContext = React.createContext(themes.light);

  function App() {
    return (
    // Provider로 prop을 받아서 이 값을 하위에 있는 컴포넌트에게 전달한다. (context의 변화를 알린다.)
      &lt;ThemeContext.Provider value={themes.dark}&gt;
        &lt;Toolbar /&gt;
      &lt;/ThemeContext.Provider&gt;
    );
  }
  function Toolbar(props) {
    return (
      &lt;div&gt;
        &lt;ThemedButton /&gt;
      &lt;/div&gt;
    );
  }
  function ThemedButton() {
    const theme = useContext(ThemeContext);
    return (
      &lt;button style={{ background: theme.background, color: theme.foreground }}&gt;test&lt;/button&gt;
    );
  }</code></pre>
</li>
</ul>
<h2>🌈 useReducer</h2>
<pre><code>const [state, dispatch] = useReducer(reducer, initialArg, init);</code></pre>
<ul>
<li>
<p><code>useState</code>의 대체 함수로 (state, action) =&gt; newState의 형태로 <b>reducer를 받고 dispatch 메서드와 짝의 형태로 현재 state를 반환한다.</b></p>
</li>
<li>
<p>리듀서는 현재 상태, 그리고 업데이트를 위해 필요한 정보를 담은 액션 값을 전달받아 새로운 상태를 반환하는 함수이다.</p>
</li>
<li>
<p>리듀서 함수에서 새로운 상태를 만들 때는 <b>불변성을 지켜야 한다.</b></p>
</li>
<li>
<p>useReducer는 콜백 대신 <b><code>dispatch</code>를 전달할 수 있기 때문에</b> 업데이트를 하는 컴포넌트의 성능을 최적화할 수 있다.</p>
<pre><code>  const initialState = {value : 0};
  function reducer(state,action){
    switch (action.type){
        case 'INCREMENT':
            return {value : state.value + 1};
        case 'DECREMENT':
            return {value : state.value - 1};
        default :
        //아무것도 해당되지 않을 때 기존 상태 반환
            return state;
    }
  }
  const Counter = () =&gt; {
      // useReducer(리듀서 함수, 초기값)
    const [state, dispatch] = useReducer(reducer,initialState);
    return (
        &lt;div&gt;
            &lt;p&gt;
                현재 카운터 값은 &lt;b&gt;{state.value}&lt;/b&gt;입니다.
            &lt;/p&gt;
            &lt;button onClick={() =&gt; dispatch({type : 'INCREMENT'})}&gt;+1&lt;/button&gt;
            &lt;button onClick={() =&gt; dispatch({type : 'DECREMENT'})}&gt;-1&lt;/button&gt;

        &lt;/div&gt;
    );
  };</code></pre>
</li>
<li>
<p><code>state</code>값과 <code>dispatch</code> 함수를 받아오는데 <code>state</code>는 현재 가리키고 있는 상태이고, <code>dispatch</code>는 액션을 발생 키기는 함수이다.</p>
</li>
<li>
<p><code>useReducer</code>를 사용했을 때 가장 큰 장점은 <b>컴포넌트 업데이트 로직을 컴포넌트 바깥으로 빼낼 수 있다는 점이다.</b></p>
</li>
</ul>
<h3>🔸 초기화 지연</h3>
<ul>
<li>
<p>초기화 state를 지연시켜서 생성할 수 있다.</p>
</li>
<li>
<p>useReducer(리듀서 함수, 초기값, init 함수) 세 번째 인자로 전달한다.</p>
</li>
<li>
<p>예를 들어 버튼 클릭 시에 state를 재설정시킨다.</p>
<pre><code>function init(initialCount) {
return {count: initialCount};
}

function reducer(state, action) {
switch (action.type) {
  case 'INCREMENT':
    return {count: state.count + 1};
  case 'DECREMENT':
    return {count: state.count - 1};
  case 'reset':
    return init(action.payload);
  default:
       state;
}
}

function Counter({initialCount}) {
const [state, dispatch] = useReducer(reducer, initialCount, init);
return (
  &lt;&gt;
    Count: {state.count}
    &lt;button
      onClick={() =&gt; dispatch({type: 'reset', payload: initialCount})}&gt;
      Reset
    &lt;/button&gt;
    &lt;button onClick={() =&gt; dispatch({type: 'DECREMENT'})}&gt;-&lt;/button&gt;
    &lt;button onClick={() =&gt; dispatch({type: 'INCREMENT'})}&gt;+&lt;/button&gt;
  &lt;/&gt;
);
}</code></pre>
</li>
</ul>
<h2>🌈 useMemo</h2>
<ul>
<li>
<p><code>useMemo</code>를 사용하면 함수형 컴포넌트 내부에서 발생하는 연산을 최적화할 수 있다.</p>
</li>
<li>
<p><a href="https://ko.wikipedia.org/wiki/%EB%A9%94%EB%AA%A8%EC%9D%B4%EC%A0%9C%EC%9D%B4%EC%85%98">메모이제이션</a>된 값을 반환한다.</p>
</li>
<li>
<p>렌더링 하는 과정에서 <b>특정 값이 바뀌었을 때만 연산을 실행</b>하고, 원하는 값이 바뀌지 않았다면 이전에 연산했던 결과를 다시 사용하는 방식이다.</p>
</li>
<li>
<p>useMemo로 전달된 함수는 <b>렌더링 중</b>에 실행된다. 때문에 렌더링 중에 실행되지 않는 것은 사용하면 안 된다.</p>
<pre><code>  const getAverage = numbers =&gt; {
      console.log("평균값 계산");
      if(numbers.length === 0)return 0;
      const sum = numbers.reduce((a,b) =&gt; a+b);
      return sum / numbers.length;
  }
  // 생략..
  const avg = useMemo(() =&gt; getAverage(list), [list]); // list 값이 변경될때만 실행
  // 생략..</code></pre>
</li>
</ul>
<h2>🌈 useCallback</h2>
<ul>
<li>
<p><code>useMemo</code>와 비슷하고 렌더링 성능을 최적화해야 하는 상황에서 사용된다.</p>
</li>
<li>
<p><a href="https://ko.wikipedia.org/wiki/%EB%A9%94%EB%AA%A8%EC%9D%B4%EC%A0%9C%EC%9D%B4%EC%85%98">메모이제이션</a>된 콜백을 반환한다.</p>
</li>
<li>
<p>이벤트 핸들러 함수를 필요할 때만 생성할 수 있다.</p>
</li>
<li>
<p>useCallback(fn, deps)은 useMemo(() =&gt; fn, deps)와 같다.</p>
<pre><code> const onChange = useCallback(e =&gt; {
   setNumber(e.target.value);
 },[]); //처음 랜더링될 때만 함수 생성
 const onInsert = useCallback(e =&gt; {
   const nextList = list.concat(parseInt(number));
   setList(nextList);
   setNumber('');
 },[number,list]); //number, list 가 바뀌었을 떄만 함수 생성</code></pre>
</li>
<li>
<p><code>useCallback</code>의 첫 번째 파라미터에는 생성하고 싶은 함수를 넣고, 두 번째 파라미터에는 어떤 값이 바뀌었을 때 함수를 새로 생성해야 하는지를 명시하는 배열을 넣는다.</p>
</li>
<li>
<p>빈 배열을 넣게 되면 컴포넌트가 렌더링 될 때 단 한 번만 함수가 생성되고, 배열 안에 값을 넣게 되면 내용일 바뀌거나 새로운 항목이 추가될 때마다 함수가 생성된다.</p>
</li>
</ul>
<h2>🌈 useRef</h2>
<ul>
<li>
<p>함수형 컴포넌트에서 <code>ref</code>를 쉽게 사용할 수 있도록 해준다.</p>
<pre><code>function TextInputWithFocusButton() {
  const inputEl = useRef(null); //ref 값 기본값 설정
  const onButtonClick = () =&gt; {
    inputEl.current.focus(); // 등록버튼 누른뒤 input 태그 focus
  };
  return (
    &lt;&gt;
      &lt;input ref={inputEl} type="text" /&gt;
      &lt;button onClick={onButtonClick}&gt;클릭&lt;/button&gt;
    &lt;/&gt;
  );
}</code></pre>
</li>
<li>
<p><code>useRef</code>를 사용하여 <code>ref</code>를 설정하면 <code>useRef</code>를 통해 만든 객체 안의 <code>current</code> 값이 실제 엘리먼트를 가리킨다.</p>
</li>
<li>
<p><code>ref</code> 안의 값이 바뀌어도 컴포넌트가 <b>렌더링 되지 않는다.</b>(렌더링과 관련되지 않은 값을 관리할 때만 사용)</p>
</li>
</ul>
<h2>🌈 useImperativeHandle</h2>
<pre><code>useImperativeHandle(ref, createHandle, [deps])</code></pre>
<ul>
<li>useImperativeHandle은 ref를 사용할 때 부모 컴포넌트에 노출되는 인스턴스 값을 사용자 화한다.</li>
<li>useImperativeHandle는 forwardRef와 같이 사용한다.
<pre><code>function FancyInput(props, ref) {
  const inputRef = useRef();
  useImperativeHandle(ref, () =&gt; ({
    focus: () =&gt; {
      inputRef.current.focus();
    }
  }));
  return &lt;input ref={inputRef} ... /&gt;;
}
FancyInput = forwardRef(FancyInput);</code></pre>
</li>
<li><code>&lt;FancyInput ref={inputRef} /&gt;</code>를 렌더링 한 부모 컴포넌트는 <code>inputRef.current.focus();</code>를 호출할 수 있다.</li>
</ul>
<h2>🌈 useLayoutEffect</h2>
<ul>
<li>이 함수는 모든 DOM 변경 후에 동기적으로 발생하고 DOM에서 레이아웃을 읽고 동기적으로 리렌더링하는 경우에 사용한다.</li>
<li>useLayoutEffect의 내부에 예정된 갱신은 브라우저가 <b>화면을 그리기 이전 시점</b>에 동기적으로 수행된다.</li>
<li>useLayoutEffect는 componentDidMount나 componentDidUpdate와 동일한 단계를 실행하긴 하지만 먼저 useEffect를 사용하고 문제가 있으면 useLayoutEffect을 사용해본다.</li>
</ul>
<h2>🌈 useDebugValue</h2>
<ul>
<li>
<p>useDebugValue는 React 개발자 도구에서 사용자 Hook 레이블을 표시하는 데에 사용할 수 있다.</p>
<pre><code>  function useFriendStatus(friendID) {
    const [isOnline, setIsOnline] = useState(null);
    useDebugValue(isOnline ? 'Online' : 'Offline');

    return isOnline;
  }</code></pre>
</li>
</ul>

<ul>
<li>📌 참고 링크 : <a href="https://ko.reactjs.org/docs/hooks-reference.html">React-Hooks 공식 문서</a></li>
<li>다른 개발자가 만든 Hooks도 라이브러리로 설치하여 사용할 수 있다.</li>
<li>📌 참고 링크 : <a href="https://nikgraf.github.io/react-hooks">https://nikgraf.github.io/react-hooks</a></li>
<li>📌 참고 링크 : <a href="https://github.com/rehooks/awesome-react-hooks">https://github.com/rehooks/awesome-react-hooks</a></li>
</ul>
<figure id="og_1592911040715" contenteditable="false" data-ke-type="opengraph" data-og-type="website" data-og-title="Hooks API Reference – React" data-og-description="A JavaScript library for building user interfaces" data-og-host="ko.reactjs.org" data-og-source-url="https://ko.reactjs.org/docs/hooks-reference.html" data-og-url="https://ko.reactjs.org/docs/hooks-reference.html" data-og-image="https://scrap.kakaocdn.net/dn/cOqhjt/hyGxbFrkLP/xv1VZtl3UJaJsxpryTgidk/img.png?width=1200&amp;height=630&amp;face=0_0_1200_630"><a href="https://ko.reactjs.org/docs/hooks-reference.html" target="_blank" rel="noopener" data-source-url="https://ko.reactjs.org/docs/hooks-reference.html">

<div>
<p>Hooks API Reference – React</p>
<p>A JavaScript library for building user interfaces</p>
<p>ko.reactjs.org</p>
</div>
</a><img src="https://scrap.kakaocdn.net/dn/cOqhjt/hyGxbFrkLP/xv1VZtl3UJaJsxpryTgidk/img.png?width=1200&amp;height=630&amp;face=0_0_1200_630"></figure>

</div></div>

SaDevelog

Harang

Hook의 개요
Hook가 React 버전 16.8에 새롭게 추가되었다. Hook를 이용하여 Class를 작성할 필요 없이 상태 값과 여러 React의 기능을 사용할 수 있다.
  Hook를 만들게 된 동기
컴포넌트 사이에서 상태와 관련된 로직을 재사용하기 어렵다.
복잡한 컴포넌트들은 이해하기 어렵다.
Class은 사람과 기계를 혼동시킨다.
  자세한 내용 참조
  Hook의 규칙
Hook을 사용할 때는 두 가지 규칙을 준수해야 한다.
이러한 규칙을 자동으로 지켜주는 linter 플러그인이 있다.
위 ESLint 플러그인은 create react app에 기본적으로 포함하고 있다.
1. 최상위에서만 Hook을 호출해야 한다.
반복문, 조건문 혹은 중첩된 함수 내에서 Hook을 호출하지 않는다.
2. 오직 React 함수 내에서 Hook을 호출해야 한다.
Hook을 일반적인 javascript 함수에서 호출하지 말아야 한다.
  useState
가장 기본적인 Hook로 함수형 컴포넌트에서 가변적인 상태를 지닐 수 있게 해 준다.
useState 함수의 파라미터에는 상태의 기본값을 넣어주는 것으로 초기 렌더링 시에 사용하는 값이다.
그 이후의 렌더링 시에는 이 값은 무시된다.
const [value,setValue] = useState(0);
useState 함수는 호출되면 배열을 반환하는데 배열의 첫 번째 원소는 상태 값, 두 번째 원소는 상태를 설정하는 함수이다.
setValue 함수는 value를 갱신할 때 사용한다.
setValue(newValue);
클래스 컴포넌트
   class Example extends React.Component {
      constructor(props) {
        super(props);
        this.state = {
          value: 0
        };
      }
      render() {
        return (
          <div>
            <p> 카운터 값 {this.state.value} 입니다. </p>
            <button onClick={() => this.setState({ count: this.state.value + 1 })}>+1</button>
            <button onClick={() => this.setState({ count: this.state.value - 1 })}>-1</button>
          </div>
        );
      }
    }
함수형 컴포넌트
  const Counter = () => {
    const [value,setValue] = useState(0);
    return(
        <div>
            <p> 카운터 값은 <b>{value}</b>입니다. </p>
            <button onClick={() => setValue(value+1)}>+1</button>
            <button onClick={() => setValue(value-1)}>-1</button>
        </div>
    )
  state 갱신의 취소
State Hook을 현재의 state와 동일한 값으로 갱신하는 경우 React는 자식을 렌더링 한다거나 무엇을 실행하는 것을 회피하고 그 처리를 종료한다.(React는 Object.is 비교 알고리즘을 사용한다.)
  useEffect
useEffect에 전달된 함수는 화면에 렌더링이 완료된 후에 수행되게 된다.
리액트 컴포넌트가 렌더링 될 때마다 특정 작업을 수행하도록 설정할 수 있는 Hook이다.
클래스형 컴포넌트의 componentDidMount와 componentDidUpdate를 합친 형태랑 같다.
useEffect()는 값이 업데이트될 때마다 실행되는데 화면에 맨 처음 렌더링 될 때만 실행하고, 업데이트될 때는 실행되지 않게 하려면 함수의 두 번째 파라미터로 비어 있는 배열을 넣어 주면 된다.
이 배열은 effect가 종속되어 있는 값의 배열이지만, 빈 배열 시에 어떤 값에도 의존하지 않으므로, 다시 실행할 필요가 전혀 없어진다.
  useEffect(() => {
      console.log({ name, nickName })
  },[])
특정 값이 업데이트될 때만 실행하고 싶으면 두 번째 파리미터로 전달되는 배열 안에 검사하고 싶은 값을 넣어 주면 된다.
useEffect(() => {
console.log(name);
},[name])
  effect 정리
컴포넌트가 언마운트되기 전이나 업데이트되기 직전에 어떤 작업을 수행하고 싶다면 useEffect에서 정리(clean-up) 함수를 반환해 주어야 한다.
정리 함수는 메모리 누수 방지를 위해 UI에서 컴포넌트를 제거하기 전에 수행된다.
만약 컴포넌트가 여러 번 렌더링 된다면 다음 effect가 수행되기 전에 이전 effect는 정리된다.
  useEffect(() => {
      console.log("effect");
      console.log({
          name, nickName
      })
      return () =>{
          console.log('cleanUp');
          console.log(name);
      }
  },[])
정리 함수가 호출될 때는 업데이트되기 직전 값을 보여준다.
  useContext
  React context 참고
const value = useContext(MyContext);
context 객체(React.createContext에서 반환된 값)를 받아 그 context의 현재 값을 반환한다.
컴포넌트에서 가장 가까운 <MyContext.Provider>가 갱신되면 이 Hook은 그 MyContext.Provider에게 전달된 가장 최신의 context value를 사용하여 렌더러를 트리거한다.
useContext로 전달된 인자는 context 객체 그 자체이어야 한다.
useContext를 호출한 컴포넌트는 context 값이 변경되면 항상 리렌더링 된다. 만약 컴포넌트를 리렌더링 하는 것에 복잡해진다면, 메모이제이션을 사용하여 최적화할 수 있다.
  const themes = {
    light: {
      foreground: "#000000",
      background: "#eeeeee"
    },
    dark: {
      foreground: "#ffffff",
      background: "#222222"
    }
  };
  const ThemeContext = React.createContext(themes.light);
  function App() {
    return (
    // Provider로 prop을 받아서 이 값을 하위에 있는 컴포넌트에게 전달한다. (context의 변화를 알린다.)
      <ThemeContext.Provider value={themes.dark}>
        <Toolbar />
      </ThemeContext.Provider>
    );
  }
  function Toolbar(props) {
    return (
      <div>
        <ThemedButton />
      </div>
    );
  }
  function ThemedButton() {
    const theme = useContext(ThemeContext);
    return (
      <button style={{ background: theme.background, color: theme.foreground }}>test</button>
    );
  }
  useReducer
const [state, dispatch] = useReducer(reducer, initialArg, init);
useState의 대체 함수로 (state, action) => newState의 형태로 reducer를 받고 dispatch 메서드와 짝의 형태로 현재 state를 반환한다.
리듀서는 현재 상태, 그리고 업데이트를 위해 필요한 정보를 담은 액션 값을 전달받아 새로운 상태를 반환하는 함수이다.
리듀서 함수에서 새로운 상태를 만들 때는 불변성을 지켜야 한다.
useReducer는 콜백 대신 dispatch를 전달할 수 있기 때문에 업데이트를 하는 컴포넌트의 성능을 최적화할 수 있다.
  const initialState = {value : 0};
  function reducer(state,action){
    switch (action.type){
        case 'INCREMENT':
            return {value : state.value + 1};
        case 'DECREMENT':
            return {value : state.value - 1};
        default :
        //아무것도 해당되지 않을 때 기존 상태 반환
            return state;
    }
  }
  const Counter = () => {
      // useReducer(리듀서 함수, 초기값)
    const [state, dispatch] = useReducer(reducer,initialState);
    return (
        <div>
            <p>
                현재 카운터 값은 <b>{state.value}</b>입니다.
            </p>
            <button onClick={() => dispatch({type : 'INCREMENT'})}>+1</button>
            <button onClick={() => dispatch({type : 'DECREMENT'})}>-1</button>
        </div>
    );
  };
state값과 dispatch 함수를 받아오는데 state는 현재 가리키고 있는 상태이고, dispatch는 액션을 발생 키기는 함수이다.
useReducer를 사용했을 때 가장 큰 장점은 컴포넌트 업데이트 로직을 컴포넌트 바깥으로 빼낼 수 있다는 점이다.
  초기화 지연
초기화 state를 지연시켜서 생성할 수 있다.
useReducer(리듀서 함수, 초기값, init 함수) 세 번째 인자로 전달한다.
예를 들어 버튼 클릭 시에 state를 재설정시킨다.
function init(initialCount) {
return {count: initialCount};
}
function reducer(state, action) {
switch (action.type) {
  case 'INCREMENT':
    return {count: state.count + 1};
  case 'DECREMENT':
    return {count: state.count - 1};
  case 'reset':
    return init(action.payload);
  default:
       state;
}
}
function Counter({initialCount}) {
const [state, dispatch] = useReducer(reducer, initialCount, init);
return (
  <>
    Count: {state.count}
    <button
      onClick={() => dispatch({type: 'reset', payload: initialCount})}>
      Reset
    </button>
    <button onClick={() => dispatch({type: 'DECREMENT'})}>-</button>
    <button onClick={() => dispatch({type: 'INCREMENT'})}>+</button>
  </>
);
}
  useMemo
useMemo를 사용하면 함수형 컴포넌트 내부에서 발생하는 연산을 최적화할 수 있다.
메모이제이션된 값을 반환한다.
렌더링 하는 과정에서 특정 값이 바뀌었을 때만 연산을 실행하고, 원하는 값이 바뀌지 않았다면 이전에 연산했던 결과를 다시 사용하는 방식이다.
useMemo로 전달된 함수는 렌더링 중에 실행된다. 때문에 렌더링 중에 실행되지 않는 것은 사용하면 안 된다.
  const getAverage = numbers => {
      console.log("평균값 계산");
      if(numbers.length === 0)return 0;
      const sum = numbers.reduce((a,b) => a+b);
      return sum / numbers.length;
  }
  // 생략..
  const avg = useMemo(() => getAverage(list), [list]); // list 값이 변경될때만 실행
  // 생략..
  useCallback
useMemo와 비슷하고 렌더링 성능을 최적화해야 하는 상황에서 사용된다.
메모이제이션된 콜백을 반환한다.
이벤트 핸들러 함수를 필요할 때만 생성할 수 있다.
useCallback(fn, deps)은 useMemo(() => fn, deps)와 같다.
 const onChange = useCallback(e => {
   setNumber(e.target.value);
 },[]); //처음 랜더링될 때만 함수 생성
 const onInsert = useCallback(e => {
   const nextList = list.concat(parseInt(number));
   setList(nextList);
   setNumber('');
 },[number,list]); //number, list 가 바뀌었을 떄만 함수 생성
useCallback의 첫 번째 파라미터에는 생성하고 싶은 함수를 넣고, 두 번째 파라미터에는 어떤 값이 바뀌었을 때 함수를 새로 생성해야 하는지를 명시하는 배열을 넣는다.
빈 배열을 넣게 되면 컴포넌트가 렌더링 될 때 단 한 번만 함수가 생성되고, 배열 안에 값을 넣게 되면 내용일 바뀌거나 새로운 항목이 추가될 때마다 함수가 생성된다.
  useRef
함수형 컴포넌트에서 ref를 쉽게 사용할 수 있도록 해준다.
function TextInputWithFocusButton() {
  const inputEl = useRef(null); //ref 값 기본값 설정
  const onButtonClick = () => {
    inputEl.current.focus(); // 등록버튼 누른뒤 input 태그 focus
  };
  return (
    <>
      <input ref={inputEl} type="text" />
      <button onClick={onButtonClick}>클릭</button>
    </>
  );
}
useRef를 사용하여 ref를 설정하면 useRef를 통해 만든 객체 안의 current 값이 실제 엘리먼트를 가리킨다.
ref 안의 값이 바뀌어도 컴포넌트가 렌더링 되지 않는다.(렌더링과 관련되지 않은 값을 관리할 때만 사용)
  useImperativeHandle
useImperativeHandle(ref, createHandle, [deps])
useImperativeHandle은 ref를 사용할 때 부모 컴포넌트에 노출되는 인스턴스 값을 사용자 화한다.
useImperativeHandle는 forwardRef와 같이 사용한다.
function FancyInput(props, ref) {
  const inputRef = useRef();
  useImperativeHandle(ref, () => ({
    focus: () => {
      inputRef.current.focus();
    }
  }));
  return <input ref={inputRef} ... />;
}
FancyInput = forwardRef(FancyInput);
<FancyInput ref={inputRef} />를 렌더링 한 부모 컴포넌트는 inputRef.current.focus();를 호출할 수 있다.
  useLayoutEffect
이 함수는 모든 DOM 변경 후에 동기적으로 발생하고 DOM에서 레이아웃을 읽고 동기적으로 리렌더링하는 경우에 사용한다.
useLayoutEffect의 내부에 예정된 갱신은 브라우저가 화면을 그리기 이전 시점에 동기적으로 수행된다.
useLayoutEffect는 componentDidMount나 componentDidUpdate와 동일한 단계를 실행하긴 하지만 먼저 useEffect를 사용하고 문제가 있으면 useLayoutEffect을 사용해본다.
  useDebugValue
useDebugValue는 React 개발자 도구에서 사용자 Hook 레이블을 표시하는 데에 사용할 수 있다.
  function useFriendStatus(friendID) {
    const [isOnline, setIsOnline] = useState(null);
    useDebugValue(isOnline ? 'Online' : 'Offline');
    return isOnline;
  }
  다른 Hooks
  참고 링크 : React-Hooks 공식 문서
다른 개발자가 만든 Hooks도 라이브러리로 설치하여 사용할 수 있다.
  참고 링크 : https://nikgraf.github.io/react-hooks
  참고 링크 : https://github.com/rehooks/awesome-react-hooks

[React] 함수형 컴포넌트의 React hooks

댓글