آموزشری‌اکت

درس ۳ از ۳۴، برنامه‌نویسی و علوم کامپیوتر، حدود ۳۱ دقیقه خواندن

فکر کردن به سبک ری‌اکت

جواب کوتاه

سند رسمی ری‌اکت می‌گه برای ساختن یه رابط کاربری با ری‌اکت، معمولا پنج قدم رو می‌رید. یک، صفحه رو به کامپوننت‌ها بشکنید: دور هر تیکه کادر بکشید، اسمش رو بذارید، و درختشون رو بسازید. دو، یه نسخه‌ی ثابت بسازید که داده رو فقط با props از بالا به پایین می‌ده، بی هیچ حالتی. سه، کمترین و کامل‌ترین حالت لازم رو پیدا کنید؛ هر چی ثابته، از props میاد یا می‌شه حسابش کرد، حالت نیست. چهار، برای هر حالت، نزدیک‌ترین کامپوننت پدر مشترک همه‌ی کامپوننت‌هایی که بهش نیاز دارن رو پیدا کنید و حالت رو اونجا بذارید. پنج، جریان داده‌ی برعکس رو اضافه کنید: تابع عوض کردن حالت رو به کامپوننت‌های پایین بدید تا با ورودی کاربر، حالت بالا رو عوض کنن.

نجار، پیش از اره

یه نجار خوب، پیش از اینکه اره به چوب بزنه، کل میز رو روی کاغذ می‌کشه: پایه‌ها، صفحه، کشوها، و اینکه هر تیکه کجا به کدوم وصل می‌شه. اگه بی نقشه شروع کنه، وسط کار می‌فهمه کشو توی میز جا نمی‌شه، و چوبی که بریده، دیگه برنمی‌گرده.

ری‌اکت هم یه طرز فکر داره که پیش از نوشتن کد، صفحه رو مثل یه نقشه می‌بینه. سند رسمی ری‌اکت یه صفحه‌ی کامل درباره‌ش داره، به اسم «فکر کردن به سبک ری‌اکت»، که می‌گه ری‌اکت می‌تونه طرز فکرتون درباره‌ی طرح‌ها و اپ‌ها رو عوض کنه. توی درس قبل دیدیم ری‌اکت چیه؛ این درس، این طرز فکر رو قدم‌به‌قدم باز می‌کنه.

پنج قدم

طبق سند رسمی، برای ساختن یه رابط کاربری با ری‌اکت، معمولا همین پنج قدم رو می‌رید:

  1. صفحه رو به یه درخت از کامپوننت‌ها بشکنید.
  2. یه نسخه‌ی ثابت توی ری‌اکت بسازید.
  3. کمترین ولی کامل‌ترین شکل حالت رابط کاربری رو پیدا کنید.
  4. پیدا کنید حالت باید کجا زندگی کنه.
  5. جریان داده‌ی برعکس رو اضافه کنید.

هر قدم، روی قدم قبلی ساخته می‌شه؛ و این ترتیب، جلوی خیلی از اشتباه‌های رایج رو می‌گیره.

مثالی که دنبالش می‌کنیم

سند رسمی، این پنج قدم رو روی یه مثال واقعی نشون می‌ده، و ما هم همون رو دنبال می‌کنیم: یه جدول محصول قابل جستجو. فرض کنید یه فروشگاه میوه و سبزی دارید، و یه طراح، طرح صفحه‌ش رو بهتون داده؛ و یه سرور هم هست که فهرست محصول‌ها رو می‌ده.

کاربر باید بتونه توی یه کادر، اسم محصول رو جستجو کنه؛ یه گزینه رو تیک بزنه که فقط محصول‌های موجود رو ببینه؛ و یه جدول، محصول‌ها رو، دسته به دسته، با اسم و قیمت نشون بده. ساده‌ست، ولی همه‌ی ایده‌های اصلی ری‌اکت توشه.

داده‌ای که از سرور میاد

طبق مثال سند رسمی، سرور یه فهرست برمی‌گردونه که هر ردیفش چهار چیز داره: دسته، مثل میوه یا سبزی؛ قیمت؛ اینکه موجوده یا نه؛ و اسم محصول، مثل سیب یا اسفناج. مثلا یه ردیف می‌گه: دسته‌ی میوه، قیمت یه دلار، موجود، اسمش سیب.

