\ 'React.js' 카테고리의 글 목록 :: Something New
728x90
반응형
 

리액트에서 자주 사용되는 주요 훅들은 useState, useEffect, useContext, useReducer, useRef가 있습니다. 각각의 훅과 사용 예시를 함께 정리해 보겠습니다.


1. useState

컴포넌트에서 상태를 관리하는 가장 기본적인 훅입니다.

  • 사용법: [상태, 상태변경함수] = useState(초기값)
 
import React, { useState } from 'react';

function Counter() {
  const [count, setCount] = useState(0); // count 상태 변수와 상태 변경 함수 setCount 설정

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => setCount(count + 1)}>Increase</button>
    </div>
  );
}

이 훅은 간단한 숫자, 문자열, 배열 등 다 ㅈ양한 데이터 유형을 상태로 관리할 수 있습니다.


2. useEffect

컴포넌트의 생명주기 동안 특정 작업을 수행할 수 있는 훅입니다. componentDidMount, componentDidUpdate, componentWillUnmount의 역할을 대체합니다.

  • 사용법: useEffect(콜백 함수, [의존성 배열])
 
 
import React, { useState, useEffect } from 'react';

function Timer() {
  const [time, setTime] = useState(0);

  useEffect(() => {
    const interval = setInterval(() => {
      setTime(prevTime => prevTime + 1);
    }, 1000);

    return () => clearInterval(interval); // 컴포넌트가 언마운트될 때 타이머 정리
  }, []); // 빈 배열은 마운트 시 한 번만 실행

  return <div>Timer: {time} seconds</div>;
}

useEffect는 데이터 가져오기, 타이머 설정, 이벤트 리스너 등록 및 해제 같은 작업에 유용합니다.


3. useContext

컴포넌트 트리에서 데이터를 전역으로 관리하고 공유할 때 사용하는 훅입니다. Context API와 함께 사용하며, props를 여러 단계에 걸쳐 전달하지 않고도 데이터를 자식 컴포넌트에 전달할 수 있습니다.

  • 사용법: const contextValue = useContext(Context)
 
import React, { useContext } from 'react';

const ThemeContext = React.createContext('light'); // 초기값 설정

function ThemedButton() {
  const theme = useContext(ThemeContext); // ThemeContext 값을 가져옴
  return <button className={theme}>Themed Button</button>;
}

function App() {
  return (
    <ThemeContext.Provider value="dark">
      <ThemedButton />
    </ThemeContext.Provider>
  );
}

useContext는 전역적으로 관리되는 데이터를 쉽게 사용하게 해 주어 테마나 사용자 정보 관리에 유용합니다.


4. useReducer

useState보다 복잡한 상태 로직이 필요할 때 사용하는 훅입니다. 주로 상태와 액션을 분리하여 Redux와 유사한 패턴으로 상태를 관리할 수 있습니다.

  • 사용법: [상태, dispatch] = useReducer(리듀서 함수, 초기 상태)
 
import React, { useReducer } from 'react';

function reducer(state, action) {
  switch (action.type) {
    case 'increment':
      return { count: state.count + 1 };
    case 'decrement':
      return { count: state.count - 1 };
    default:
      return state;
  }
}

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

  return (
    <div>
      <p>Count: {state.count}</p>
      <button onClick={() => dispatch({ type: 'increment' })}>+</button>
      <button onClick={() => dispatch({ type: 'decrement' })}>-</button>
    </div>
  );
}

useReducer는 복잡한 상태와 여러 상태 변경 작업을 관리할 때 유용합니다.


5. useRef

특정 DOM 요소에 접근하거나 컴포넌트가 리렌더링될 때 유지해야 하는 값에 접근할 수 있습니다. useRef로 생성된 객체는 컴포넌트가 리렌더링되어도 값이 유지됩니다.

  • 사용법: const refContainer = useRef(초기값)
 
 
 
import React, { useRef } from 'react';

function FocusInput() {
  const inputRef = useRef(null);

  const focusInput = () => {
    if (inputRef.current) {
      inputRef.current.focus();
    }
  };

  return (
    <div>
      <input ref={inputRef} type="text" />
      <button onClick={focusInput}>Focus the input</button>
    </div>
  );
}

useRef는 DOM 조작이 필요한 경우나 이전 상태를 유지하고 싶은 경우에 유용합니다.


