הפחתת מטענים ייעודיים (payloads) של JavaScript באמצעות פיצול קוד

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

ב-Codelab הזה נסביר איך להשתמש בפיצול קוד כדי לשפר את הביצועים של אפליקציה פשוטה שממיינת שלושה מספרים.

בחלון הדפדפן מוצגת אפליקציה בשם Magic Sorter עם שלושה שדות להזנת מספרים וכפתור מיון.

מדידה

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

  1. כדי לראות תצוגה מקדימה של האתר, לוחצים על הצגת האפליקציה ואז על מסך מלא מסך מלא.
  2. מקישים על `Control+Shift+J` (או על `Command+Option+J` ב-Mac) כדי לפתוח את כלי הפיתוח.
  3. לוחצים על הכרטיסייה רשת.
  4. מסמנים את התיבה השבתת המטמון.
  5. טוענים מחדש את האפליקציה.

חלונית "רשת" שמוצגת בה חבילת JavaScript בגודל 71.2KB.

‫71.2KB של JavaScript רק כדי למיין כמה מספרים באפליקציה פשוטה. מה קורה?

בקוד המקור (src/index.js), הספרייה lodash מיובאת ומשמשת את האפליקציה הזו. ב-Lodash יש הרבה פונקציות בסיסיות שימושיות, אבל כאן אנחנו משתמשים רק בשיטה אחת מהחבילה. טעות נפוצה היא להתקין ולייבא יחסי תלות שלמים של צד שלישי, כשמשתמשים רק בחלק קטן מהם.

אופטימיזציה

יש כמה דרכים לצמצם את גודל החבילה:

  1. לכתוב שיטת מיון מותאמת אישית במקום לייבא ספרייה של צד שלישי
  2. משתמשים ב-method המובנה Array.prototype.sort() כדי למיין לפי מספרים
  3. צריך לייבא רק את השיטה sortBy מ-lodash ולא את כל הספרייה
  4. הורדת הקוד למיון רק כשהמשתמש לוחץ על הכפתור

אפשרויות 1 ו-2 הן שיטות מתאימות לחלוטין להקטנת גודל החבילה (וכנראה שהן הכי הגיוניות לאפליקציה אמיתית). אבל לא נשתמש בהם במדריך הזה, כדי שתוכלו ללמוד איך לעשות את זה בעצמכם 😈.

אפשרויות 3 ו-4 עוזרות לשפר את הביצועים של האפליקציה הזו. השלבים האלה מפורטים בחלקים הבאים של ה-Codelab. כמו בכל מדריך תכנות, תמיד כדאי לנסות לכתוב את הקוד בעצמכם במקום להעתיק ולהדביק.

מייבאים רק את מה שצריך

צריך לשנות כמה קבצים כדי לייבא רק את השיטה היחידה מ-lodash. כדי להתחיל, צריך להחליף את התלות הזו ב-package.json:

"lodash": "^4.7.0",

בזה:

"lodash.sortby": "^4.7.0",

עכשיו, ב-src/index.js, מייבאים את המודול הספציפי הזה:

import "./style.css";
import _ from "lodash";
import sortBy from "lodash.sortby";

ולעדכן את אופן המיון של הערכים:

form.addEventListener("submit", e => {
  e.preventDefault();
  const values = [input1.valueAsNumber, input2.valueAsNumber, input3.valueAsNumber];
  const sortedValues = _.sortBy(values);
  const sortedValues = sortBy(values);

  results.innerHTML = `
    <h2>
      ${sortedValues}
    </h2>
  `
});

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

חלונית &quot;רשת&quot; שמוצגת בה חבילת JavaScript בגודל 15.2KB.

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

פיצול קוד

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

אפשר לפצל את החבילה היחידה שמשמשת את האפליקציה הזו לשני חלקים נפרדים:

  • אחד שאחראי על הקוד שמרכיב את המסלול הראשוני שלנו
  • צ'אנק משני שמכיל את קוד המיון שלנו

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

קודם כל, מסירים את הייבוא ברמה העליונה של שיטת המיון בקובץ src/index.js:

import sortBy from "lodash.sortby";

ולייבא אותו בתוך רכיב ה-event listener שמופעל כשלוחצים על הכפתור:

form.addEventListener("submit", e => {
  e.preventDefault();
  import('lodash.sortby')
    .then(module => module.default)
    .then(sortInput())
    .catch(err => { alert(err) });
});

התכונה import() היא חלק מהצעה (כרגע בשלב 3 של תהליך TC39) לכלול את היכולת לייבא מודול באופן דינמי. webpack כבר כולל תמיכה בכך ופועל לפי אותו תחביר שמופיע בהצעה.

import() מחזיר הבטחה (promise) וכשהיא מתממשת, המודול שנבחר מסופק ומפוצל לחלק נפרד. אחרי שהמודול מוחזר, משתמשים ב-module.default כדי להפנות לייצוא ברירת המחדל שסופק על ידי lodash. ה-promise משורשר עם .then אחר שקורא ל-method sortInput כדי למיין את שלושת ערכי הקלט. בסוף שרשרת ההבטחות,הפונקציה catch() משמשת לטיפול במקרים שבהם ה-promise נדחה בגלל שגיאה.

הדבר האחרון שצריך לעשות הוא לכתוב את השיטה sortInput בסוף הקובץ. זו צריכה להיות פונקציה שמחזירה פונקציה שמקבלת את השיטה המיובאת מ-lodash.sortBy. לאחר מכן, הפונקציה המקוננת יכולה למיין את שלושת ערכי הקלט ולעדכן את ה-DOM.

const sortInput = () => {
  return (sortBy) => {
    const values = [
      input1.valueAsNumber,
      input2.valueAsNumber,
      input3.valueAsNumber
    ];
    const sortedValues = sortBy(values);

    results.innerHTML = `
      <h2>
        ${sortedValues}
      </h2>
    `
  };
}

מעקב

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

חלונית &quot;רשת&quot; שמוצגת בה חבילת JavaScript בגודל 2.7KB.

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

חלונית &quot;רשת&quot; שמוצגת בה חבילת JavaScript בגודל 2.7KB ואחריה חבילת JavaScript בגודל 13.9KB.

שימו לב שהמספרים עדיין ממוינים.

סיכום

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

ממשק משתמש של טעינה מדורגת (Lazy loading)

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

טעינה מדורגת של מודולים של צומת של צד שלישי

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

טעינה מדורגת (Lazy loading) עם JavaScript framework

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

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

טעינה מראש ושליפה מראש (prefetch)

כשאפשר, כדאי להשתמש ברמזים לדפדפן כמו <link rel="preload"> או <link rel="prefetch"> כדי לנסות לטעון מודולים קריטיים עוד יותר מוקדם. webpack תומך בשני הרמזים באמצעות שימוש בהערות קסם בהצהרות ייבוא. הנושא הזה מוסבר בפירוט במדריך טעינה מראש של מקטעים קריטיים.

טעינה מדורגת (Lazy loading) של יותר מקוד

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