به این شکل داده، که از سرور میاد و صفحه از روش ساخته می‌شه، مدل داده (Data Model) می‌گن. نگه داشتن شکل این داده جلوی چشم، همون قدم اوله؛ چون سند رسمی می‌گه رابط کاربری و مدل داده، معمولا یه شکل دارن.

طرح صفحه

طرح صفحه، یعنی تصویری که طراح کشیده، از بالا به پایین این‌هاست: یه کادر جستجو؛ زیرش یه گزینه‌ی تیک‌زدنی با متن «فقط محصول‌های موجود»؛ و زیرش یه جدول با دو ستون، اسم و قیمت، که محصول‌ها رو گروه‌گروه، زیر عنوان هر دسته، نشون می‌ده.

محصول‌هایی که موجود نیستن، توی طرح با رنگ دیگه‌ای نشون داده می‌شن. این طرح، هنوز هیچ کدی نیست؛ فقط یه تصویره. کار ما اینه که این تصویر رو، با پنج قدم، به یه صفحه‌ی کارکن تبدیل کنیم.

قدم ۱: شکستن صفحه به کامپوننت

سند رسمی می‌گه اولین کار اینه که دور هر کامپوننت و زیرکامپوننت، توی طرح صفحه، کادر بکشید و اسمش رو بذارید. همون سند یه نکته‌ی کاربردی هم می‌گه: اگه با یه طراح کار می‌کنید، شاید اون، توی ابزار طراحیش، این تیکه‌ها رو از قبل اسم‌گذاری کرده باشه؛ ازش بپرسید.

این قدم، روی کاغذ یا روی یه عکس از طرح انجام می‌شه؛ هنوز هیچ کدی نیست. ولی مهم‌ترین قدمه؛ چون هر چی اینجا درست تقسیم بشه، بقیه‌ی کار ساده‌تر می‌شه.

از کجا بفهمیم کجا رو جدا کنیم

سند رسمی می‌گه بسته به پیش‌زمینه‌تون، می‌تونید به سه شکل به تقسیم صفحه فکر کنید:

  • برنامه‌نویسی: همون روشی که برای تصمیم ساختن یه تابع تازه به کار می‌برید. یکیش جداسازی نگرانی‌هاست (Separation of Concerns): هر کامپوننت، بهتره فقط یه کار بکنه؛ اگه بزرگ شد، به تیکه‌های کوچیک‌تر شکسته بشه.
  • سی‌اس‌اس: به اینکه برای چه چیزهایی کلاس جدا می‌ساختید فکر کنید؛ هرچند کامپوننت‌ها کمی درشت‌ترن.
  • طراحی: به اینکه لایه‌های طرح رو چطور مرتب می‌کردید فکر کنید.

هر سه راه، معمولا به یه جواب نزدیک می‌رسن؛ هر کدوم که براتون آشناتره رو انتخاب کنید.

شکل داده، شکل صفحه

سند رسمی یه نکته‌ی هوشمندانه داره: اگه داده‌تون خوب ساختار داشته باشه، معمولا می‌بینید که به‌طور طبیعی، به ساختار کامپوننت‌های رابط کاربری می‌خوره. دلیلش اینه که رابط کاربری و مدل داده، معمولا یه معماری اطلاعات دارن؛ یعنی یه شکل.

پس صفحه رو طوری به کامپوننت بشکنید که هر کامپوننت، به یه تیکه از مدل داده بخوره. توی مثال ما: هر ردیف داده، یه ردیف جدول می‌شه؛ هر دسته، یه عنوان دسته؛ و کل فهرست، کل جدول. این‌طوری، کد صفحه آیینه‌ی داده می‌شه.

پنج کامپوننت این صفحه

طبق سند رسمی، این صفحه پنج کامپوننت داره:

  • FilterableProductTable: کل اپ رو در بر داره.
  • SearchBar: ورودی کاربر رو می‌گیره؛ کادر جستجو و گزینه‌ی تیک‌زدنی.
  • ProductTable: فهرست رو، بر اساس ورودی کاربر، فیلتر می‌کنه و نشون می‌ده.
  • ProductCategoryRow: برای هر دسته، یه عنوان نشون می‌ده.
  • ProductRow: برای هر محصول، یه ردیف نشون می‌ده.

اسم‌ها انگلیسی‌ان، چون توی کد نوشته می‌شن؛ و هر اسم، دقیقا می‌گه اون کامپوننت چی کار می‌کنه.