이 외에도 리액트에서는 useMemouseCallback 훅도 자주 사용됩니다.

이 훅들은 성능 최적화를 위해 특정 값이나 함수를 메모이제이션할 때 사용합니다.

 

728x90
728x90
반응형

 

제가 현장에서 쓰고 있는 환경은 yarn만 사용하고 있는데요

npm과의 차이는 무엇인지 정리해 보았습니다.

npm과 yarn은 모두 자바스크립트 패키지 관리 도구로, 프로젝트의 의존성(패키지)을 관리하는 데 사용됩니다. 하

지만 두 도구는 몇 가지 중요한 차이점과 장점을 가지고 있습니다.

npm과 yarn의 주요 차이점과 yarn을 사용하는 이유

npm (Node Package Manager)

  • 역사: npm은 Node.js와 함께 출시되었으며, 가장 널리 사용되는 패키지 관리 도구입니다.
  • 기본 기능: 패키지 설치, 업데이트, 삭제, 스크립트 실행 등 기본적인 패키지 관리 기능을 제공합니다.
  • 의존성 관리: package.json 파일을 사용해 의존성을 정의하고, package-lock.json 파일을 통해 설치된 패키지의 정확한 버전을 기록합니다.
  • 속도: 초기에는 설치 속도가 상대적으로 느렸지만, 최근 버전에서는 속도 개선이 이루어졌습니다.
  • 캐싱: npm은 패키지를 로컬 캐시에 저장하지만, 캐시 관리는 yarn에 비해 약간 불완전할 수 있습니다.

Yarn

  • 역사: Yarn은 Facebook이 개발하였으며, npm의 속도와 안정성 문제를 해결하기 위해 만들어졌습니다.
  • 기본 기능: 패키지 설치, 업데이트, 삭제, 스크립트 실행 등의 기본 기능을 제공하며, npm과 호환됩니다.
  • 의존성 관리: package.json과 함께 yarn.lock 파일을 사용하여 설치된 패키지의 버전을 정확히 기록합니다. yarn.lock 파일은 의존성의 정확한 버전을 보장하는 데 도움을 줍니다.
  • 속도: 캐시와 병렬 설치 덕분에 패키지 설치 속도가 빠릅니다.
  • 캐싱: Yarn은 패키지를 로컬 캐시에 저장하고, 캐시를 적극적으로 활용하여 재사용합니다. 이는 설치 속도를 크게 향상시킵니다.
  • 오프라인 모드: Yarn은 오프라인 모드를 지원하여, 한 번 설치한 패키지를 인터넷 없이도 재설치할 수 있습니다.
  • 버전 관리: yarn은 의존성의 정확한 버전을 보장하는 yarn.lock 파일을 생성하여, 팀원 간의 일관된 환경을 유지하는 데 도움을 줍니다.
  • 워크스페이스: Yarn은 여러 패키지를 동시에 관리할 수 있는 워크스페이스 기능을 제공하여, 모노레포(Monorepo) 구조를 지원합니다.

yarn을 사용하는 이유

  1. 속도: Yarn은 병렬 설치와 강력한 캐시 시스템 덕분에 패키지 설치 속도가 빠릅니다. 이는 대규모 프로젝트에서 유리합니다.
  2. 일관성: yarn.lock 파일을 사용하여, 개발 팀원들이 동일한 버전의 패키지를 설치하도록 보장할 수 있습니다. 이는 의존성 버전 충돌 문제를 줄이는 데 도움을 줍니다.
  3. 오프라인 설치: Yarn은 오프라인 모드를 지원하여, 이전에 설치한 패키지를 인터넷 없이도 설치할 수 있습니다. 이는 네트워크 문제로 인한 장애를 방지할 수 있습니다.
  4. 워크스페이스 지원: Yarn의 워크스페이스 기능을 사용하면, 모노레포 구조를 쉽게 관리할 수 있어, 여러 패키지를 동시에 개발하고 관리할 때 유리합니다.
  5. 강력한 캐싱: Yarn의 캐시 시스템은 패키지를 로컬에 저장하고, 재사용을 통해 설치 시간을 단축시킵니다.

