프런트엔드 프로젝트 구성요소 폴더 구성

폴더 구조 프론트엔드 프로젝트의 구성요소는 중요합니다. 프로젝트를 더 쉽게 개발하고 유지 관리할 수 있기 때문입니다. 특히 크거나 복잡한 구성 요소를 처리할 때 폴더를 구성하면 코드를 체계적으로 정리하고 쉽게 찾고 이해할 수 있습니다.

폴더 구조는 이렇습니다. 다양한 형식의 구성요소 다음을 사용하여 개발된 프로젝트에서 일반적으로 사용됩니다. Next.js 및 TypeScript:

1. 원자적 디자인 구조

Atomic Design은 구성 요소를 복잡성과 기능에 따라 구분하는 디자인 개념입니다. 원자, 분자, 유기체, 템플릿, 페이지의 5가지 레벨로 구분됩니다.

src/
└── components/
    ├── atoms/             # Small, reusable elements (e.g., buttons, inputs)
    │   ├── Button.tsx
    │   ├── Input.tsx
    │   ├── Icon.tsx
    │   └── ...            # Additional atoms
    │
    ├── molecules/         # Combinations of atoms (e.g., form groups)
    │   ├── FormInput.tsx
    │   ├── NavLink.tsx
    │   └── ...            # Additional molecules
    │
    ├── organisms/         # Complex UI components (e.g., headers, cards)
    │   ├── Header.tsx
    │   ├── Card.tsx
    │   ├── Footer.tsx
    │   └── ...            # Additional organisms
    │
    ├── templates/         # Page templates (layouts with placeholders)
    │   ├── MainLayout.tsx
    │   ├── DashboardLayout.tsx
    │   └── ...            # Additional templates
    │
    └── pages/             # Page-specific components (used directly in pages)
        ├── HomePage.tsx
        ├── AboutPage.tsx
        └── ...            # Additional page components

예:

원자: Button.tsx

import React from 'react';

interface ButtonProps {
  label: string;
  onClick: () => void;
  type?: 'button' | 'submit' | 'reset';
  disabled?: boolean;
}

const Button: React.FC<buttonprops> = ({ label, onClick, type = 'button', disabled = false }) => (
  <button type="{type}" onclick="{onClick}" disabled classname="btn">
    {label}
  </button>
);

export default Button;
</buttonprops>

분자: FormInput.tsx

import React from 'react';
import Input from '../atoms/Input';
import Label from '../atoms/Label';

interface FormInputProps {
  label: string;
  value: string;
  onChange: (value: string) => void;
}

const FormInput: React.FC<forminputprops> = ({ label, value, onChange }) => (
  <div classname="form-input">
    <label text="{label}"></label>
    <input value="{value}" onchange="{onChange}">
  </div>
);

export default FormInput;
</forminputprops>

유기체: Header.tsx

import React from 'react';
import NavLink from '../molecules/NavLink';
import Logo from '../atoms/Logo';

const Header: React.FC = () => (
  <header classname="header">
    <logo></logo>
    <nav>
      <navlink href="/" label="Home"></navlink>
      <navlink href="/about" label="About"></navlink>
      <navlink href="/contact" label="Contact"></navlink>
    </nav>
  </header>
);

export default Header;

2. 기능 기반 구조

기능이나 모듈별로 구성 요소를 분리하는 구조는 기능이 풍부한 프로젝트에서 널리 사용됩니다. 기능을 효율적으로 관리하고 확장하는 데 도움이 됩니다

src/
└── components/
    ├── authentication/    # Components related to authentication
    │   ├── Login.tsx
    │   ├── Signup.tsx
    │   └── PasswordReset.tsx
    │
    ├── dashboard/         # Components specific to the dashboard
    │   ├── DashboardHeader.tsx
    │   ├── DashboardSidebar.tsx
    │   └── StatsCard.tsx
    │
    ├── userProfile/       # Components for user profile
    │   ├── ProfileHeader.tsx
    │   ├── EditProfileForm.tsx
    │   └── Avatar.tsx
    │
    ├── shared/            # Shared or common components across features
    │   ├── Button.tsx
    │   ├── Modal.tsx
    │   └── ...            # Additional shared components
    │
    └── layout/            # Layout components
        ├── Header.tsx
        ├── Footer.tsx
        └── Sidebar.tsx

예:

인증: Login.tsx

import React, { useState } from 'react';
import Button from '../shared/Button';
import FormInput from '../shared/FormInput';

const Login: React.FC = () => {
  const [email, setEmail] = useState('');
  const [password, setPassword] = useState('');

  const handleLogin = () => {
    // Logic for login
  };

  return (
    <div classname="login">
      <h2 id="Login">Login</h2>
      <forminput label="Email" value="{email}" onchange="{setEmail}"></forminput>
      <forminput label="Password" value="{password}" onchange="{setPassword}"></forminput>
      <button label="Login" onclick="{handleLogin}"></button>
    </div>
  );
};