چیدن درخت

حالا که کامپوننت‌ها پیدا شدن، سند رسمی می‌گه اون‌ها رو به شکل یه درخت بچینید: کامپوننت‌هایی که توی طرح، داخل یه کامپوننت دیگه‌ان، توی درخت، فرزند اون می‌شن. FilterableProductTable بالای همه؛ زیرش SearchBar و ProductTable؛ و زیر ProductTable، دو کامپوننت ProductCategoryRow و ProductRow.

این درخت، نقشه‌ی کل اپه. هر وقت گیج شدید که یه داده باید کجا باشه یا یه تابع از کجا به کجا بره، به همین درخت برگردید. برنامه‌نویس‌های باتجربه، برای صفحه‌های بزرگ، این درخت رو حتی روی کاغذ می‌کشن.

قدم ۲: نسخه‌ی ثابت

طبق سند رسمی، ساده‌ترین راه اینه که اول یه نسخه بسازید که رابط کاربری رو از روی مدل داده نشون بده، ولی هیچ تعاملی نداشته باشه. کادر جستجو هست، ولی کار نمی‌کنه؛ گزینه‌ی تیک‌زدنی هست، ولی هیچی رو عوض نمی‌کنه؛ جدول، همه‌ی محصول‌ها رو نشون می‌ده.

همون سند دلیلش رو هم می‌گه: معمولا ساختن اول نسخه‌ی ثابت و اضافه کردن تعامل بعدش، ساده‌تره. چون ساختن نسخه‌ی ثابت، تایپ زیاد و فکر کم لازم داره؛ ولی اضافه کردن تعامل، فکر زیاد و تایپ کم. جدا کردن این دو، هر کدوم رو ساده‌تر می‌کنه.

دادن داده با props

برای ساختن نسخه‌ی ثابت، سند رسمی می‌گه کامپوننت‌هایی بسازید که از کامپوننت‌های دیگه استفاده می‌کنن، و داده رو با props بهشون می‌دن. props، راهیه برای دادن داده از پدر به فرزند؛ مثلا FilterableProductTable، فهرست محصول‌ها رو به ProductTable می‌ده، و ProductTable، هر محصول رو به یه ProductRow.

کامپوننت بالای درخت، یعنی FilterableProductTable، کل مدل داده رو به‌عنوان یه prop می‌گیره. بقیه، هر کدوم فقط تیکه‌ای که لازم دارن رو از پدرشون می‌گیرن. ایستگاه دوم این مسیر، props رو کامل، با نوع تایپ‌اسکریپتی، یاد می‌ده.

از بالا یا از پایین

سند رسمی می‌گه برای ساختن کامپوننت‌ها، دو راه دارید: «بالا به پایین»، یعنی از کامپوننت‌های بالای درخت، مثل FilterableProductTable، شروع کنید؛ یا «پایین به بالا»، یعنی از کامپوننت‌های پایین، مثل ProductRow.

و توصیه‌ش اینه: توی مثال‌های ساده‌تر، معمولا رفتن از بالا به پایین راحت‌تره؛ توی پروژه‌های بزرگ‌تر، از پایین به بالا. دلیلش اینه که توی پروژه‌ی بزرگ، اول تیکه‌های کوچیک رو می‌سازید و جدا امتحان می‌کنید، و بعد، با اطمینان، کنار هم می‌ذاریدشون.

جریان یه‌طرفه‌ی داده

طبق سند رسمی، بعد از ساختن کامپوننت‌ها، یه کتابخونه از کامپوننت‌های قابل استفاده‌ی دوباره دارید که مدل داده رو نشون می‌دن. و چون این یه اپ ثابته، کامپوننت‌ها فقط JSX برمی‌گردونن. همون سند، به این حرکت داده، جریان یه‌طرفه‌ی داده (One-Way Data Flow) می‌گه؛ چون داده، از کامپوننت بالا، به سمت پایین درخت جریان پیدا می‌کنه.

مثل آب که از بالای کوه به پایین می‌ره و هیچ‌وقت برعکس نمی‌ره. این قاعده، ری‌اکت رو قابل پیش‌بینی می‌کنه: اگه یه چیزی روی صفحه اشتباهه، کافیه از پایین درخت، رو به بالا برید، تا ببینید داده از کجا اومده.

هشدار: هنوز هیچ حالتی نه