이러한 이유로 yarn은 많은 개발자들이 선호하는 패키지 관리 도구가 되었으며, 특히 대규모 프로젝트나 모노레포 환경에서 유리합니다. npm도 지속적으로 개선되고 있으며, 최신 버전에서는 많은 성능 개선과 새로운 기능들이 추가되었습니다. 두 도구 중 어떤 것을 선택할지는 프로젝트의 필요와 팀의 선호에 따라 결정하면 됩니다.

같은 소스를 갖고 수정을 하다보면 package.json파일을 수정하는 경우가 생기는데요

이 때 단순히 커밋만 할 경우 다른 분들의 환경에서는 에러가 날 수 있습니다.

package.json을 수정한 후 동료에게 yarn install을 터미널에서 한 번 해달라고 요청하면 됩니다.

모두에게 동일한 버전의 패키지가 업데이트 됩니다.

yarn install은 Node.js 프로젝트에서 사용하는 패키지 관리 도구인 Yarn이 패키지를 설치하는 명령어입니다. 이 명령어는 프로젝트의 의존성(dependencies)을 package.json 파일에 정의된 대로 다운로드하고, 이를 node_modules 디렉터리에 설치합니다. 이 과정에서 여러 가지 작업이 수행됩니다:

  1. package.json 파일을 분석: package.json 파일에 명시된 의존성 목록을 읽어들입니다.
  2. 의존성 설치: package.json 파일에 나열된 패키지들과 그에 따른 하위 의존성들을 모두 설치합니다.
  3. yarn.lock 파일 관리: yarn.lock 파일이 없다면 생성하고, 의존성 버전을 고정하여 프로젝트에서 동일한 버전의 패키지를 사용할 수 있도록 보장합니다. 이미 yarn.lock 파일이 있다면 그 내용을 바탕으로 의존성을 설치합니다.
  4. 중복 제거 및 캐싱: Yarn은 중복된 패키지를 제거하고, 이미 다운로드된 패키지를 캐싱하여 이후 설치 속도를 빠르게 합니다.

이 명령어는 프로젝트의 종속성을 최신 상태로 유지하고, 필요한 패키지를 설치하는 데 사용됩니다.

728x90
728x90
반응형

1] React Hook Form: useForm

1. useForm 이란

useForm은 React Hook Form 라이브러리에서 제공하는 커스텀 훅으로, 폼 관리를 손쉽게 할 수 있도록 도와줍니다. useForm은 객체를 인수로 받아 다양한 옵션을 설정할 수 있습니다

2. 주요 옵션

  • mode: 사용자가 폼을 제출하기 전에 언제 검증이 발생할지 설정하는 옵션입니다.
    • onSubmit (기본값): 폼 제출 시 검증이 발생합니다.
    • onBlur: 입력 필드가 포커스를 잃을 때 검증이 발생합니다.
    • onChange: 입력 값이 변경될 때마다 검증이 발생합니다. 이 경우 성능에 영향을 미칠 수 있습니다.
    • onTouched: 필드가 처음으로 포커스를 잃을 때 검증이 발생하고, 이후로는 값이 변경될 때마다 검증됩니다.
    • all: onBlur와 onChange 이벤트 모두에서 검증이 발생합니다.
  • reValidateMode: 폼이 제출된 후에 에러가 있는 입력 필드가 다시 검증되는 시점을 설정하는 옵션입니다.
    • onChange (기본값): 입력 값이 변경될 때마다 재검증이 발생합니다.
    • onBlur: 입력 필드가 포커스를 잃을 때 재검증이 발생합니다.
  • defaultValues: 폼의 기본 값을 설정하는 옵션입니다. 동기적 및 비동기적으로 기본 값을 설정할 수 있으며, 이 값은 폼이 처음 렌더링될 때 사용됩니다.
  • values: 외부 상태나 서버 데이터로 폼 값을 동기화하는 데 유용한 옵션입니다. values가 업데이트되면 폼 값이 자동으로 갱신됩니다.

 

import React from "react";
import { useForm } from "react-hook-form";

function App() {
  const { register, handleSubmit } = useForm({
    mode: "onSubmit",
    defaultValues: {
      firstName: "",
      lastName: "",
    },
  });

  const onSubmit = (data) => {
    console.log(data);
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <input {...register("firstName")} />
      <input {...register("lastName")} />
      <input type="submit" />
    </form>
  );
}

