פיצול קוד באמצעות React.lazy ו-Suspense

לא צריך לשלוח למשתמשים יותר קוד מהנדרש, אז פצלו את החבילות כדי לוודא שזה לא יקרה.

השיטה React.lazy מאפשרת לפצל בקלות את הקוד של אפליקציית React ברמת הרכיב באמצעות ייבוא דינמי.

import React, { lazy } from 'react';

const AvatarComponent = lazy(() => import('./AvatarComponent'));

const DetailsComponent = () => (
  <div>
    <AvatarComponent />
  </div>
)

למה זה שימושי?

אפליקציית React גדולה בדרך כלל תכלול הרבה רכיבים, שיטות שירות וספריות של צד שלישי. אם לא מנסים לטעון חלקים שונים של אפליקציה רק כשהם נחוצים, חבילה אחת גדולה של JavaScript תישלח למשתמשים ברגע שהם יטענו את הדף הראשון. זה יכול להשפיע באופן משמעותי על הביצועים של הדף.

הפונקציה React.lazy מספקת דרך מובנית להפריד רכיבים באפליקציה לחלקים נפרדים של JavaScript, בלי הרבה מאמץ. אחר כך תוכלו לטפל במצבי טעינה כשתשלבו אותו עם הרכיב Suspense.

מתח

הבעיה בשליחת מטען ייעודי (payload) גדול של JavaScript למשתמשים היא משך הזמן שנדרש לדף כדי לסיים את הטעינה, במיוחד במכשירים ובחיבורים לרשת חלשים יותר. לכן פיצול קוד וטעינה מדורגת הם שימושיים מאוד.

עם זאת, תמיד יהיה עיכוב קל שהמשתמשים יחוו כשרכיב של פיצול קוד מאוחזר דרך הרשת, ולכן חשוב להציג מצב טעינה שימושי. שימוש ב-React.lazy עם הרכיב Suspense עוזר לפתור את הבעיה הזו.

import React, { lazy, Suspense } from 'react';

const AvatarComponent = lazy(() => import('./AvatarComponent'));

const renderLoader = () => <p>Loading</p>;

const DetailsComponent = () => (
  <Suspense fallback={renderLoader()}>
    <AvatarComponent />
  </Suspense>
)

‫Suspense מקבל רכיב fallback שמאפשר להציג כל רכיב React כמצב טעינה. הדוגמה הבאה ממחישה איך זה עובד. הדמות מוצגת רק כשלוחצים על הכפתור, ואז נשלחת בקשה לאחזור הקוד שנדרש לרכיב AvatarComponent המושהה. בינתיים, מוצג רכיב הטעינה החלופי.

כאן, הקוד שמרכיב את AvatarComponent הוא קטן, ולכן סמל הטעינה מוצג רק לזמן קצר. יכול להיות שרכיבים גדולים יותר ייטענו לאט יותר, במיוחד בחיבורים חלשים לרשת.

כדי להמחיש איך זה עובד:

  • כדי לראות תצוגה מקדימה של האתר, לוחצים על הצגת האפליקציה ואז על מסך מלא מסך מלא.
  • מקישים על `Control+Shift+J` (או על `Command+Option+J` ב-Mac) כדי לפתוח את כלי הפיתוח.
  • לוחצים על הכרטיסייה רשת.
  • לוחצים על התפריט הנפתח Throttling (ויסות נתונים), שמוגדר כברירת מחדל לאפשרות No throttling (ללא ויסות נתונים). בוחרים באפשרות Fast 3G.
  • לוחצים על הכפתור Click Me באפליקציה.

אינדיקטור הטעינה יופיע עכשיו למשך זמן רב יותר. שימו לב שכל הקוד שמרכיב את AvatarComponent מאוחזר כחלק נפרד.

חלונית הרשת של כלי הפיתוח, שבה מוצגת הורדה של קובץ chunk.js אחד

השעיה של כמה רכיבים

תכונה נוספת של Suspense היא שהיא מאפשרת להשהות את הטעינה של כמה רכיבים, גם אם כולם נטענים בטעינה מדורגת.

לדוגמה:

import React, { lazy, Suspense } from 'react';

const AvatarComponent = lazy(() => import('./AvatarComponent'));
const InfoComponent = lazy(() => import('./InfoComponent'));
const MoreInfoComponent = lazy(() => import('./MoreInfoComponent'));

const renderLoader = () => <p>Loading</p>;

const DetailsComponent = () => (
  <Suspense fallback={renderLoader()}>
    <AvatarComponent />
    <InfoComponent />
    <MoreInfoComponent />
  </Suspense>
)

זו דרך שימושית מאוד לעכב את העיבוד של כמה רכיבים, תוך הצגת מצב טעינה יחיד. אחרי שכל הרכיבים נטענים, המשתמש רואה את כולם בו-זמנית.

אפשר לראות את זה בהטמעה הבאה:

בלי זה, קל להיתקל בבעיה של טעינה מדורגת, או של חלקים שונים של ממשק משתמש שנטענים אחד אחרי השני, ולכל אחד מהם יש אינדיקטור טעינה משלו. זה עלול לפגוע בחוויית המשתמש.

מה עושים אם הטעינה נכשלת

‫Suspense מאפשר להציג מצב טעינה זמני בזמן שבקשות לאחזור מהרשת מתבצעות ברקע. אבל מה אם הבקשות האלה לאחזור מהרשת נכשלות מסיבה כלשהי? יכול להיות שאתם במצב אופליין, או שאפליקציית האינטרנט מנסה לבצע טעינה מדורגת של כתובת URL עם גרסה לא עדכנית, שכבר לא זמינה אחרי פריסה מחדש של השרת.

ב-React יש דפוס סטנדרטי לטיפול בכשלים מהסוג הזה בטעינה: שימוש בגבולות שגיאה. כפי שמתואר במסמכי התיעוד, כל רכיב React יכול לשמש כגבול שגיאה אם הוא מטמיע את אחת מהשיטות של מחזור החיים (או את שתיהן) static getDerivedStateFromError() או componentDidCatch().

כדי לזהות ולטפל בכשלים בטעינה מדורגת, אתם יכולים לעטוף את הרכיב Suspense ברכיב הורה שמשמש כגבול שגיאה. בתוך השיטה render() של גבול השגיאה, אפשר להציג את הצאצאים כמו שהם אם אין שגיאה, או להציג הודעת שגיאה בהתאמה אישית אם משהו משתבש:

import React, { lazy, Suspense } from 'react';

const AvatarComponent = lazy(() => import('./AvatarComponent'));
const InfoComponent = lazy(() => import('./InfoComponent'));
const MoreInfoComponent = lazy(() => import('./MoreInfoComponent'));

const renderLoader = () => <p>Loading</p>;

class ErrorBoundary extends React.Component {
  constructor(props) {
    super(props);
    this.state = {hasError: false};
  }

  static getDerivedStateFromError(error) {
    return {hasError: true};
  }

  render() {
    if (this.state.hasError) {
      return <p>Loading failed! Please reload.</p>;
    }

    return this.props.children;
  }
}

const DetailsComponent = () => (
  <ErrorBoundary>
    <Suspense fallback={renderLoader()}>
      <AvatarComponent />
      <InfoComponent />
      <MoreInfoComponent />
    </Suspense>
  </ErrorBoundary>
)

סיכום

אם אתם לא בטוחים איפה להתחיל להחיל פיצול קוד על אפליקציית React, בצעו את השלבים הבאים:

  1. מתחילים ברמת המסלול. נתיבים הם הדרך הפשוטה ביותר לזהות נקודות באפליקציה שאפשר לפצל. במסמכי התיעוד של React מוסבר איך אפשר להשתמש ב-Suspense יחד עם react-router.
  2. מזהים רכיבים גדולים בדף באתר שמוצגים רק באינטראקציות מסוימות של המשתמש (כמו לחיצה על כפתור). פיצול הרכיבים האלה יקטין את המטענים הייעודיים (payloads) של JavaScript.
  3. כדאי לשקול לפצל כל דבר אחר שלא מופיע במסך ואינו קריטי למשתמש.