سند رسمی، توی این قدم یه هشدار صریح داره: الان نباید هیچ مقدار حالتی به کار ببرید؛ اون مال قدم بعدیه. همون سند توضیح می‌ده که حالت، فقط برای تعامله؛ یعنی داده‌ای که با گذشت زمان عوض می‌شه. و چون این، یه نسخه‌ی ثابته، لازمش ندارید.

این هشدار، یکی از رایج‌ترین اشتباه‌های تازه‌کارها رو نشونه می‌گیره: گذاشتن حالت همه‌جا، از همون اول، «برای احتیاط». این کار، کد رو پیچیده می‌کنه و باعث می‌شه یه داده، چند جا نگه داشته بشه و ناجور بشه. اول بی حالت؛ بعد، فقط هر جا لازمه.

قدم ۳: کمترین حالت لازم

برای اینکه رابط کاربری تعاملی بشه، کاربر باید بتونه داده رو عوض کنه؛ و طبق سند رسمی، برای این کار از حالت استفاده می‌کنید. همون سند می‌گه به حالت، به‌عنوان کمترین مجموعه‌ی داده‌ی در حال تغییر که اپ باید یادش بمونه، فکر کنید.

کلمه‌ی مهم، «کمترین» ـه. هدف اینه که حداقل حالت ممکن رو پیدا کنید، و همه‌ی چیزهای دیگه رو، هر وقت لازم شد، از روی همون حساب کنید. چرا؟ چون هر حالت اضافه، یه جای دیگه‌ست که ممکنه با بقیه ناجور بشه.

تکرار نکن (DRY)

سند رسمی، مهم‌ترین اصل ساختن حالت رو این می‌دونه: تکرار نکن، یا به انگلیسی DRY، کوتاه‌شده‌ی Don't Repeat Yourself. مثال خود سند: اگه یه فهرست خرید می‌سازید، اقلام رو به شکل یه آرایه توی حالت نگه دارید؛ و اگه خواستید شمار اقلام رو هم نشون بدید، اون رو جدا توی حالت نذارید؛ طول همون آرایه رو بخونید.

اگه شمار رو جدا نگه دارید، هر بار که یه قلم اضافه یا کم می‌شه، باید یادتون باشه شمار رو هم عوض کنید؛ و یه روز، یادتون می‌ره. ولی اگه شمار همیشه از روی آرایه حساب بشه، هیچ‌وقت نمی‌تونه اشتباه باشه.

سه سوال برای پیدا کردن حالت

سند رسمی، برای اینکه بفهمید یه تیکه داده حالته یا نه، سه سوال می‌پرسه:

  1. با گذشت زمان، ثابت می‌مونه؟ اگه آره، حالت نیست.
  2. از پدر، با props میاد؟ اگه آره، حالت نیست.
  3. می‌شه از روی حالت یا props موجود حسابش کرد؟ اگه آره، قطعا حالت نیست.

طبق همون سند، چیزی که بعد از این سه سوال باقی می‌مونه، احتمالا حالته.

چهار تیکه داده‌ی این مثال

سند رسمی، این سه سوال رو روی چهار تیکه داده‌ی مثال می‌پرسه. فهرست اصلی محصول‌ها، با props میاد؛ پس حالت نیست. متن جستجو، با زمان عوض می‌شه و از چیز دیگه‌ای حساب نمی‌شه؛ پس حالته. مقدار گزینه‌ی تیک‌زدنی هم، به همین دلیل، حالته.

و فهرست فیلترشده؟ می‌شه از روی فهرست اصلی، متن جستجو و مقدار گزینه، حسابش کرد؛ پس حالت نیست. یعنی کل این صفحه، فقط دو حالت داره: متن جستجو و مقدار گزینه. شاید عجیب باشه که یه صفحه‌ی کامل با دو تیکه حافظه کار کنه؛ ولی این، دقیقا همون «کمترین» ـه.

props و حالت، چه فرقی دارن

سند رسمی، این فرق رو خیلی روشن می‌گه. props، مثل آرگومان‌هایی‌ان که به یه تابع می‌دید؛ اجازه می‌دن پدر، به فرزند داده بده و ظاهرش رو تنظیم کنه. مثلا یه فرم، رنگ رو به یه دکمه می‌ده. حالت، مثل حافظه‌ی کامپوننته؛ اجازه می‌ده یه کامپوننت چیزی رو یادش بمونه و با تعامل، عوضش کنه.