2] React Hook Form: 폼 상태 관리와 검증

1. 폼 상태 관리

useForm 훅은 폼의 상태를 관리하는 여러 가지 기능을 제공합니다. formState 객체를 통해 폼의 다양한 상태를 확인하고 제어할 수 있습니다.

  • errors: 각 입력 필드의 오류 상태를 관리합니다. 서버에서 반환된 오류 상태와 동기화할 수 있습니다.
  • isSubmitting: 폼이 제출 중인 상태를 나타냅니다.
  • isDirty: 사용자가 입력 필드를 수정한 상태를 나타냅니다.

2. 검증 옵션

useForm은 다양한 방식으로 폼 입력 값을 검증할 수 있도록 옵션을 제공합니다.

  • criteriaMode: 필드에서 발생한 모든 오류를 표시할지, 첫 번째 오류만 표시할지 설정할 수 있습니다.
    • firstError (기본값): 각 필드에서 발생한 첫 번째 오류만 수집됩니다.
    • all: 모든 오류를 수집합니다.
  • shouldFocusError: 검증 실패 시 첫 번째 오류가 발생한 필드에 자동으로 포커스를 설정할지 여부를 제어합니다. 기본값은 true입니다.
import React from "react";
import { useForm } from "react-hook-form";

function App() {
  const { register, handleSubmit, formState: { errors } } = useForm({
    criteriaMode: "all",
  });

  const onSubmit = (data) => {
    console.log(data);
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <input {...register("firstName", { required: "First name is required" })} />
      {errors.firstName && <p>{errors.firstName.message}</p>}
      <input type="submit" />
    </form>
  );
}

3] React Hook Form

1. 폼 값과 에러 상태 초기화

useForm에서는 폼을 초기화할 수 있는 다양한 방법을 제공합니다. 이를 통해 폼을 새로 고침 없이도 값과 에러 상태를 쉽게 초기화할 수 있습니다.

  • reset: 폼 전체를 초기 상태로 되돌립니다. resetOptions를 사용해 초기화 시 값을 유지하거나 에러 상태를 유지할 수 있습니다.
  • resetField: 특정 필드만 초기화할 수 있습니다.

2. 외부 라이브러리와 통합

useForm은 Yup, Zod, Joi 등과 같은 외부 검증 라이브러리와 통합할 수 있습니다. 이를 통해 더 강력하고 유연한 검증을 구현할 수 있습니다.

  • resolver: 외부 라이브러리와 통합하기 위한 옵션입니다. 사용자가 선호하는 검증 라이브러리를 선택해 사용할 수 있습니다.
import React from "react";
import { useForm } from "react-hook-form";
import { yupResolver } from "@hookform/resolvers/yup";
import * as yup from "yup";

const schema = yup.object().shape({
  name: yup.string().required("Name is required"),
  age: yup.number().required("Age is required").positive().integer(),
});

function App() {
  const { register, handleSubmit } = useForm({
    resolver: yupResolver(schema),
  });

  const onSubmit = (data) => {
    console.log(data);
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <input {...register("name")} />
      <input type="number" {...register("age")} />
      <input type="submit" />
    </form>
  );
}
728x90
728x90
반응형

abulator는 JavaScript로 작성된 고성능 그리드 테이블 라이브러리로, 다양한 기능과 유연성을 제공하여 복잡한 데이터 테이블을 쉽게 만들 수 있습니다. 이 블로그에서는 React Query와 Tabulator를 함께 사용하여 조회 및 저장 기능을 구현하는 방법을 설명하겠습니다.

Tabulator 사용 이유

  • 고성능: 대량의 데이터를 빠르게 처리하고 렌더링할 수 있습니다.
  • 유연성: 다양한 데이터 소스와 쉽게 통합할 수 있습니다.
  • 사용 편의성: 간단한 API와 다양한 설정 옵션을 제공하여 개발 시간을 절약할 수 있습니다.
  • 풍부한 기능: 정렬, 필터링, 페이지네이션, 편집 등의 다양한 기능을 기본적으로 제공합니다.

Tabulator 설치 및 설정

npm install tabulator-tables

설치 후, Tabulator 스타일시트를 추가해야 합니다. 이를 위해 index.html 파일에 다음을 추가합니다:

<link href="https://unpkg.com/tabulator-tables@4.9.3/dist/css/tabulator.min.css" rel="stylesheet">