export default Login;

대시보드: StatsCard.tsx

import React from 'react';

interface StatsCardProps {
  title: string;
  value: number;
  icon: React.ReactNode;
}

const StatsCard: React.FC<statscardprops> = ({ title, value, icon }) => (
  <div classname="stats-card">
    <div classname="stats-card-icon">{icon}</div>
    <div classname="stats-card-info">
      <h3 id="title">{title}</h3>
      <p>{value}</p>
    </div>
  </div>
);

export default StatsCard;
</statscardprops>

3. 도메인 중심 구조

이 구조는 프로젝트의 도메인이나 제한된 컨텍스트에 따라 구성 요소를 구성하는 데 중점을 둡니다. 따라서 이 구조는 명확한 도메인 분리가 필요한 복잡한 시스템에 적합합니다

src/
└── components/
    ├── domain/
    │   ├── product/       # Components related to product domain
    │   │   ├── ProductCard.tsx
    │   │   ├── ProductList.tsx
    │   │   └── ProductDetail.tsx
    │   │
    │   ├── cart/          # Components for cart domain
    │   │   ├── CartItem.tsx
    │   │   ├── CartSummary.tsx
    │   │   └── CartIcon.tsx
    │   │
    │   ├── user/          # Components for user domain
    │   │   ├── UserAvatar.tsx
    │   │   ├── UserProfile.tsx
    │   │   └── UserSettings.tsx
    │   │
    │   └── ...            # Additional domain-specific components
    │
    ├── ui/                # UI elements (atoms, molecules, etc.)
    │   ├── atoms/         
    │   ├── molecules/     
    │   └── organisms/     
    │
    └── layout/            # Layout components
        ├── Header.tsx
        ├── Footer.tsx
        └── Sidebar.tsx

예:

제품: ProductCard.tsx

import React from 'react';

interface ProductCardProps {
  name: string;
  price: number;
  imageUrl: string;
  onAddToCart: () => void;
}

const ProductCard: React.FC<productcardprops> = ({ name, price, imageUrl, onAddToCart }) => (
  <div classname="product-card">
    <img src="%7BimageUrl%7D" alt="{name}" classname="product-card-image">
    <div classname="product-card-info">
      <h3 id="name">{name}</h3>
      <p>${price.toFixed(2)}</p>
      <button onclick="{onAddToCart}">Add to Cart</button>
    </div>
  </div>
);

export default ProductCard;
</productcardprops>

카트: CartSummary.tsx

import React from 'react';

interface CartSummaryProps {
  totalItems: number;
  totalPrice: number;
}

const CartSummary: React.FC<cartsummary props> = ({ totalItems, totalPrice }) => (
  <div classname="cart-summary">
    <h3 id="Cart-Summary">Cart Summary</h3>
    <p>Total Items: {totalItems}</p>
    <p>Total Price: ${totalPrice.toFixed(2)}</p>
    <button>Checkout</button>
  </div>
);

export default CartSummary;
</cartsummary>

4. 스토리북을 활용한 CDD(컴포넌트 중심 개발)

이 구조는 크로스 플랫폼 개발을 지원하도록 설계되었습니다. 컴포넌트 중심 개발(CDD) 메인 애플리케이션과 별도의 형식으로 컴포넌트를 개발하고 테스트할 수 있는 스토리북을 사용

src/
└── components/
    ├── Button/
    │   ├── Button.tsx      # Component implementation
    │   ├── Button.stories.tsx # Storybook stories
    │   ├── Button.test.tsx # Unit tests
    │   └── Button.module.css # Component-specific styles
    │
    ├── Input/
    │   ├── Input.tsx
    │   ├── Input.stories.tsx
    │   ├── Input.test.tsx
    │   └── Input.module.css
    │
    ├── Modal/
    │   ├── Modal.tsx
    │   ├── Modal.stories.tsx
    │   ├── Modal.test.tsx
    │   └── Modal.module.css
    │
    └── ...                # Additional component folders

예:

버튼: Button.tsx

import React from 'react';
import styles from './Button.module.css';

interface ButtonProps {
  label: string;
  onClick: () => void;
  variant?: 'primary' | 'secondary';
}

const Button: React.FC<buttonprops> = ({ label, onClick, variant = 'primary' }) => (
  <button classname="{`${styles.btn}" onclick="{onClick}">
    {label}
  </button>
);

export default Button;
</buttonprops>

버튼: Button.stories.tsx (스토리북)

import React from 'react';
import { Meta, Story } from '@storybook/react';
import Button, { ButtonProps } from './Button';