همون سند می‌گه این دو با هم کار می‌کنن: یه پدر، معمولا یه چیزی رو توی حالت خودش نگه می‌داره، تا بتونه عوضش کنه، و اون رو به فرزندها، به شکل props، می‌ده. و با مهربونی اضافه می‌کنه: اشکالی نداره اگه بار اول، این فرق هنوز مبهم به نظر بیاد؛ کمی تمرین لازمه تا جا بیفته.

قدم ۴: حالت کجا زندگی کنه

حالا که کمترین حالت رو پیدا کردید، سند رسمی می‌گه باید بفهمید کدوم کامپوننت، صاحب این حالته؛ یعنی مسئول عوض کردنش. و یادآوری می‌کنه که ری‌اکت، جریان یه‌طرفه‌ی داده داره؛ داده از پدر به فرزند می‌ره، رو به پایین درخت.

همون سند صادقانه می‌گه شاید بلافاصله روشن نباشه کدوم کامپوننت باید صاحب کدوم حالت باشه؛ و این، برای کسی که تازه با این مفهوم آشنا شده، چالشیه. ولی یه روش قدم‌به‌قدم داره، که بخش بعدی می‌گه.

روش پیدا کردن جای حالت

سند رسمی، برای هر تیکه حالت، این روش رو پیشنهاد می‌کنه:

  1. همه‌ی کامپوننت‌هایی که چیزی رو بر اساس اون حالت نشون می‌دن، پیدا کنید.
  2. نزدیک‌ترین پدر مشترکشون رو پیدا کنید؛ کامپوننتی که توی درخت، بالای همه‌شونه.
  3. تصمیم بگیرید: معمولا حالت رو مستقیم توی همون پدر مشترک بذارید.
  4. یا می‌تونید توی یه کامپوننت بالاتر از پدر مشترک بذاریدش.
  5. اگه هیچ کامپوننتی برای نگه داشتنش منطقی نبود، یه کامپوننت تازه، فقط برای نگه داشتن حالت، بسازید و بالای پدر مشترک بذارید.

به کار بردن روش روی مثال

سند رسمی، این روش رو روی دو حالت مثال، یعنی متن جستجو و مقدار گزینه، به کار می‌بره. چون این دو همیشه با هم میان، منطقیه یه جا باشن. کدوم کامپوننت‌ها ازشون استفاده می‌کنن؟ ProductTable، که باید فهرست رو بر اساسشون فیلتر کنه؛ و SearchBar، که باید نشونشون بده.

نزدیک‌ترین پدر مشترک این دو، FilterableProductTable ـه. پس طبق سند، دو حالت، یعنی filterText و inStockOnly، توی FilterableProductTable نگه داشته می‌شن، با useState؛ و به ProductTable و SearchBar، به شکل props، داده می‌شن.

یه امتحان کوچیک از خود سند

سند رسمی، اینجا یه آزمایش کوچیک پیشنهاد می‌کنه: توی جعبه‌ی کد قابل ویرایشش، مقدار اولیه‌ی متن جستجو رو از یه متن خالی، به fruit، یعنی میوه، عوض کنید. همون لحظه، هم کادر جستجو و هم جدول، به‌روز می‌شن؛ کادر، کلمه‌ی fruit رو نشون می‌ده، و جدول، فقط میوه‌ها رو.

این آزمایش، نشون می‌ده چطور یه حالت، از یه جا، دو کامپوننت جدا رو کنترل می‌کنه. ولی اگه بخواید توی کادر چیزی تایپ کنید، هنوز کار نمی‌کنه؛ که دلیلش، قدم پنجمه.

قدم ۵: جریان داده‌ی برعکس

تا اینجا، داده فقط از بالا به پایین می‌ره. ولی سند رسمی می‌گه برای عوض کردن حالت بر اساس ورودی کاربر، لازمه داده برعکس هم جریان پیدا کنه: کامپوننت‌های فرم، که پایین درختن، باید بتونن حالتی که توی FilterableProductTable، بالای درخت، هست رو عوض کنن.

اگه توی نسخه‌ی قدم چهارم، توی کادر تایپ کنید، سند رسمی می‌گه می‌بینید که ری‌اکت ورودی‌تون رو نادیده می‌گیره؛ و این عمدیه. چون گفتید مقدار کادر، همیشه برابر filterText باشه؛ و filterText، هیچ‌وقت عوض نمی‌شه.

