ویرگول
ورودثبت نام
Farhad Adeli
Farhad Adeliمهندس نرم‌افزار ارشد با ۱۶+ سال تجربه در فرانت‌اند، بک‌اند و سیستم‌های بلادرنگ؛ علاقه‌مند به معماری نرم‌افزار، WebRTC و یادگیری سریع با کمک AI.
Farhad Adeli
Farhad Adeli
خواندن ۶ دقیقه·۴ ماه پیش

کامپوننتهای قابل استفاده مجدد را خیلی زود نسازید

کامپوننتهای قابل استفاده مجدد یکی از جذابترین ایدهها در توسعه فرانتاند هستند.

در نگاه اول، کاملاً منطقی به نظر میرسند.

چرا یک UI را دو بار بنویسیم؟

چرا یک کامپوننت انعطافپذیر نسازیم و همهجا از آن استفاده نکنیم؟

چرا از همان ابتدا یک design system تمیز نسازیم؟

ایده خوبی است.

اما یک دام مهم دارد.

خیلی از تیمهای فرانتاند تلاش میکنند کامپوننتها را بیش از حد زود reusable کنند.

وقتی یک کامپوننت قبل از اینکه نیازمندیها واضح شوند reusable میشود، معمولاً از همان duplication سادهای که قرار بود حذف کند پیچیدهتر میشود.

Reusability هزینه دارد

یک کامپوننت reusable بهصورت خودکار بهتر از یک کامپوننت تکراری نیست.

کد reusable مسئولیت دارد.

باید چند use case مختلف را پشتیبانی کند.

باید propهای انعطافپذیر داشته باشد.

باید naming واضح داشته باشد.

باید مرزهای مشخص داشته باشد.

باید مستند شود.

باید طوری تغییر کند که همه جاهایی که به آن وابستهاند خراب نشوند.

یعنی reusable بودن هزینه دارد.

وقتی یک کامپوننت reusable میسازیم، فقط یک کامپوننت نمینویسیم.

در واقع داریم یک API میسازیم.

مثلاً:

<Button variant="primary" size="lg" loading disabled iconLeft={<PlusIcon />} fullWidth ={handleClick} > Create </Button>

این ممکن است برای یک button واقعی در design system کاملاً مناسب باشد.

اما برای یک دکمه مخصوص یک feature، این همه انعطافپذیری ممکن است غیرضروری باشد.

گاهی سادهترین نسخه بهتر است:

<button ={handleCreate}> Create order </button>

مشکل، کامپوننت reusable نیست.

مشکل این است که قبل از اینکه الگوی واقعی را بفهمیم abstraction میسازیم.

Duplication همیشه دشمن نیست

توسعهدهندهها معمولاً یاد گرفتهاند از duplication دوری کنند.

اصل DRY یا “Don’t Repeat Yourself” مفید است.

اما گاهی آن را خیلی زود اعمال میکنیم.

دو تکه کد ممکن است امروز شبیه هم باشند، اما فردا در مسیرهای متفاوتی تغییر کنند.

مثلاً دو کارت را تصور کنید:

ProductCard CustomerCard

در ابتدا هر دو ممکن است این موارد را داشته باشند:

title subtitle status actions

پس یک InfoCard عمومی میسازیم.

اما یک هفته بعد:

ProductCard به هشدار موجودی نیاز دارد. CustomerCard به risk label نیاز دارد. ProductCard به قوانین قیمتگذاری نیاز دارد. CustomerCard به منطق وضعیت حساب نیاز دارد.

حالا کامپوننت generic شروع میکند به بزرگ شدن:

<InfoCard title={title} subtitle={subtitle} status={status} showInventoryWarning={true} showRiskLabel={false} pricingMode="discounted" accountStatus={undefined} actions={actions} />

در این نقطه، کامپوننت reusable است، اما تمیز نیست.

زیادی میداند.

موارد نامرتبط زیادی را پشتیبانی میکند.

و هر نیازمندی جدید آن را بدتر میکند.

یک مقدار duplication ارزانتر بود.

شکل مشابه به معنی abstraction مشترک نیست

یکی از مهمترین درسها در معماری فرانتاند این است:

چیزهایی که شبیه هم هستند، همیشه یکی نیستند.

دو کامپوننت میتوانند UI مشابهی داشته باشند، اما معنی بیزینسی متفاوتی داشته باشند.

این تفاوت مهم است.

مثلاً:

OrderStatusBadge PaymentStatusBadge DeliveryStatusBadge UserStatusBadge

همه آنها ممکن است شبیه badgeهای کوچک باشند.

اما قوانینشان ممکن است کاملاً متفاوت باشد.

