8장 Hooks

danbi lee·2022년 6월 8일

리액트

목록 보기

2/5

useState

가장 기본적인 Hook으로 함수 컴포넌트에서 상태 관리시 사용

const [value, setValue] = useState(0);

useSatae 함수의 파라미터에는 상태의 기본값을 넣어줌
함수가 호출되면 배열을 반환함
배열의 첫 번째 원소는 상태 값(value), 두 번째 원소는 상태를 설정하는 함수(setValue)

useState 여러 번 사용하기

하나의 useState 함수는 하나의 상태 값만 관리 할 수 있음
컴포넌트에서 관리해야 할 상태가 여러 개라면 useState를 여러 번 사용!

const Info = () => {
  const [name, setName] = useState('');
  const [nickname, setNickname] = useState('');
  
  ...
}

useEffect

리액트 컴포넌트가 렌더링될 때마다 특정 작업을 수행하도록 설정할 수 있는 Hook

import { useState, useEffect } from 'react';

const Info = () => {
  const [name, setName] = useState('');
  const [nickname, setNickname] = useState('');
  useEffect(() => {
    console.log('렌더링이 완료되었습니다');
    console.log({
      name,
      nickname
    });
  });

이렇게 하면 렌더링될 때마다 콘솔이 찍힘

마운트될 때만 실행하려면?

마운트: DOM 객체가 생성되고 브라우저에 나타나는 것

useEffect에서 설정한 함수를 컴포넌트가 화면에 맨 처음 렌더링될 때만 실행하고자 한다면 -> 함수의 두 번째 파라미터로 비어있는 배열을 넣으면 됨

useEffect(() => {
    console.log('마운트될 때만 실행합니다.');
    console.log({
      name,
      nickname
    });
  },[]);

특정 값이 업데이트될 때만 실행하려면?

특정 값이 변경될 때만 호출하고 싶다면 -> useEffect의 두 번째 파라미터로 전달되는 배열 안에 검사하고 싶은 값을 넣어주면 됨

useEffect(() => {
    console.log('마운트될 때만 실행합니다.');
    console.log({
      name,
      nickname
    });
  },[name]);

뒷정리

useEffect는 기본적으로 렌더링되고 난 직후마다 실행되며, 두 번째 파라미터 배열에 무엇을 넣는지에 따라 실행되는 조건이 달라짐
컴포넌트가 언마운트되기 전이나 업데이트되기 직전에 어떤 작업을 수행하려면 useEffect에서 뒷정리(cleanup) 함수를 반환해 주어야 함

언마운트: 컴포넌트를 DOM에서 제거하는 것
Clean-up함수: useEffect()에서 parameter로 넣은 함수의 return 함수

  useEffect(() => {
    console.log('effect');
    console.log(name);
    return () => {
      console.log('cleanup');
      console.log(name);
    };
  },[name]);

userReducer

리듀서는 현재 상태, 그리고 업데이트를 위해 필요한 정보를 담은 액션 값을 전달받아 새로운 상태를 반환하는 함수
새로운 상태를 만들 때는 반드시 불변성을 지켜야 함!

function reducer(state, action) {
	return { ... };
}
  
// 액션 값의 형태
{
	type: 'INCREMENT',  
}

카운터를 구현해보면

import { useReducer } from 'react';

function reducer(state, action) {
  // action.type에 따라 다른 작업 수행
  switch (action.type) {
    case 'INCREMENT':
      return { value: state.value + 1 };
    case 'DECREMENT':
      return { value: state.value - 1 };
    default:
      // 아무것도 해당되지 않을 때 기존 상태 반환
      return state;
  }
}

const Counter = () => {
  const [state, dispatch] = useReducer(reducer, { value: 0 });

  return(
    <div>
      <p>현재 카운터 값은 <b>{state.value}</b>입니다.</p>
      <button onClick={() => dispatch({ type: 'INCREMENT' })}>+1</button>
      <button onClick={() => dispatch({ type: 'DECREMENT' })}>-1</button>
    </div>
  );
};

useReducer의 첫 번째 파라미터엔 리듀서 함수를, 두 번째 파라미터엔 기본값을 넣음
이 Hook을 사용하면 state값과 dispatch 함수를 받아옴
- state는 현재 가리키고 있는 상태
- dispatch는 액션을 발생시키는 함수
- 함수 안에 파라미터로 액션 값을 넣어 주면 리듀서 함수가 호출되는 구조

장점

컴포넌트 업데이트 로직을 컴포넌트 바깥으로 빼낼 수 있음

인풋 상태 관리하기

import { useReducer } from 'react';

function reducer(state, action) {
  return {
    ...state,
    [action.name]: action.value
  };
}

const Info = () => {
  const [state, dispatch] = useReducer(reducer, {
    name: '',
    nickname: ''
  });
  const { name, nickname } = state;
  const onChange = e => {
    dispatch(e.target);
  }

  return(
    <div>
      <div>
        <input name='name' value={name} onChange={onChange}></input>
        <input name='nickname' value={nickname} onChange={onChange}></input>
      </div>
      <div>
        <div>
          <b>이름: </b> {name}
        </div>
        <div>
          <b>닉네임: </b> {nickname}
        </div>
      </div>
    </div>
  );
}

export default Info;

useMemo

컴포넌트 내부에서 발생하는 연산을 최적화 할 수 있음

import { useState } from 'react';

const getAverage = numbers => {
  console.log('평균값 계산 중..');
  if (numbers.length === 0) return 0;
  const sum = numbers.reduce((a, b) => a + b);
  return sum / numbers.length;
};

const Average = () => {
  const [list, setList] = useState([]);
  const [number, setNumber] = useState('');

  const onChange = e => {
    setNumber(e.target.value);
  };
  const onInsert = e => {
    const nextList = list.concat(parseInt(number));
    setList(nextList);
    setNumber('');
  };

  return (
    <div>
      <input value={number} onChange={onChange} />
      <button onClick={onInsert}>등록</button>
      <ul>
        {list.map((value, index) => (
          <li key={index}>{value}</li>
        ))}
      </ul>
      <div>
        <b>평균값: </b>{getAverage(list)}
      </div>
    </div>
  );
};

export default Average;

map() : 새로운 배열 생성
concat(): 배열 합체
parseInt() : 정수를 반환

useCallback

useMemo와 비슷, 렌더링 성능을 최적화해야 하는 상황에서 사용

import { useState, useMemo, useCallback } from 'react';

const getAverage = numbers => {
  console.log('평균값 계산 중..');
  if (numbers.length === 0) return 0;
  const sum = numbers.reduce((a, b) => a + b);
  return sum / numbers.length;
};

const Average = () => {
  const [list, setList] = useState([]);
  const [number, setNumber] = useState('');

  const onChange = useCallback(e => {
    setNumber(e.target.value);
  }, []); // 컴포넌트가 처음 렌더링될 때만 함수 생성
  const onInsert = useCallback(() => {
    const nextList = list.concat(parseInt(number));
    setList(nextList);
    setNumber('');
  }, [number, list]); // number 혹은 list가 바뀌었을 때만 함수 생성
  const avg = useMemo(() => getAverage(list), [list]);
  return (
    <div>
      <input value={number} onChange={onChange} />
      <button onClick={onInsert}>등록</button>
      <ul>
        {list.map((value, index) => (
          <li key={index}>{value}</li>
        ))}
      </ul>
      <div>
        <b>평균값: </b>{avg}
      </div>
    </div>
  );
};

export default Average;

useCallback 첫 번째 파라미터에는 생성하고 싶은 함수를, 두 번째 파라미터에는 배열을 넣음
이 배열엔 어떤 값이 바뀌었을 때 함수를 새로 생성할지를 명시
- 빈 배열을 넣으면 컴포넌트가 렌더링될 때 만들었던 함수를 재사용함
- 배열안에 number, list 같이 넣으면 내용이 바뀌거나 새롭게 추가될 때 새로 만들어진 함수를 사용함
함수 내부에서 상태 값에 의존해야 할 때는 그 값을 반드시 두 번째 파라미터 안에 포함시켜 주어야 함

useRef

함수 컴포넌트에서 ref를 쉽게 사용할 수 있도록 해줌

import { useState, useMemo, useCallback, useRef } from 'react';


const getAverage = numbers => {
  console.log('평균값 계산 중..');
  if (numbers.length === 0) return 0;
  const sum = numbers.reduce((a, b) => a + b);
  return sum / numbers.length;
};

const Average = () => {
  const [list, setList] = useState([]);
  const [number, setNumber] = useState('');
  const inputEl = useRef(null);

  const onChange = useCallback(e => {
    setNumber(e.target.value);
  }, []); // 컴포넌트가 처음 렌더링될 때만 함수 생성
  const onInsert = useCallback(() => {
    const nextList = list.concat(parseInt(number));
    setList(nextList);
    setNumber('');
    inputEl.current.focus();
  }, [number, list]); // number 혹은 list가 바뀌었을 때만 함수 생성
  const avg = useMemo(() => getAverage(list), [list]);
  return (
    <div>
      <input value={number} onChange={onChange} ref={inputEl} />
      <button onClick={onInsert}>등록</button>
      <ul>
        {list.map((value, index) => (
          <li key={index}>{value}</li>
        ))}
      </ul>
      <div>
        <b>평균값: </b>{avg}
      </div>
    </div>
  );
};

export default Average;

다른 Hooks

danbi lee

계속해서 보완중

다음 포스트