دادن تابع تغییر به پایین

طبق سند رسمی، چون حالت مال FilterableProductTable ـه، فقط اون می‌تونه setFilterText و setInStockOnly رو صدا بزنه. پس برای اینکه SearchBar بتونه حالت رو عوض کنه، این دو تابع رو، به شکل props، به SearchBar می‌دید؛ مثلا با اسم‌های onFilterTextChange و onInStockOnlyChange.

بعد، توی SearchBar، به کادر و گزینه یه کنترل‌کننده‌ی onChange اضافه می‌کنید، که با هر تغییر، اون تابع‌ها رو با مقدار تازه صدا می‌زنه. حالا، طبق سند، اپ کامل کار می‌کنه: کاربر تایپ می‌کنه، حالت بالا عوض می‌شه، و ری‌اکت، هم کادر رو و هم جدول رو، از روی حالت تازه، دوباره می‌کشه.

چرا این‌قدر صریح

سند رسمی می‌گه ری‌اکت این جریان داده رو صریح می‌کنه؛ هرچند کمی تایپ بیشتری لازم داره، در مقایسه با روشی که بهش اتصال دوطرفه‌ی داده (Two-Way Data Binding) می‌گن، و بعضی ابزارهای دیگه دارن. توی اتصال دوطرفه، کادر و داده خودکار به هم وصلن؛ ولی توی ری‌اکت، شما صریح می‌نویسید کی و چطور داده عوض بشه.

فایده‌ی این صراحت اینه که هر تغییر داده، یه مسیر روشن داره، که می‌شه دنبالش کرد. توی یه صفحه با صدها کامپوننت، وقتی یه عدد اشتباهه، می‌دونید دقیقا کدوم تابع، از کدوم کامپوننت، عوضش کرده. این، همون پیش‌بینی‌پذیریه که ری‌اکت رو برای پروژه‌های بزرگ مناسب می‌کنه.

همین پنج قدم، برای هر صفحه‌ای

این پنج قدم، فقط برای جدول محصول نیست؛ برای هر صفحه‌ای کار می‌کنه. مثلا یه صفحه‌ی مخاطب‌ها توی گوشی: قدم یک، کادر جستجو، فهرست مخاطب و ردیف هر مخاطب؛ قدم دو، فهرست ثابت؛ قدم سه، حالت‌ها: متن جستجو، و شاید مخاطب انتخاب‌شده؛ قدم چهار، پدر مشترک؛ قدم پنج، وصل کردن کادر به حالت.

هر بار که با یه طرح تازه روبه‌رو شدید، این پنج قدم رو، حتی روی کاغذ، برید. اولش کند به نظر میاد؛ ولی بعد از چند صفحه، تقریبا خودکار می‌شه، و جلوی ساعت‌ها بازنویسی کد رو می‌گیره.

کار با طراح

همون‌طور که سند رسمی گفت، اگه با یه طراح کار می‌کنید، شاید اون، تیکه‌های طرح رو از قبل اسم‌گذاری کرده باشه. این، یه فرصت بزرگه: اگه اسم کامپوننت‌ها توی کد، با اسم تیکه‌ها توی طرح یکی باشه، حرف زدن تیم خیلی راحت‌تر می‌شه؛ وقتی طراح می‌گه «کارت محصول»، همه می‌دونن کدوم کامپوننت.

و برعکس: اگه شما برنامه‌نویسید و طراح هنوز طرح رو تقسیم نکرده، درخت کامپوننتی که توی قدم یک ساختید رو بهش نشون بدید. خیلی وقت‌ها، همین گفت‌وگو، جاهایی از طرح رو نشون می‌ده که تکراری‌ان و می‌شه یکیشون کرد.

این پنج قدم و تایپ‌اسکریپت

سند رسمی، این مثال رو با جاوااسکریپت نوشته؛ ولی توی این مسیر، با تایپ‌اسکریپت کار می‌کنیم. فرقش، توی قدم دو و چهار پیدا می‌شه: وقتی props یه کامپوننت رو می‌نویسید، نوعشون رو هم می‌نویسید؛ مثلا ProductRow یه محصول می‌گیره، با اسم متنی، قیمت متنی و موجودی درست و نادرست.