이제 React 컴포넌트에서 Tabulator를 사용할 준비가 되었습니다.

import React, { useEffect, useRef } from 'react';
import Tabulator from 'tabulator-tables';
import 'tabulator-tables/dist/css/tabulator.min.css';

const SimpleGrid = ({ data, onAddRow, onDeleteRow }) => {
  const tableRef = useRef(null);

  useEffect(() => {
    const table = new Tabulator(tableRef.current, {
      columns: [
        { title: 'Name', 
          field: 'name', 
          editor: 'input'   
        },
        { title: 'Age', 
          field: 'age', 
          editor: 'input' 
        },
        // 필요한 다른 컬럼들을 추가합니다
      ],
    });

    // 데이터가 변경될 때마다 테이블을 업데이트합니다
    if (data) {
      table.setData(data);
    }
    
    // Cleanup function to destroy the table when the component unmounts
    return () => table.destroy();
  }, [data]);

  const handleAddRow = () => {
    onAddRow({ name: '', age: '' }); // 기본값을 가진 새 행 추가
  };

  const handleDeleteRow = () => {
    const table = tableRef.current.tabulator;
    const selectedRows = table.getSelectedRows();
    selectedRows.forEach(row => row.delete());
    onDeleteRow(selectedRows.map(row => row.getData())); // 삭제된 행 데이터 반환
  };

  return (
    <div>
      <button onClick={handleAddRow}>행 추가</button>
      <button onClick={handleDeleteRow}>행 삭제</button>
      <div ref={tableRef}></div>
    </div>
  );
};

export default SimpleGrid;
import React, { useState } from 'react';
import { useQuery } from 'react-query';
import SimpleGrid from './SimpleGrid';

// 데이터 조회 함수
const fetchData = async (params) => {
  const response = await fetch(`https://api.example.com/data?${new URLSearchParams(params)}`);
  if (!response.ok) {
    throw new Error('네트워크 응답에 문제가 있습니다');
  }
  return response.json();
};

const DataView = () => {
  const [searchParams, setSearchParams] = useState({});
  const [gridData, setGridData] = useState([]);
  
  // useQuery 훅을 사용하여 데이터를 조회합니다
  const { refetch, isFetching } = useQuery(
    ['fetchData', searchParams],
    () => fetchData(searchParams),
    {
      enabled: false,
      onSuccess: (data) => setGridData(data), // 데이터 조회 후 상태 업데이트
    }
  );

  // 검색 버튼 클릭 시 호출되는 함수
  const handleSearch = () => {
    const params = {
      key1: 'value1',
      key2: 'value2',
    };
    setSearchParams(params);
    refetch();
  };

  const handleAddRow = (newRow) => {
    setGridData([...gridData, newRow]);
  };

  const handleDeleteRow = (deletedRows) => {
    setGridData(gridData.filter(row => !deletedRows.includes(row)));
  };

  return (
    <div>
      <button onClick={handleSearch}>검색</button>
      {isFetching ? (
        <p>로딩 중...</p>
      ) : (
        <SimpleGrid 
        	data={gridData} 
        	onAddRow={handleAddRow} 
            onDeleteRow={handleDeleteRow} />
      )}
    </div>
  );
};

export default DataView;

 

728x90
728x90
반응형

데이터 저장 기능은 useMutation 훅을 사용하여 구현할 수 있습니다. 아래는 예시 코드입니다:

import React, { useState } from 'react';
import { useMutation, useQueryClient } from 'react-query';

// 데이터 저장 함수
const saveData = async (data) => {
  const response = await fetch('https://api.example.com/save', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(data),
  });
  if (!response.ok) {
    throw new Error('데이터 저장에 문제가 있습니다');
  }
  return response.json();
};