یکی ممکن است به وضعیت پرداخت وابسته باشد.

یکی دیگر به وضعیت ارسال.

یکی دیگر به permissionهای کاربر.

اگر خیلی زود همه را مجبور کنیم داخل یک StatusBadge عمومی قرار بگیرند، ممکن است کامپوننتی بسازیم که از نظر فنی reusable است، اما از نظر معنایی گیجکننده است.

سؤال بهتر این نیست:

آیا این کامپوننتها شبیه هم هستند؟

سؤال بهتر این است:

آیا این کامپوننتها به یک دلیل تغییر میکنند؟

اگر جواب نه است، احتمالاً نباید در یک abstraction مشترک قرار بگیرند.

Reusability زودهنگام API بد میسازد

هر کامپوننت reusable یک API ارائه میدهد.

در React، این API معمولاً همان props است.

هرچه کامپوننت انعطافپذیرتر شود، API آن بزرگتر میشود.

در ابتدا:

<Card title="Orders" />

بعد:

<Card title="Orders" subtitle="Last 30 days" actions={<ExportButton />} footer={<Pagination />} loading={isLoading} error={error} emptyState={<EmptyOrders />} variant="dashboard" collapsible defaultCollapsed={false} />

بخشی از اینها ممکن است کاملاً معتبر باشد.

اما سؤال این است:

آیا این کامپوننت هنوز ساده و قابل فهم است؟

یک کامپوننت reusable با propهای زیاد، درست استفاده کردن را سخت میکند.

توسعهدهندهها شروع میکنند به پرسیدن این سؤالها:

کدام propها با هم کار میکنند؟ کدام propها با هم conflict دارند؟ اگر loading و error هر دو true باشند چه میشود؟ آیا footer همراه emptyState قابل استفاده است؟ آیا variant فقط style را تغییر میدهد یا behavior را هم عوض میکند؟

کامپوننت تبدیل به یک framework کوچک میشود.

و frameworkهای کوچک نیاز به نگهداری دارند.

کامپوننتهای reusable میتوانند business logic را پنهان کنند

خطر دیگر این است که منطق مخصوص feature را داخل کامپوننتهای shared قرار دهیم.

مثلاً:

<DataTable type="orders" showPaymentStatus showRefundAction allowBulkCancel />

این ممکن است reusable به نظر برسد، اما حالا table درباره orders، payments، refunds و permissions میداند.

یعنی کامپوننت shared دیگر واقعاً shared نیست.

تبدیل شده به جایی مخلوط برای business logic.

رویکرد بهتر معمولاً این است:

Shared component: UI عمومی جدول Feature component: رفتار مخصوص سفارشها

مثلاً:

<DataTable columns={columns} rows={rows} />

و بعد داخل feature سفارشها:

<OrderTable />

کامپوننت shared فقط rendering عمومی را مدیریت میکند.

کامپوننت feature معنی بیزینسی را مدیریت میکند.

این جداسازی باعث میشود کامپوننت reusable تمیز بماند.

Reuse معمولاً باید بعد از تکرار بیاید

یک قانون عملی که دوست دارم:

اول duplicate کن. بعداً abstract کن.

نه برای همیشه.

نه بیدقت.

بلکه آگاهانه.

بار اولی که چیزی را میسازید، معمولاً هنوز الگوی واقعی را نمیدانید.

بار دوم، شباهتها را میبینید.

بار سوم، الگو واضحتر میشود.

به همین دلیل بعضی توسعهدهندهها از “rule of three” استفاده میکنند:

استفاده اول: مستقیم بساز استفاده دوم: duplication را تحمل کن استفاده سوم: به abstraction فکر کن

این به معنی آن نیست که همیشه باید دقیقاً منتظر سه نمونه بمانید.

اما یادآوری خوبی است:

قبل از پایدار شدن الگو abstraction نسازید.

هزینه abstraction اشتباه معمولاً بیشتر از هزینه duplication موقت است.

چه چیزی یک کامپوننت reusable خوب میسازد؟

یک کامپوننت reusable خوب معمولاً چند ویژگی دارد.

هدف واضحی دارد.

API کوچکی دارد.

زیادی درباره business logic نمیداند.

تست کردنش ساده است.

مستند کردنش ساده است.

بدون خواندن کل سورس کدش قابل استفاده است.

به یک دلیل اصلی تغییر میکند.

نمونههای خوب:

Button Input Modal Tooltip Dropdown Tabs Avatar DatePicker Toast

این کامپوننتها معمولاً رفتار عمومی UI را نمایش میدهند.

گزینههای خوبی برای shared یا design system هستند.

اما کامپوننتهایی مثل اینها متفاوتاند:

OrderSummaryCard ProductInventoryWarning CustomerRiskBadge PaymentAttemptTimeline AdminPermissionPanel

این اسمها معنی بیزینسی دارند.

ممکن است داخل یک feature reusable باشند.

اما احتمالاً نباید خیلی زود به فولدر shared عمومی منتقل شوند.

فولدر Shared نباید تبدیل به سطل زباله شود

خیلی از پروژهها فولدرهایی شبیه این دارند:

src/shared src/components src/common

این فولدرها میتوانند مفید باشند.

اما میتوانند خطرناک هم باشند.

وقتی توسعهدهندهها نمیدانند چیزی کجا باید قرار بگیرد، آن را داخل shared میگذارند.

به مرور، shared تبدیل میشود به سطل زباله همهچیز:

UI عمومی UI مخصوص feature business logic formatterها API helperها permission logic کامپوننتهای قدیمی و استفادهنشده

بعد دیگر کسی نمیداند چه چیزی واقعاً reusable است.

قانون بهتر:

کد را داخل feature نگه دارید تا وقتی ثابت کند واقعاً باید shared شود.

کد shared باید ارتقا داده شود.

نه اینکه از اول shared فرض شود.

Reusability باید از ownership پیروی کند

قبل از انتقال یک کامپوننت به shared، بپرسید:

مالک این کامپوننت کیست؟

اگر فقط feature سفارشها از آن استفاده میکند، داخل orders نگهش دارید.

اگر فقط feature پرداختها از آن استفاده میکند، داخل payments نگهش دارید.

اگر چند feature غیرمرتبط از آن استفاده میکنند، شاید جای آن در shared باشد.

مثلاً:

features/orders/components/OrderStatusBadge features/payments/components/PaymentStatusBadge shared/components/Badge

در این ساختار:

Badge = building block بصری عمومی OrderStatusBadge = معنی مخصوص سفارش PaymentStatusBadge = معنی مخصوص پرداخت

این ساختار به شما reuse میدهد، بدون اینکه business logic را قاطی کند.

چکلیست مفید قبل از reusable کردن یک کامپوننت

قبل از ساختن یک کامپوننت reusable، بپرسید:

۱. آیا حداقل دو یا سه use case واقعی وجود دارد؟ ۲. آیا این use caseها به یک دلیل تغییر میکنند؟ ۳. آیا معنی بیزینسی آنها یکی است؟ ۴. آیا API میتواند کوچک بماند؟ ۵. آیا این کار complexity را کم میکند یا فقط پنهانش میکند؟ ۶. آیا تغییرات آینده سادهتر میشود یا سختتر؟ ۷. آیا این واقعاً shared است یا فقط از نظر ظاهری شبیه است؟ ۸. آیا business logic بیرون از کامپوننت shared میماند؟ ۹. آیا duplication فعلاً ارزانتر است؟ ۱۰. مالک این کامپوننت کیست؟

اگر جوابها واضح نیستند، احتمالاً برای abstraction زود است.

قانون سرانگشتی من

کامپوننت reusable را فقط به خاطر reuse احتمالی آینده نسازید.

کامپوننت reusable را وقتی بسازید که reuse واقعاً ظاهر شده باشد.

ساده شروع کنید.

کد مخصوص feature را داخل همان feature نگه دارید.

اجازه دهید الگو کمی تکرار شود.

بعد بخشهای پایدار را استخراج کنید.

مقدار کمی duplication همیشه بد نیست.

اما یک abstraction بد میتواند هر تغییر آینده را کند کند.

کامپوننتهای reusable قدرتمند هستند.

اما زمانبندی مهم است.

هدف این نیست که از reusability فرار کنیم.

هدف این است که از reusability زودهنگام فرار کنیم.

معماری خوب فرانتاند به این معنی نیست که همهچیز reusable باشد.

یعنی بدانیم چه چیزی باید reusable باشد، چه چیزی باید specific بماند، و چه زمانی الگو به اندازه کافی بالغ شده که استخراج شود.

گاهی بهترین کامپوننت، انعطافپذیرترین کامپوننت نیست.

بهترین کامپوننت، کامپوننتی است که مسئله فعلی را واضح حل میکند.

software engineeringsoftware developmentsoftware architecturefrontend developmentweb development
۰
۱
Farhad Adeli
Farhad Adeli
مهندس نرم‌افزار ارشد با ۱۶+ سال تجربه در فرانت‌اند، بک‌اند و سیستم‌های بلادرنگ؛ علاقه‌مند به معماری نرم‌افزار، WebRTC و یادگیری سریع با کمک AI.
شاید از این پست‌ها خوشتان بیاید