و توی قدم چهار، نوع حالت‌ها رو مشخص می‌کنید: filterText یه متنه، inStockOnly یه درست و نادرست. این نوع‌ها، باعث می‌شن اگه یه روز، یه prop رو یادتون بره به یه کامپوننت بدید، ویرایشگر همون لحظه بگه؛ پیش از اینکه صفحه خراب بشه.

جواب کوتاه

اگه کسی پرسید «فکر کردن به سبک ری‌اکت یعنی چی»:

یعنی پنج قدم: صفحه رو به درخت کامپوننت‌ها بشکنید؛ یه نسخه‌ی ثابت با props بسازید؛ کمترین حالت لازم رو پیدا کنید؛ حالت رو توی نزدیک‌ترین پدر مشترک بذارید؛ و تابع تغییر حالت رو به کامپوننت‌های پایین بدید تا ورودی کاربر، حالت رو عوض کنه.

چند باور رایج

  • «بهتره از اول همه‌جا حالت بذاریم.» اول نسخه‌ی ثابت، بی حالت.
  • «فهرست فیلترشده هم باید حالت باشه.» از روی حالت حساب می‌شه.
  • «props و حالت یه چیزن.» props ورودیه؛ حالت حافظه.
  • «فرزند می‌تونه مستقیم حالت پدر رو عوض کنه.» فقط با تابعی که پدر بهش داده.
  • «تقسیم صفحه یه جواب درست داره.» یه قضاوته؛ مثل سرستون جدول.

یه مثال

نگار، صفحه‌ی سفارش یه کافه رو با ری‌اکت می‌ساخت. اول، بی فکر، برای هر چیزی یه حالت گذاشت: فهرست سفارش، شمار اقلام، جمع قیمت، و اینکه دکمه‌ی پرداخت فعاله یا نه. بعد از دو روز، هر بار که یه چیز رو عوض می‌کرد، یکی از بقیه اشتباه می‌شد؛ مثلا جمع قیمت با فهرست جور نبود.

با سه سوال قدم سه، دید که شمار اقلام، جمع قیمت و فعال بودن دکمه، همه از روی فهرست سفارش حساب می‌شن. چهار حالت، یه حالت شد. کد نصف شد، و اون خطاهای عجیب، دیگه هیچ‌وقت تکرار نشدن؛ چون دیگه هیچ دو جایی نبود که بتونن با هم ناجور بشن.

تمرین امروز

امروز، پنج قدم رو روی کاغذ، روی یه صفحه‌ی واقعی برید.

  1. صفحه‌ی «سبد خرید» یه فروشگاه اینترنتی رو باز کنید و روی کاغذ بکشید.
  2. دور هر کامپوننت کادر بکشید، اسم انگلیسی بذارید و درختش رو بنویسید.
  3. همه‌ی تیکه‌های داده‌ی صفحه رو فهرست کنید؛ مثلا اقلام، شمار، جمع.
  4. با سه سوال سند رسمی، بفهمید کدوم‌ها واقعا حالتن.
  5. برای هر حالت، نزدیک‌ترین پدر مشترک رو روی درخت علامت بزنید.

درس بعدی، اولین پروژه‌ی ری‌اکت رو روی کامپیوترتون می‌سازه: ساختن اولین پروژه.

جمع‌بندی. آنچه از این درس با خودتان می‌برید.

  • قدم ۱: صفحه رو به درخت کامپوننت‌ها بشکنید.
  • قدم ۲: نسخه‌ی ثابت، فقط با props، بی حالت.
  • قدم ۳: کمترین حالت لازم؛ بقیه رو حساب کنید.
  • قدم ۴: حالت رو توی نزدیک‌ترین پدر مشترک بذارید.
  • قدم ۵: تابع تغییر رو پایین بدید تا ورودی کاربر، حالت رو عوض کنه.

خودتون رو بسنجید

۱۵ پرسش، هر بار تازه از میان ۳۰ پرسش این درس. آخرش فقط کارنامه رو می‌بینید: چند تا درست، چند تا نادرست.

خودتون رو بسنجید

۱۵ پرسش

  • هر بار پرسش‌ها و ترتیب گزینه‌ها عوض می‌شه.
  • تا آخر نمی‌گیم کدوم جواب درست بوده؛ می‌تونید برگردید و جوابتون رو عوض کنید.
  • آخرش کارنامه می‌گیرید: چند تا درست، چند تا نادرست.
  • اگه وسطش بستید، دوباره که باز کنید از همون‌جا ادامه می‌دید.

فصل‌های این درس

درس بعد