프론트엔드 개발 패턴은(는) 무엇을 하나요?
React, Next.js 및 성능이 뛰어난 사용자 인터페이스를 위한 최신 프론트엔드 패턴입니다.
컴포넌트 패턴
상속보다는 합성
// ✅ 좋은 예: 컴포넌트 합성
interface CardProps {
children: React.ReactNode
variant?: 'default' | 'outlined'
}
export function Card({ children, variant = 'default' }: CardProps) {
return <div className={`card card-${variant}`}>{children}</div>
}
export function CardHeader({ children }: { children: React.ReactNode }) {
return <div className="card-header">{children}</div>
}
export function CardBody({ children }: { children: React.ReactNode }) {
return <div className="card-body">{children}</div>
}
// 사용법
<Card>
<CardHeader>제목</CardHeader>
<CardBody>내용</CardBody>
</Card>
복합 컴포넌트
interface TabsContextValue {
activeTab: string
setActiveTab: (tab: string) => void
}
const TabsContext = createContext<TabsContextValue | undefined>(undefined)
export function Tabs({ children, defaultTab }: {
children: React.ReactNode
defaultTab: string
}) {
const [activeTab, setActiveTab] = useState(defaultTab)
return (
<TabsContext.Provider value={{ activeTab, setActiveTab }}>
{children}
</TabsContext.Provider>
)
}
export function TabList({ children }: { children: React.ReactNode }) {
return <div className="tab-list">{children}</div>
}
export function Tab({ id, children }: { id: string, children: React.ReactNode }) {
const context = useContext(TabsContext)
if (!context) throw new Error('Tab은 Tabs 내에서 사용되어야 합니다')
return (
<button
className={context.activeTab === id ? 'active' : ''}
onClick={() => context.setActiveTab(id)}
>
{children}
</button>
)
}
// 사용법
<Tabs defaultTab="overview">
<TabList>
<Tab id="overview">개요</Tab>
<Tab id="details">세부사항</Tab>
</TabList>
</Tabs>
렌더 프롭스 패턴
interface DataLoaderProps<T> {
url: string
children: (data: T | null, loading: boolean, error: Error | null) => React.ReactNode
}
export function DataLoader<T>({ url, children }: DataLoaderProps<T>) {
const [data, setData] = useState<T | null>(null)
const [loading, setLoading] = useState(true)
const [error, setError] = useState<Error | null>(null)
useEffect(() => {
fetch(url)
.then(res => res.json())
.then(setData)
.catch(setError)
.finally(() => setLoading(false))
}, [url])
return <>{children(data, loading, error)}</>
}
// 사용법
<DataLoader<Market[]> url="/api/markets">
{(markets, loading, error) => {
if (loading) return <Spinner />
if (error) return <Error error={error} />
return <MarketList markets={markets!} />
}}
</DataLoader>
사용자 정의 훅 패턴
상태 관리 훅
export function useToggle(initialValue = false): [boolean, () => void] {
const [value, setValue] = useState(initialValue)
const toggle = useCallback(() => {
setValue(v => !v)
}, [])
return [value, toggle]
}
// 사용법
const [isOpen, toggleOpen] = useToggle()
비동기 데이터 가져오기 훅
interface UseQueryOptions<T> {
onSuccess?: (data: T) => void
onError?: (error: Error) => void
enabled?: boolean
}
export function useQuery<T>(
key: string,
fetcher: () => Promise<T>,
options?: UseQueryOptions<T>
) {
const [data, setData] = useState<T | null>(null)
const [error, setError] = useState<Error | null>(null)
const [loading, setLoading] = useState(false)
const refetch = useCallback(async () => {
setLoading(true)
setError(null)
try {
const result = await fetcher()
setData(result)
options?.onSuccess?.(result)
} catch (err) {
const error = err as Error
setError(error)
options?.onError?.(error)
} finally {
setLoading(false)
}
}, [fetcher, options])
useEffect(() => {
if (options?.enabled !== false) {
refetch()
}
}, [key, refetch, options?.enabled])
return { data, error, loading, refetch }
}
// 사용법
const { data: markets, loading, error, refetch } = useQuery(
'markets',
() => fetch('/api/markets').then(r => r.json()),
{
onSuccess: data => console.log('가져옴', data.length, '개 시장'),
onError: err => console.error('실패:', err)
}
)
디바운스 훅
export function useDebounce<T>(value: T, delay: number): T {
const [debouncedValue, setDebouncedValue] = useState<T>(value)
useEffect(() => {
const handler = setTimeout(() => {
setDebouncedValue(value)
}, delay)
return () => clearTimeout(handler)
}, [value, delay])
return debouncedValue
}
// 사용법
const [searchQuery, setSearchQuery] = useState('')
const debouncedQuery = useDebounce(searchQuery, 500)
useEffect(() => {
if (debouncedQuery) {
performSearch(debouncedQuery)
}
}, [debouncedQuery])
상태 관리 패턴
Context + 리듀서 패턴
interface State {
markets: Market[]
selectedMarket: Market | null
loading: boolean
}
type Action =
| { type: 'SET_MARKETS'; payload: Market[] }
| { type: 'SELECT_MARKET'; payload: Market }
| { type: 'SET_LOADING'; payload: boolean }
function reducer(state: State, action: Action): State {
switch (action.type) {
case 'SET_MARKETS':
return { ...state, markets: action.payload }
case 'SELECT_MARKET':
return { ...state, selectedMarket: action.payload }
case 'SET_LOADING':
return { ...state, loading: action.payload }
default:
return state
}
}
const MarketContext = createContext<{
state: State
dispatch: Dispatch<Action>
} | undefined>(undefined)
export function MarketProvider({ children }: { children: React.ReactNode }) {
const [state, dispatch] = useReducer(reducer, {
markets: [],
selectedMarket: null,
loading: false
})
return (
<MarketContext.Provider value={{ state, dispatch }}>
{children}
</MarketContext.Provider>
)
}
export function useMarkets() {
const context = useContext(MarketContext)
if (!context) throw new Error('useMarkets는 MarketProvider 내에서 사용되어야 합니다')
return context
}
성능 최적화
메모이제이션
// ✅ useMemo를 사용한 비용이 큰 계산
const sortedMarkets = useMemo(() => {
return markets.sort((a, b) => b.volume - a.volume)
}, [markets])
// ✅ 자식에게 전달되는 함수에 useCallback 사용
const handleSearch = useCallback((query: string) => {
setSearchQuery(query)
}, [])
// ✅ 순수 컴포넌트에 React.memo 사용
export const MarketCard = React.memo<MarketCardProps>(({ market }) => {
return (
<div className="market-card">
<h3>{market.name}</h3>
<p>{market.description}</p>
</div>
)
})
코드 분할 및 지연 로딩
import { lazy, Suspense } from 'react'
// ✅ 무거운 컴포넌트 지연 로딩
const HeavyChart = lazy(() => import('./HeavyChart'))
const ThreeJsBackground = lazy(() => import('./ThreeJsBackground'))
export function Dashboard() {
return (
<div>
<Suspense fallback={<ChartSkeleton />}>
<HeavyChart data={data} />
</Suspense>
<Suspense fallback={null}>
<ThreeJsBackground />
</Suspense>
</div>
)
}
긴 목록을 위한 가상화
import { useVirtualizer } from '@tanstack/react-virtual'
export function VirtualMarketList({ markets }: { markets: Market[] }) {
const parentRef = useRef<HTMLDivElement>(null)
const virtualizer = useVirtualizer({
count: markets.length,
getScrollElement: () => parentRef.current,
estimateSize: () => 100, // 예상 행 높이
overscan: 5 // 추가로 렌더링할 항목 수
})
return (
<div ref={parentRef} style={{ height: '600px', overflow: 'auto' }}>
<div
style={{
height: `${virtualizer.getTotalSize()}px`,
position: 'relative'
}}
>
{virtualizer.getVirtualItems().map(virtualRow => (
<div
key={virtualRow.index}
style={{
position: 'absolute',
top: 0,
left: 0,
width: '100%',
height: `${virtualRow.size}px`,
transform: `translateY(${virtualRow.start}px)`
}}
>
<MarketCard market={markets[virtualRow.index]} />
</div>
))}
</div>
</div>
)
}
폼 처리 패턴
유효성 검사가 포함된 제어 폼
interface FormData {
name: string
description: string
endDate: string
}
interface FormErrors {
name?: string
description?: string
endDate?: string
}
export function CreateMarketForm() {
const [formData, setFormData] = useState<FormData>({
name: '',
description: '',
endDate: ''
})
const [errors, setErrors] = useState<FormErrors>({})
const validate = (): boolean => {
const newErrors: FormErrors = {}
if (!formData.name.trim()) {
newErrors.name = '이름은 필수입니다'
} else if (formData.name.length > 200) {
newErrors.name = '이름은 200자를 초과할 수 없습니다'
}
if (!formData.description.trim()) {
newErrors.description = '설명은 필수입니다'
}
if (!formData.endDate) {
newErrors.endDate = '종료일은 필수입니다'
}
setErrors(newErrors)
return Object.keys(newErrors).length === 0
}
const handleSubmit = async (e: React.FormEvent) => {
e.preventDefault()
if (!validate()) return
try {
await createMarket(formData)
// 성공 처리
} catch (error) {
// 오류 처리
}
}
return (
<form onSubmit={handleSubmit}>
<input
value={formData.name}
onChange={e => setFormData(prev => ({ ...prev, name: e.target.value }))}
placeholder="시장 이름"
/>
{errors.name && <span className="error">{errors.name}</span>}
{/* 다른 필드 */}
<button type="submit">시장 만들기</button>
</form>
)
}
오류 경계 패턴
interface ErrorBoundaryState {
hasError: boolean
error: Error | null
}
export class ErrorBoundary extends React.Component<
{ children: React.ReactNode },
ErrorBoundaryState
> {
state: ErrorBoundaryState = {
hasError: false,
error: null
}
static getDerivedStateFromError(error: Error): ErrorBoundaryState {
return { hasError: true, error }
}
componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
console.error('오류 경계가 잡음:', error, errorInfo)
}
render() {
if (this.state.hasError) {
return (
<div className="error-fallback">
<h2>문제가 발생했습니다</h2>
<p>{this.state.error?.message}</p>
<button onClick={() => this.setState({ hasError: false })}>
다시 시도
</button>
</div>
)
}
return this.props.children
}
}
// 사용법
<ErrorBoundary>
<App />
</ErrorBoundary>
애니메이션 패턴
Framer Motion 애니메이션
import { motion, AnimatePresence } from 'framer-motion'
// ✅ 목록 애니메이션
export function AnimatedMarketList({ markets }: { markets: Market[] }) {
return (
<AnimatePresence>
{markets.map(market => (
<motion.div
key={market.id}
initial={{ opacity: 0, y: 20 }}
animate={{ opacity: 1, y: 0 }}
exit={{ opacity: 0, y: -20 }}
transition={{ duration: 0.3 }}
>
<MarketCard market={market} />
</motion.div>
))}
</AnimatePresence>
)
}
// ✅ 모달 애니메이션
export function Modal({ isOpen, onClose, children }: ModalProps) {
return (
<AnimatePresence>
{isOpen && (
<>
<motion.div
className="modal-overlay"
initial={{ opacity: 0 }}
animate={{ opacity: 1 }}
exit={{ opacity: 0 }}
onClick={onClose}
/>
<motion.div
className="modal-content"
initial={{ opacity: 0, scale: 0.9, y: 20 }}
animate={{ opacity: 1, scale: 1, y: 0 }}
exit={{ opacity: 0, scale: 0.9, y: 20 }}
>
{children}
</motion.div>
</>
)}
</AnimatePresence>
)
}
접근성 패턴
키보드 탐색
export function Dropdown({ options, onSelect }: DropdownProps) {
const [isOpen, setIsOpen] = useState(false)
const [activeIndex, setActiveIndex] = useState(0)
const handleKeyDown = (e: React.KeyboardEvent) => {
switch (e.key) {
case 'ArrowDown':
e.preventDefault()
setActiveIndex(i => Math.min(i + 1, options.length - 1))
break
case 'ArrowUp':
e.preventDefault()
setActiveIndex(i => Math.max(i - 1, 0))
break
case 'Enter':
e.preventDefault()
onSelect(options[activeIndex])
setIsOpen(false)
break
case 'Escape':
setIsOpen(false)
break
}
}
return (
<div
role="combobox"
aria-expanded={isOpen}
aria-haspopup="listbox"
onKeyDown={handleKeyDown}
>
{/* 드롭다운 구현 */}
</div>
)
}
포커스 관리
export function Modal({ isOpen, onClose, children }: ModalProps) {
const modalRef = useRef<HTMLDivElement>(null)
const previousFocusRef = useRef<HTMLElement | null>(null)
useEffect(() => {
if (isOpen) {
// 현재 포커스된 요소 저장
previousFocusRef.current = document.activeElement as HTMLElement
// 모달로 포커스 이동
modalRef.current?.focus()
} else {
// 닫을 때 포커스 복원
previousFocusRef.current?.focus()
}
}, [isOpen])
return isOpen ? (
<div
ref={modalRef}
role="dialog"
aria-modal="true"
tabIndex={-1}
onKeyDown={e => e.key === 'Escape' && onClose()}
>
{children}
</div>
) : null
}
상태 관리 라이브러리 패턴
Zustand
import { create } from 'zustand'
interface MarketStore {
markets: Market[]
selectedMarket: Market | null
loading: boolean
error: string | null
fetchMarkets: () => Promise<void>
selectMarket: (market: Market) => void
}
export const useMarketStore = create<MarketStore>((set) => ({
markets: [],
selectedMarket: null,
loading: false,
error: null,
fetchMarkets: async () => {
set({ loading: true, error: null })
try {
const response = await fetch('/api/markets')
const markets = await response.json()
set({ markets, loading: false })
} catch (error) {
set({ error: (error as Error).message, loading: false })
}
},
selectMarket: (market) => set({ selectedMarket: market })
}))
// 사용법
function MarketPage() {
const { markets, loading, selectedMarket, fetchMarkets, selectMarket } = useMarketStore()
useEffect(() => {
fetchMarkets()
}, [fetchMarkets])
if (loading) return <Loading />
return (
<div>
<MarketList markets={markets} onSelect={selectMarket} />
{selectedMarket && <MarketDetail market={selectedMarket} />}
</div>
)
}
Jotai
import { atom, useAtom } from 'jotai'
// 기본 아톰
const marketsAtom = atom<Market[]>([])
const selectedMarketIdAtom = atom<string | null>(null)
// 파생 아톰
const selectedMarketAtom = atom((get) => {
const markets = get(marketsAtom)
const selectedId = get(selectedMarketIdAtom)
return markets.find(market => market.id === selectedId) || null
})
// 비동기 아톰
const fetchMarketsAtom = atom(
null,
async (_get, set) => {
const response = await fetch('/api/markets')
const markets = await response.json()
set(marketsAtom, markets)
}
)
// 사용법
function MarketView() {
const [markets] = useAtom(marketsAtom)
const [selectedMarket] = useAtom(selectedMarketAtom)
const [, fetchMarkets] = useAtom(fetchMarketsAtom)
useEffect(() => {
fetchMarkets()
}, [fetchMarkets])
return (
<div>
<MarketList markets={markets} />
{selectedMarket && <MarketDetail market={selectedMarket} />}
</div>
)
}
서버 사이드 렌더링 패턴
Next.js App Router 패턴
// app/markets/page.tsx
import { Metadata } from 'next'
interface MarketPageProps {
params: { id: string }
searchParams: { page?: string }
}
// ✅ 서버 컴포넌트
export default async function MarketsPage() {
const markets = await fetchMarkets()
return (
<div>
<h1>시장</h1>
<MarketList data={markets} />
</div>
)
}
// ✅ 정적 메타데이터
export const metadata: Metadata = {
title: '시장',
description: '모든 시장 보기'
}
스트리밍 및 Suspense
import { Suspense } from 'react'
export default function DashboardPage() {
return (
<div>
<h1>대시보드</h1>
<Suspense fallback={<MarketsSkeleton />}>
{/* 내부에서 await 하는 서버 컴포넌트 */}
<MarketsSection />
</Suspense>
<Suspense fallback={<TrendingSkeleton />}>
<TrendingSection />
</Suspense>
</div>
)
}
서버 액션을 통한 데이터 변경
// app/markets/actions.ts
'use server'
import { revalidatePath } from 'next/cache'
export async function createMarket(formData: FormData) {
const name = formData.get('name') as string
const description = formData.get('description') as string
// 유효성 검사
if (!name || name.length > 200) {
return { error: '유효하지 않은 이름' }
}
try {
await db.market.create({ data: { name, description } })
revalidatePath('/markets')
return { success: true }
} catch (error) {
return { error: '시장을 생성하지 못했습니다' }
}
}
// app/markets/new/page.tsx
export default function NewMarketPage() {
return (
<form action={createMarket}>
<input name="name" placeholder="시장 이름" required />
<textarea name="description" placeholder="설명" required />
<button type="submit">시장 만들기</button>
</form>
)
}
테스트 패턴
컴포넌트 테스트
import { render, screen, fireEvent } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
describe('MarketCard', () => {
const mockMarket = {
id: '1',
name: '테스트 시장',
description: '설명'
}
it('시장 이름과 설명을 렌더링합니다', () => {
render(<MarketCard market={mockMarket} />)
expect(screen.getByText('테스트 시장')).toBeInTheDocument()
expect(screen.getByText('설명')).toBeInTheDocument()
})
it('클릭 시 onSelect를 호출합니다', async () => {
const onSelect = jest.fn()
render(<MarketCard market={mockMarket} onSelect={onSelect} />)
await userEvent.click(screen.getByRole('button'))
expect(onSelect).toHaveBeenCalledWith(mockMarket)
})
})
통합 테스트
describe('MarketList', () => {
const mockMarkets = [
{ id: '1', name: '시장 1', description: '설명 1' },
{ id: '2', name: '시장 2', description: '설명 2' }
]
it('모든 시장을 렌더링합니다', () => {
render(<MarketList markets={mockMarkets} />)
expect(screen.getByText('시장 1')).toBeInTheDocument()
expect(screen.getByText('시장 2')).toBeInTheDocument()
})
it('선택 시 selectedMarket을 업데이트합니다', async () => {
render(<MarketsPage />)
await userEvent.click(screen.getByText('시장 1'))
expect(screen.getByText('선택된 시장: 시장 1')).toBeInTheDocument()
})
})
사용자 정의 훅 테스트
import { renderHook, act } from '@testing-library/react'
describe('useDebounce', () => {
beforeEach(() => {
jest.useFakeTimers()
})
afterEach(() => {
jest.useRealTimers()
})
it('지정된 지연 후에 값을 업데이트합니다', () => {
const { result, rerender } = renderHook(
({ value, delay }) => useDebounce(value, delay),
{ initialProps: { value: '초기', delay: 500 } }
)
expect(result.current).toBe('초기')
rerender({ value: '업데이트됨', delay: 500 })
act(() => {
jest.advanceTimersByTime(300)
})
expect(result.current).toBe('초기')
act(() => {
jest.advanceTimersByTime(200)
})
expect(result.current).toBe('업데이트됨')
})
})
CSS 및 스타일링 패턴
CSS 모듈
// components/MarketCard.module.css
.card {
border: 1px solid var(--border-color);
border-radius: 8px;
padding: 16px;
transition: box-shadow 0.2s;
}
.card:hover {
box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
}
.title {
font-size: 1.25rem;
font-weight: 600;
margin-bottom: 8px;
}
.description {
color: var(--text-secondary);
line-height: 1.5;
}
// components/MarketCard.tsx
import styles from './MarketCard.module.css'
export function MarketCard({ market }: { market: Market }) {
return (
<div className={styles.card}>
<h3 className={styles.title}>{market.name}</h3>
<p className={styles.description}>{market.description}</p>
</div>
)
}
Tailwind CSS 유틸리티 구성
// ✅ 일관된 디자인을 위한 합성 유틸리티 함수
function cn(...classes: (string | boolean | undefined)[]) {
return classes.filter(Boolean).join(' ')
}
interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
variant?: 'primary' | 'secondary' | 'ghost'
size?: 'sm' | 'md' | 'lg'
}
export function Button({ variant = 'primary', size = 'md', className, ...props }: ButtonProps) {
return (
<button
className={cn(
'rounded-lg font-medium transition-colors focus:outline-none focus:ring-2',
{
'bg-blue-600 text-white hover:bg-blue-700': variant === 'primary',
'bg-gray-200 text-gray-900 hover:bg-gray-300': variant === 'secondary',
'bg-transparent text-gray-600 hover:bg-gray-100': variant === 'ghost'
},
{
'px-3 py-1.5 text-sm': size === 'sm',
'px-4 py-2 text-base': size === 'md',
'px-6 py-3 text-lg': size === 'lg'
},
className
)}
{...props}
/>
)
}
Next.js 앱 라우터 모범 사례
서버 컴포넌트와 클라이언트 컴포넌트
// app/markets/[id]/page.tsx - 서버 컴포넌트 (기본값)
import { notFound } from 'next/navigation'
import MarketDetail from './MarketDetail'
interface PageProps {
params: { id: string }
}
export default async function MarketPage({ params }: PageProps) {
const market = await fetchMarket(params.id)
if (!market) {
notFound()
}
// 데이터는 서버에서 가져오고 클라이언트 컴포넌트에 props로 전달
return <MarketDetail market={market} />
}
// app/markets/[id]/MarketDetail.tsx - 클라이언트 컴포넌트
'use client'
import { useState } from 'react'
export default function MarketDetail({ market }: { market: Market }) {
const [isFollowing, setIsFollowing] = useState(false)
return (
<div>
<h1>{market.name}</h1>
<p>{market.description}</p>
<button onClick={() => setIsFollowing(!isFollowing)}>
{isFollowing ? '팔로우 중' : '팔로우'}
</button>
</div>
)
}
데이터 가져오기 패턴
// ✅ 병렬 데이터 가져오기
export default async function DashboardPage() {
// 데이터 가져오기 병렬 실행
const [markets, user, trending] = await Promise.all([
fetchMarkets(),
fetchCurrentUser(),
fetchTrending()
])
return (
<div>
<MarketsList data={markets} />
<UserProfile user={user} />
<TrendingSection data={trending} />
</div>
)
}
// ✅ 조건부 데이터 가져오기
export default async function SearchPage({
searchParams
}: {
searchParams: { q?: string }
}) {
// 쿼리가 있는 경우에만 데이터 가져오기
const results = searchParams.q
? await searchMarkets(searchParams.q)
: []
return (
<div>
<SearchForm initialQuery={searchParams.q} />
<SearchResults results={results} />
</div>
)
}
결론
이러한 프론트엔드 패턴은 확장 가능하고 유지보수 가능하며 성능이 뛰어난 사용자 인터페이스를 구축하기 위한 견고한 기반을 제공합니다. 주요 내용은 다음과 같습니다:
- 컴포넌트 패턴: 재사용 가능한 UI를 위한 합성, 복합 컴포넌트 및 렌더 프롭스
- 훅: 재사용 가능한 로직을 위한 useToggle, useQuery 및 useDebounce
- 상태 관리: 예측 가능한 상태를 위한 Context + Reducer, Zustand 및 Jotai
- 성능: 메모이제이션, 코드 분할 및 가상화
- 서버 렌더링: Next.js App Router, 스트리밍 및 서버 액션
- 테스트: 포괄적인 적용 범위를 위한 단위, 통합 및 훅 테스트
- 접근성: 키보드 탐색 및 포커스 관리
항상 특정 사용 사례에 가장 적합한 패턴을 선택하고 복잡성을 지나치게 추상화하지 않도록 주의하세요.