export default {
  title: 'Components/Button',
  component: Button,
} as Meta;

const Template: Story<buttonprops> = (args) => <button></button>;

export const Primary = Template.bind({});
Primary.args = {
  label: 'Primary Button',
  onClick: () => console.log('Primary Button Clicked'),
  variant: 'primary',
};

export const Secondary = Template.bind({});
Secondary.args = {
  label: 'Secondary Button',
  onClick: () => console.log('Secondary Button Clicked'),
  variant: 'secondary',
};
</buttonprops>

5. 공유 구성요소 라이브러리

여러 팀이 함께 작업하는 프로젝트에서 공통 구성 요소를 사용하는 구조를 만드는 것이 중요합니다. 이 구조는 프로젝트 전반에 걸쳐 재사용할 수 있는 구성 요소를 분리하는 것을 강조합니다

src/
└── components/
    ├── shared/            # Shared components across the application
    │   ├── Button/
    │   │   ├── Button.tsx
    │   │   └── Button.module.css
    │   │
    │   ├── Modal/
    │   │   ├── Modal.tsx
    │   │   └── Modal.module.css
    │   │
    │   └── ...            # Additional shared components
    │
    ├── featureSpecific/   # Feature-specific components
    │   ├── UserProfile/
    │   │   ├── ProfileHeader.tsx
    │   │   ├── ProfileDetails.tsx
    │   │   └── Avatar.tsx
    │   │
    │   ├── ProductList/
    │   │   ├── ProductCard.tsx
    │   │   └── ProductFilter.tsx
    │   │
    │   └── ...            # Additional feature-specific components
    │
    └── layout/            # Layout components
        ├── Header.tsx
        ├── Footer.tsx
        └── Sidebar.tsx

ตัวอย่าง:

Shared: Modal.tsx

import React from 'react';
import styles from './Modal.module.css';

interface ModalProps {
  title: string;
  isOpen: boolean;
  onClose: () => void;
}

const Modal: React.FC<modalprops> = ({ title, isOpen, onClose, children }) => {
  if (!isOpen) return null;

  return (
    <div classname="{styles.modalOverlay}">
      <div classname="{styles.modal}">
        <h2 id="title">{title}</h2>
        <button classname="{styles.closeButton}" onclick="{onClose}">
          ×
        </button>
        <div classname="{styles.modalContent}">{children}</div>
      </div>
    </div>
  );
};

export default Modal;
</modalprops>

Feature-Specific: ProfileHeader.tsx

import React from 'react';

interface ProfileHeaderProps {
  name: string;
  bio: string;
  avatarUrl: string;
}

const ProfileHeader: React.FC<profileheaderprops> = ({ name, bio, avatarUrl }) => (
  <div classname="profile-header">
    <img src="%7BavatarUrl%7D" alt="{name}" classname="profile-avatar">
    <h1 id="name">{name}</h1>
    <p>{bio}</p>
  </div>
);

export default ProfileHeader;
</profileheaderprops>

Factors to Consider When Structuring Components

1. Reusability: ควรแยก component ที่สามารถใช้ซ้ำได้ออกจาก component ที่เฉพาะเจาะจงกับฟีเจอร์
2. Maintainability: การจัดโครงสร้างที่ดีช่วยให้การดูแลรักษาและการอัพเดตโปรเจคเป็นไปอย่างราบรื่น
3. Scalability: โครงสร้างที่ดีจะช่วยให้การขยายฟีเจอร์และการเพิ่ม component ใหม่ ๆ เป็นเรื่องง่าย
4. Performance: ใช้เทคนิคที่เหมาะสมในการโหลดและใช้ component เพื่อให้แน่ใจว่าแอปพลิเคชันของคุณมีประสิทธิภาพ

Best Practices for Component Structure

• Single Responsibility Principle: แต่ละ component ควรทำหน้าที่เดียวและทำได้ดี
• Component Naming: ตั้งชื่อ component ให้สื่อความหมายและชัดเจน
• Component Composition: ใช้ composition แทน inheritance เมื่อสร้าง component ใหม่
• Use Prop Types or TypeScript: กำหนด prop types หรือใช้ TypeScript interfaces เพื่อเพิ่มความปลอดภัยในการใช้งาน
• Write Tests: เขียน unit tests สำหรับ component ทุกตัวเพื่อตรวจสอบการทำงาน

ด้วยข้อมูลและแนวทางเหล่านี้ หวังว่าคุณจะสามารถจัดโครงสร้างในโฟลเดอร์ components ของโปรเจคได้อย่างมีประสิทธิภาพและเหมาะสมกับความต้องการของโปรเจคของคุณ!

위 내용은 프런트엔드 프로젝트 구성요소 폴더 구성의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!