const DataSave = () => {
  const queryClient = useQueryClient();
  const [formData, setFormData] = useState({ key1: '', key2: '' });

  // useMutation 훅을 사용하여 데이터를 저장합니다
  const mutation = useMutation(saveData, {
    onSuccess: () => {
      // 저장이 성공하면 데이터를 다시 조회합니다
      queryClient.invalidateQueries('fetchData');
    },
  });

  // 폼 제출 시 호출되는 함수
  const handleSubmit = (event) => {
    event.preventDefault();
    mutation.mutate(formData);
  };

  return (
    <form onSubmit={handleSubmit}>
      <input
        type="text"
        value={formData.key1}
        onChange={(e) => setFormData({ ...formData, key1: e.target.value })}
        placeholder="Key1"
      />
      <input
        type="text"
        value={formData.key2}
        onChange={(e) => setFormData({ ...formData, key2: e.target.value })}
        placeholder="Key2"
      />
      <button type="submit">저장</button>
      {mutation.isLoading ? (
        <p>저장 중...</p>
      ) : mutation.isError ? (
        <p>저장에 실패했습니다: {mutation.error.message}</p>
      ) : (
        mutation.isSuccess && <p>저장이 완료되었습니다!</p>
      )}
    </form>
  );
};

export default DataSave;

 

  • saveData 함수: 서버에 데이터를 저장하는 함수입니다.
  • useMutation 훅: React Query를 사용하여 데이터를 저장합니다.
  • handleSubmit 함수: 폼 제출 시 호출되어 데이터를 저장합니다.
  • queryClient.invalidateQueries: 데이터 저장이 성공하면 해당 쿼리를 무효화하여 데이터를 다시 조회합니다.

 

728x90
728x90
반응형

React Query는 서버 상태 관리를 쉽게 할 수 있도록 도와주는 강력한 라이브러리입니다. 이 블로그에서는 React Query를 사용한 조회 기능과 저장 기능을 중심으로 사용법을 설명하겠습니다.

React Query 설정

먼저 React Query를 설치해야 합니다. 다음 명령어를 사용하여 설치할 수 있습니다:

npm install react-query

설치 후, QueryClient와 QueryClientProvider를 설정해야 합니다. 애플리케이션의 루트 컴포넌트에서 이를 설정합니다.

import React from 'react';
import { QueryClient, QueryClientProvider } from 'react-query';

const queryClient = new QueryClient();

const App = () => (
  <QueryClientProvider client={queryClient}>
    {/* 나머지 애플리케이션 컴포넌트 */}
  </QueryClientProvider>
);

export default App;

이제 React Query를 사용할 준비가 되었습니다.

조회 기능 구현

React Query의 useQuery 훅을 사용하여 데이터를 조회할 수 있습니다. 아래는 예시 코드입니다:

import React, { useEffect, useRef, useState } from 'react';
import { useQuery } from 'react-query';

// 데이터 조회 함수
const fetchData = async (params) => {
  const response = await fetch(`https://api.example.com/data?${new URLSearchParams(params)}`);
  if (!response.ok) {
    throw new Error('네트워크 응답에 문제가 있습니다');
  }
  return response.json();
};

const DataView = () => {
  const [searchParams, setSearchParams] = useState({});
  const gridRef = useRef();

  // useQuery 훅을 사용하여 데이터를 조회합니다
  const { data, refetch, isFetching } = useQuery(
    ['fetchData', searchParams],
    () => fetchData(searchParams),
    { enabled: false } // 초기에는 비활성화
  );

  // 검색 버튼 클릭 시 호출되는 함수
  const handleSearch = () => {
    const params = {
      key1: 'value1',
      key2: 'value2',
    };
    setSearchParams(params);
    refetch();
  };

  // 검색 파라미터가 변경될 때마다 데이터를 재조회합니다
  useEffect(() => {
    if (Object.keys(searchParams).length > 0) {
      refetch();
    }
  }, [searchParams, refetch]);

  return (
    <div>
      <button onClick={handleSearch}>검색</button>
      {isFetching ? (
        <p>로딩 중...</p>
      ) : (
        <div ref={gridRef}>
          {/* 데이터를 그리드에 표시합니다 */}
          {data?.map((item, index) => (
            <div key={index}>{item.name}</div>
          ))}
        </div>
      )}
    </div>
  );
};

export default DataView;
  • fetchData 함수: 서버로부터 데이터를 가져오는 함수입니다.
  • useQuery 훅: React Query를 사용하여 데이터를 조회합니다.
  • handleSearch 함수: 검색 버튼 클릭 시 호출되어 검색 파라미터를 설정하고 데이터를 재조회합니다.
  • useEffect 훅: 검색 파라미터가 변경될 때마다 데이터를 재조회합니다.

:

728x90

+ Recent posts