מבוא
HTML5 מספק לנו כלים נהדרים לשיפור המראה החזותי של אפליקציות אינטרנט. זה נכון במיוחד בתחום האנימציות. אבל עם היכולות החדשות מגיעים גם אתגרים חדשים. למעשה, האתגרים האלה לא ממש חדשים, ולפעמים כדאי לשאול את השכנה הידידותית שלכם מהשולחן הסמוך, מתכנתת Flash, איך היא התגברה על דברים דומים בעבר.
בכל מקרה, כשעובדים עם אנימציה, חשוב מאוד שהמשתמשים יראו את האנימציות האלה בצורה חלקה. חשוב להבין שאי אפשר ליצור אנימציות חלקות רק על ידי הגדלת FPS מעבר לסף קוגניטיבי כלשהו. לצערנו, המוח שלנו חכם יותר מזה. אתם תגלו שקצב פריימים אמיתי של 30 פריימים לשנייה (fps) באנימציה הרבה יותר טוב מקצב של 60 פריימים לשנייה עם כמה פריימים שהושמטו באמצע. אנשים שונאים חוסר עקביות.
במאמר הזה ננסה לתת לכם את הכלים והטכניקות שיעזרו לכם לשפר את חוויית השימוש באפליקציה שלכם.
האסטרטגיה
אנחנו ממש לא רוצים למנוע מכם ליצור אפליקציות מדהימות עם רכיבים חזותיים מרשימים ב-HTML5.
אם תשימו לב שהביצועים יכולים להיות קצת יותר טובים, תוכלו לחזור לכאן ולקרוא איך לשפר את הרכיבים של האפליקציה. כמובן שזה יכול לעזור לעשות דברים נכון מלכתחילה, אבל אל תתנו לזה להפריע לכם להיות פרודוקטיביים.
איכות חזותית משופרת עם HTML5
שיפור המהירות באמצעות חומרה
שיפור מהירות באמצעות חומרה הוא אבן דרך חשובה לביצועי הרינדור הכוללים בדפדפן. העיקרון הכללי הוא להעביר משימות שבדרך כלל מחושבות על ידי המעבד הראשי (CPU) ליחידת העיבוד הגרפי (GPU) במתאם הגרפי של המחשב. כך אפשר לשפר את הביצועים באופן משמעותי וגם לצמצם את צריכת המשאבים במכשירים ניידים.
היבטים אלה של המסמך יכולים להיות מואצים על ידי ה-GPU
- הרכבת פריסה כללית
- מעברי CSS3
- טרנספורמציות תלת-ממדיות ב-CSS3
- ציור על קנבס
- שרטוט תלת-ממדי ב-WebGL
האצת ה-canvas וה-WebGL הן תכונות למטרות מיוחדות שאולי לא רלוונטיות לאפליקציה הספציפית שלכם, אבל שלושת ההיבטים הראשונים יכולים לעזור כמעט לכל אפליקציה לפעול מהר יותר.
מה אפשר להאיץ?
האצת GPU פועלת על ידי העברת משימות ספציפיות ומוגדרות היטב לחומרה ייעודית. העיקרון הכללי הוא שהמסמך מחולק לכמה "שכבות" שלא משתנות בהתאם להיבטים של הדף שמופעלת בהם האצה. השכבות האלה מעובדות באמצעות צינור עיבוד הנתונים המסורתי. לאחר מכן, המעבד הגרפי משמש להרכבת השכבות בדף אחד, תוך החלת "האפקטים" שניתן להאיץ תוך כדי תנועה. תוצאה אפשרית היא שאובייקט שמונפש במסך לא דורש "פריסה מחדש" אחת של הדף בזמן שהאנימציה מתרחשת.
מה שחשוב להבין מזה הוא שצריך להקל על מנוע הרינדור לזהות מתי הוא יכול להפעיל את הקסם של האצת ה-GPU. דוגמה:
השיטה הזו עובדת, אבל הדפדפן לא באמת יודע שאתם מבצעים פעולה שאמורה להיראות לבני אדם כמו אנימציה חלקה. מה קורה כשמשיגים את אותו מראה חזותי באמצעות מעברי CSS3 במקום זאת:
אופן ההטמעה של האנימציה הזו בדפדפן מוסתר לחלוטין מהמפתח. זה אומר שהדפדפן יכול להשתמש בטריקים כמו האצת GPU כדי להשיג את המטרה שהוגדרה.
יש שתי הגדרות flag שימושיות בשורת הפקודה של Chrome שיכולות לעזור בניפוי באגים בהאצת המעבד הגרפי:
--show-composited-layer-bordersמציג גבול אדום מסביב לרכיבים שמתבצעת בהם מניפולציה ברמת ה-GPU. הכלי הזה מתאים כדי לוודא שהמניפולציות מתרחשות בשכבת ה-GPU.-
--show-paint-rectsכל השינויים שלא קשורים ל-GPU נצבעים, ומופיע גבול בהיר מסביב לכל האזורים שנצבעים מחדש. אתם יכולים לראות את הדפדפן מבצע אופטימיזציה של אזורי הצביעה בפעולה.
ל-Safari יש דגלי זמן ריצה דומים שמתוארים כאן.
מעברי CSS3
מעברי CSS הופכים את האנימציה של הסגנון לפשוטה לכולם, אבל הם גם תכונה חכמה לשיפור הביצועים. מכיוון שהדפדפן מנהל את מעבר ה-CSS, אפשר לשפר מאוד את נאמנות האנימציה, ובמקרים רבים לשפר את המהירות באמצעות חומרה. נכון לעכשיו, ל-WebKit (Chrome, Safari, iOS) יש טרנספורמציות CSS עם שיפור מהירות באמצעות חומרה, אבל בקרוב הן יהיו זמינות גם בדפדפנים ובפלטפורמות אחרים.
אתם יכולים להשתמש באירועים של transitionEnd כדי ליצור סקריפטים עם שילובים חזקים, אבל כרגע, כדי לתעד את כל האירועים הנתמכים של סיום המעבר, צריך לצפות ב-webkitTransitionEnd transitionend oTransitionEnd.
בהרבה ספריות יש עכשיו ממשקי API של אנימציה שמשתמשים במעברים אם הם קיימים, ואם לא, חוזרים לאנימציה רגילה בסגנון DOM. scripty2, YUI transition, jQuery animate enhanced.
CSS3 translate
אני בטוח שכבר יצא לכם להנפיש את מיקום ה-X/Y של רכיב בדף. כנראה ששיניתם את המאפיינים left ו-top של הסגנון המוטבע. עם טרנספורמציות דו-ממדיות, אנחנו יכולים להשתמש בפונקציונליות של translate() כדי לשכפל את ההתנהגות הזו.
אנחנו יכולים לשלב את זה עם אנימציית DOM כדי להשתמש באפשרות הכי טובה
<div style="position:relative; height:120px;" class="hwaccel">
<div style="padding:5px; width:100px; height:100px; background:papayaWhip;
position:absolute;" id="box">
</div>
</div>
<script>
document.querySelector('#box').addEventListener('click', moveIt, false);
function moveIt(evt) {
var elem = evt.target;
if (Modernizr.csstransforms && Modernizr.csstransitions) {
// vendor prefixes omitted here for brevity
elem.style.transition = 'all 3s ease-out';
elem.style.transform = 'translateX(600px)';
} else {
// if an older browser, fall back to jQuery animate
jQuery(elem).animate({ 'left': '600px'}, 3000);
}
}
</script>
אנחנו משתמשים ב-Modernizr כדי לבדוק את התכונות של CSS 2D Transforms ו-CSS Transitions. אם הן קיימות, אנחנו משתמשים ב-translate כדי לשנות את המיקום. אם האנימציה הזו נוצרת באמצעות מעבר, יש סיכוי טוב שהדפדפן יוכל להאיץ אותה באמצעות חומרה. כדי לתת לדפדפן עוד דחיפה בכיוון הנכון, נשתמש ב"כדור הקסם של CSS" מלמעלה.
אם הדפדפן שלנו פחות מתקדם, נחזור ל-jQuery כדי להזיז את הרכיב. אתם יכולים להשתמש ב-jQuery Transform polyfill plugin של Louis-Remi Babe כדי להפוך את כל התהליך לאוטומטי.
window.requestAnimationFrame
requestAnimationFrame הוצג על ידי Mozilla ופותח על ידי WebKit במטרה לספק לכם API מקורי להפעלת אנימציות, בין אם הן מבוססות על DOM/CSS או על <canvas> או WebGL. הדפדפן יכול לבצע אופטימיזציה של אנימציות שפועלות בו-זמנית, ולשלב אותן במחזור אחד של עיצוב מחדש וצביעה מחדש. כך אפשר ליצור אנימציה באיכות גבוהה יותר. לדוגמה, אנימציות מבוססות-JS שמסונכרנות עם מעברי CSS או SVG SMIL. בנוסף, אם אתם מריצים את לולאת האנימציה בכרטיסייה שלא גלויה, הדפדפן לא ימשיך להריץ אותה, מה שאומר פחות שימוש במעבד (CPU), במעבד הגרפי (GPU) ובשימוש בזיכרון, וכתוצאה מכך חיי סוללה ארוכים בהרבה.
כדי לקבל פרטים נוספים על אופן השימוש ב-requestAnimationFrame והסיבות לשימוש בו, אפשר לעיין במאמר של פול אייריש requestAnimationFrame for smart animating.
יצירת פרופילים
אם אתם מגלים שאפשר לשפר את מהירות האפליקציה, כדאי לבדוק את הפרופיילינג כדי לראות איפה האופטימיזציה תניב את התועלת הגדולה ביותר. לעתים קרובות, לאופטימיזציות תהיה השפעה שלילית על יכולת התחזוקה של קוד המקור, ולכן צריך להחיל אותן רק במקרה הצורך. הפרופיילינג מראה לכם אילו חלקים בקוד יניבו את התועלת הרבה ביותר אם תשפרו את הביצועים שלהם.
ניתוח ביצועים של JavaScript
כלי הפרופיילינג של JavaScript מספקים סקירה כללית על הביצועים של האפליקציה ברמת הפונקציה של JavaScript, על ידי מדידת הזמן שלוקח להריץ כל פונקציה בנפרד מההתחלה ועד הסוף.
זמן הביצוע ברוטו של פונקציה הוא משך הזמן הכולל שלוקח להריץ אותה מההתחלה ועד הסוף. זמן הביצוע נטו הוא זמן הביצוע ברוטו פחות הזמן שלקח להפעיל פונקציות שנקראו מהפונקציה.
חלק מהפונקציות מופעלות בתדירות גבוהה יותר מאחרות. בדרך כלל, כלי הפרופיילינג מציגים את הזמן שלקח לכל הקריאות לפעול, וגם את זמן הביצוע הממוצע, המינימלי והמקסימלי.
פרטים נוספים זמינים במסמכי התיעוד של כלי הפיתוח ל-Chrome בנושא יצירת פרופילים.
DOM
הביצועים של JavaScript משפיעים מאוד על מידת הגמישות והתגובה של האפליקציה. חשוב להבין שכלים לניתוח ביצועים של JavaScript מודדים את זמן הביצוע של JavaScript, אבל הם גם מודדים באופן עקיף את הזמן שנדרש לביצוע פעולות DOM. פעולות ה-DOM האלה הן בדרך כלל הגורם לבעיות בביצועים.
function drawArray(array) {
for(var i = 0; i < array.length; i++) {
document.getElementById('test').innerHTML += array[i]; // No good :(
}
}
לדוגמה, בקוד שלמעלה כמעט לא מושקע זמן בהרצת JavaScript בפועל. סביר מאוד להניח שהפונקציה drawArray תופיע בפרופילים שלכם כי היא יוצרת אינטראקציה עם ה-DOM בצורה מאוד בזבזנית.
טיפים וטריקים
פונקציות אנונימיות
לא קל ליצור פרופיל לפונקציות אנונימיות כי אין להן שם שיופיע בכלי ליצירת פרופילים. יש שתי דרכים לעקוף את הבעיה:
$('.stuff').each(function() { ... });
שכתוב:
$('.stuff').each(function workOnStuff() { ... });
לא כולם יודעים ש-JavaScript תומכת בביטויים של פונקציות בעלות שם. כך הם יופיעו בצורה מושלמת בכלי ליצירת פרופילים. יש בעיה אחת בפתרון הזה: הביטוי בעל השם למעשה מכניס את שם הפונקציה להיקף הלקסיקלי הנוכחי. הפעולה הזו עלולה להחליף סמלים אחרים, אז צריך להיזהר.
יצירת פרופילים של פונקציות ארוכות
נניח שיש לכם פונקציה ארוכה ואתם חושדים שחלק קטן ממנה הוא הסיבה לבעיות בביצועים. יש שתי דרכים לגלות איזה חלק גורם לבעיה:
- השיטה הנכונה: לארגן את הקוד מחדש כך שלא יכלול פונקציות ארוכות.
- השיטה הזדונית לביצוע משימות: הוספת הצהרות לקוד בצורה של פונקציות בעלות שם שקוראות לעצמן. אם תהיו קצת זהירים, זה לא ישנה את הסמנטיקה ויגרום לחלקים מהפונקציה להופיע כפונקציות נפרדות בכלי לניתוח ביצועים (profiler):
js function myLongFunction() { ... (function doAPartOfTheWork() { ... })(); ... }אל תשכחו להסיר את הפונקציות הנוספות האלה אחרי שתסיימו ליצור את הפרופיל, או אפילו להשתמש בהן כנקודת התחלה לארגון הקוד מחדש.
יצירת פרופילים של DOM
הכלים העדכניים למפתחים של Chrome Web Inspector כוללים את "תצוגת ציר הזמן" החדשה, שמציגה ציר זמן של הפעולות ברמה הנמוכה שמבצע הדפדפן. אתם יכולים להשתמש במידע הזה כדי לבצע אופטימיזציה של פעולות ה-DOM. כדאי לנסות לצמצם את מספר ה "פעולות" שהדפדפן צריך לבצע בזמן שהקוד פועל.
תצוגת ציר הזמן יכולה ליצור כמות עצומה של מידע. לכן, כדאי לנסות ליצור מקרי בדיקה מינימליים שאפשר להריץ באופן עצמאי.
בתמונה שלמעלה מוצג הפלט של תצוגת ציר הזמן של סקריפט פשוט מאוד. בחלונית הימנית מוצגות הפעולות שבוצעו על ידי הדפדפן בסדר כרונולוגי, ובציר הזמן שבחלונית השמאלית מוצג הזמן בפועל שנדרש לכל פעולה.
מידע נוסף על תצוגת ציר הזמן כלי חלופי ליצירת פרופילים ב-Internet Explorer הוא DynaTrace Ajax Edition.
שיטות ליצירת פרופילים
היבטים של זיהוי משתמשים ספציפיים
כשרוצים ליצור פרופיל של האפליקציה, כדאי לנסות לבודד את ההיבטים של הפונקציונליות שלה שעלולים לגרום לאיטיות, עד כמה שניתן. אחר כך נסו להריץ פרופיל שמפעיל רק חלקים מהקוד שרלוונטיים להיבטים האלה של האפליקציה. כך יהיה קל יותר לפרש את נתוני הפרופיילינג, כי הם לא יתערבבו עם נתיבי קוד שלא קשורים לבעיה עצמה. דוגמאות טובות להיבטים ספציפיים של האפליקציה:
- זמן ההפעלה (הפעלת כלי הניתוח, טעינה מחדש של האפליקציה, המתנה עד לסיום תהליך האיניציאליזציה, עצירת כלי הניתוח.
- לוחצים על כפתור ועל האנימציה שמופיעה אחריו (מפעילים את כלי הניתוח, לוחצים על הכפתור, מחכים עד שהאנימציה מסתיימת, עוצרים את כלי הניתוח).
יצירת פרופילים של ממשק משתמש גרפי (GUI)
יכול להיות שיהיה קשה יותר להפעיל רק את החלק הנכון של האפליקציה בתוכנית GUI מאשר כשמבצעים אופטימיזציה, למשל, של מעקב הקרניים של מנוע התלת-ממד. לדוגמה, אם אתם רוצים ליצור פרופיל של מה שקורה כשלוחצים על כפתור, יכול להיות שתפעילו בדרך אירועים לא קשורים של העברת העכבר מעל אלמנטים, והתוצאות יהיו פחות חד-משמעיות. כדאי להימנע מכך :)
ממשק פרוגרמטי
יש גם ממשק פרוגרמטי להפעלת מנפה הבאגים. כך אפשר לשלוט בצורה מדויקת מתי יצירת הפרופיל מתחילה ומתי היא מסתיימת.
התחלת יצירת פרופיל באמצעות:
console.profile()
הפסקת הפרופיילינג באמצעות:
console.profileEnd()
חזרה על הפעולה
כשאתם מבצעים פרופיילינג, ודאו שאתם יכולים לשחזר את התוצאות. רק אז תוכלו לדעת אם האופטימיזציות שביצעתם באמת שיפרו את המצב. בנוסף, יצירת פרופיל ברמת הפונקציה מתבצעת בהקשר של המחשב כולו. זה לא מדע מדויק. הרצות פרופיל בודדות עשויות להיות מושפעות מהרבה דברים אחרים שקורים במחשב:
- טיימר לא קשור באפליקציה שלכם שמופעל בזמן שאתם מודדים משהו אחר.
- איסוף הזבל פועל.
- כרטיסייה אחרת בדפדפן מבצעת פעולה מורכבת באותו תהליך הפעלה.
- תוכנה אחרת במחשב שמשתמשת במעבד (CPU) וגורמת לאפליקציה לפעול לאט יותר.
- שינויים פתאומיים בשדה הכבידה של כדור הארץ.
כדאי גם להריץ את אותו נתיב קוד כמה פעמים בסשן פרופיילינג אחד. כך תוכלו להפחית את ההשפעה של הגורמים שלמעלה, והחלקים האיטיים יבלטו עוד יותר.
מודדים, משפרים, מודדים
כשמזהים נקודה איטית בתוכנית, כדאי לנסות לחשוב על דרכים לשפר את התנהגות הביצוע. אחרי שמשנים את הקוד, צריך ליצור פרופיל שוב. אם אתם מרוצים מהתוצאה, המשיכו הלאה. אם אתם לא רואים שיפור, כנראה שכדאי לבטל את השינוי ולא להשאיר אותו "כי הוא לא יכול להזיק".
אסטרטגיות אופטימיזציה
צמצום האינטראקציה עם ה-DOM
אחת הדרכים הנפוצות לשפר את המהירות של אפליקציות לקוח באינטרנט היא לצמצם את האינטראקציה עם DOM. למרות שהמהירות של מנועי JavaScript גדלה בסדר גודל, הגישה ל-DOM לא הפכה למהירה יותר באותו קצב. זה גם לא יקרה אף פעם מסיבות מעשיות מאוד (דברים כמו פריסה וציור של דברים על המסך פשוט לוקחים זמן).
שמירת צומתי DOM במטמון
בכל פעם שאתם מאחזרים צומת או רשימה של צמתים מה-DOM, נסו לחשוב אם תוכלו להשתמש בהם שוב בחישוב מאוחר יותר (או אפילו רק באיטרציה הבאה של הלולאה). כל עוד לא מוסיפים או מוחקים צמתים באזור הרלוונטי, זה בדרך כלל המצב.
לפני:
function getElements() {
return $('.my-class');
}
אחרי:
var cachedElements;
function getElements() {
if (cachedElements) {
return cachedElements;
}
cachedElements = $('.my-class');
return cachedElements;
}
ערכי מאפייני מטמון
כמו שאפשר לשמור במטמון צומתי DOM, אפשר גם לשמור במטמון ערכים של מאפיינים. נניח שאתם יוצרים אנימציה של מאפיין בסגנון של צומת. אם אתם יודעים שאתם (כלומר, החלק הזה בקוד) היחידים שתיגעו במאפיין הזה, אתם יכולים לשמור במטמון את הערך האחרון בכל איטרציה כדי שלא תצטרכו לקרוא אותו שוב ושוב.
לפני:
setInterval(function() {
var ele = $('#element');
var left = parseInt(ele.css('left'), 10);
ele.css('left', (left + 5) + 'px');
}, 1000 / 30);
אחרי:
js
var ele = $('#element');
var left = parseInt(ele.css('left'), 10);
setInterval(function() {
left += 5;
ele.css('left', left + 'px');
}, 1000 / 30);
העברת מניפולציית DOM אל מחוץ ללולאות
לולאות הן לעיתים קרובות נקודות חמות לאופטימיזציה. נסו לחשוב על דרכים להפריד בין עיבוד הנתונים בפועל לבין העבודה עם ה-DOM. במקרים רבים אפשר לבצע חישוב, ואז להחיל את כל התוצאות בבת אחת.
לפני:
document.getElementById('target').innerHTML = '';
for(var i = 0; i < array.length; i++) {
var val = doSomething(array[i]);
document.getElementById('target').innerHTML += val;
}
אחרי:
var stringBuilder = [];
for(var i = 0; i < array.length; i++) {
var val = doSomething(array[i]);
stringBuilder.push(val);
}
document.getElementById('target').innerHTML = stringBuilder.join('');
שרטוט מחדש ועיצוב מחדש
כמו שהסברנו קודם, הגישה ל-DOM היא איטית יחסית. הוא נהיה איטי מאוד כשהקוד קורא ערך שצריך לחשב מחדש כי הקוד שינה לאחרונה משהו שקשור ב-DOM. לכן, כדאי להימנע משילוב של גישת קריאה וכתיבה ל-DOM. באופן אידיאלי, הקוד צריך תמיד להיות מקובץ בשני שלבים:
- שלב 1: קריאת ערכי DOM שנדרשים לקוד
- שלב 2: שינוי ה-DOM
נסו לא לתכנת תבנית כמו:
- שלב 1: קריאת ערכי DOM
- שלב 2: שינוי ה-DOM
- שלב 3: קוראים עוד קצת
- שלב 4: משנים את ה-DOM במקום אחר.
לפני:
function paintSlow() {
var left1 = $('#thing1').css('left');
$('#otherThing1').css('left', left);
var left2 = $('#thing2').css('left');
$('#otherThing2').css('left', left);
}
אחרי:
function paintFast() {
var left1 = $('#thing1').css('left');
var left2 = $('#thing2').css('left');
$('#otherThing1').css('left', left);
$('#otherThing2').css('left', left);
}
ההמלצה הזו רלוונטית לפעולות שמתרחשות בהקשר של הרצת JavaScript אחת. (למשל, בתוך גורם מטפל באירועים, בתוך גורם מטפל במרווחים או כשמטפלים בתגובת AJAX).
הפעלת הפונקציה paintSlow() מלמעלה יוצרת את התמונה הזו:
אם עוברים להטמעה המהירה יותר, מקבלים את התמונה הזו:
התמונות האלה מראות ששינוי הסדר שבו הקוד ניגש ל-DOM יכול לשפר מאוד את ביצועי העיבוד. במקרה כזה, הקוד המקורי צריך לחשב מחדש את הסגנונות ולפרוס את הדף פעמיים כדי ליצור את אותה תוצאה. אפשר להחיל אופטימיזציה דומה על כל קוד "בעולם האמיתי" ולקבל תוצאות דרמטיות.
מידע נוסף: רינדור: צביעה מחדש, הזרמה מחדש/פריסה מחדש, עיצוב מחדש מאת סטויאן סטפנוב
שרטוט מחדש ולולאת האירוע
הרצת JavaScript בדפדפן פועלת לפי מודל של "לולאת אירוע". כברירת מחדל, הדפדפן נמצא במצב "לא פעיל". אירועים מאינטראקציות של משתמשים או דברים כמו טיימרים של JavaScript או קריאות חוזרות (callbacks) של Ajax יכולים להפריע למצב הזה. בכל פעם שקטע קוד ב-JavaScript פועל בנקודת הפרעה כזו, הדפדפן בדרך כלל ימתין עד שהוא יסיים לפני שהוא יצייר מחדש את המסך (יכולים להיות חריגים במקרים של קטעי קוד ב-JavaScript שפועלים במשך זמן ארוך מאוד או במקרים כמו תיבות התראה שקוטעות את ההפעלה של JavaScript).
השלכות
- אם מחזורי האנימציה של JavaScript נמשכים יותר מ-1/30 שניות, לא תוכלו ליצור אנימציות חלקות כי הדפדפן לא יצייר מחדש במהלך ההפעלה של JavaScript. אם אתם מצפים לטפל גם באירועי משתמשים, אתם צריכים להיות הרבה יותר מהירים.
- לפעמים כדאי לעכב חלק מפעולות ה-JavaScript.
לדוגמה:
setTimeout(function() { ... }, 0)הקוד הזה מורה לדפדפן להפעיל את פונקציית ה-callback ברגע שלולאת האירוע שוב לא פעילה (בפועל, דפדפנים מסוימים ימתינו לפחות 10 אלפיות השנייה). חשוב לדעת שהפעולה הזו תיצור שני מחזורי הפעלה של JavaScript בהפרש זמן קצר מאוד. שניהם עשויים להפעיל צביעה מחדש של המסך, מה שעלול להכפיל את הזמן הכולל שמוקדש לצביעה. השאלה אם זה באמת מפעיל שני רינדורים תלויה בהיוריסטיקה בדפדפן.
גרסה רגילה:
function paintFast() {
var height1 = $('#thing1').css('height');
var height2 = $('#thing2').css('height');
$('#otherThing1').css('height', '20px');
$('#otherThing2').css('height', '20px');
}
נוסיף קצת השהיה:
function paintALittleLater() {
var height1 = $('#thing1').css('height');
var height2 = $('#thing2').css('height');
$('#otherThing1').css('height', '20px');
setTimeout(function() {
$('#otherThing2').css('height', '20px');
}, 10)
}
בגרסה עם העיכוב, הדפדפן מבצע רינדור פעמיים, למרות שההפרש בין שני השינויים בדף הוא רק מאית השנייה.
אתחול מדורג (lazy initialization)
המשתמשים רוצים אפליקציות אינטרנט שנטענות מהר ומגיבות במהירות. עם זאת, למשתמשים יש סף שונה למה שהם תופסים כאיטי, בהתאם לפעולה שהם מבצעים. לדוגמה, אפליקציה לא צריכה לבצע הרבה חישובים באירוע של העברת העכבר מעל רכיב, כי זה עלול ליצור חוויית משתמש גרועה בזמן שהמשתמש ממשיך להזיז את העכבר. עם זאת, המשתמשים רגילים להמתין קצת אחרי שהם לוחצים על כפתור.
לכן, כדאי להעביר את קוד האתחול כך שיבוצע בשלב מאוחר ככל האפשר (למשל, כשהמשתמש לוחץ על כפתור שמפעיל רכיב מסוים באפליקציה).
לפני:
js
var things = $('.ele > .other * div.className');
$('#button').click(function() { things.show() });
אחרי:
js
$('#button').click(function() { $('.ele > .other * div.className').show() });
האצלת אירועים
הוספה של גורמים מטפלים באירועים בכל רחבי הדף יכולה לקחת הרבה זמן, וגם להיות מייגעת אם האלמנטים מוחלפים באופן דינמי, כי אז צריך להוסיף את הגורמים המטפלים באירועים לאלמנטים החדשים.
הפתרון במקרה הזה הוא להשתמש בטכניקה שנקראת "האצלת אירועים" (event delegation). במקום לצרף גורמים מטפלים באירועים לרכיבים ספציפיים, אפשר להשתמש בטבע המבעבע של אירועי דפדפן רבים על ידי צירוף הגורם המטפל באירועים לצומת הורה ובדיקת צומת היעד של האירוע כדי לראות אם האירוע מעניין.
ב-jQuery אפשר לבטא את זה בקלות כך:
$('#parentNode').delegate('.button', 'click', function() { ... });
מתי לא כדאי להשתמש בהקצאת אירועים
לפעמים ההפך הוא הנכון: אתם משתמשים בהקצאת אירועים ונתקלים בבעיה בביצועים. בעיקרון, הקצאת אירועים מאפשרת זמן אתחול עם מורכבות קבועה. עם זאת, צריך לשלם את מחיר הבדיקה אם אירוע מסוים מעניין בכל הפעלה של האירוע הזה. זה יכול להיות יקר, במיוחד לאירועים שמתרחשים לעיתים קרובות כמו "mouseover" או אפילו "mousemove".
בעיות נפוצות ופתרונות
הפעולות שאני מבצע ב-$(document).ready נמשכות הרבה זמן
העצה האישית של מאלטה: אף פעם אל תעשו שום דבר ב-$(document).ready. נסו לשלוח את המסמך בפורמט הסופי שלו. בסדר, מותר לרשום רכיבי event listener, אבל רק באמצעות id-selector ו/או באמצעות הקצאת אירועים. באירועים שדורשים משאבים רבים, כמו mousemove, כדאי לעכב את הרישום עד שהם נדרשים (אירוע mouseover ברכיב הרלוונטי).
אם אתם באמת צריכים לבצע פעולות, כמו בקשת Ajax כדי לקבל נתונים בפועל, הציגו אנימציה נחמדה. כדאי לכלול את האנימציה כ-URI של נתונים אם מדובר בקובץ GIF מונפש או משהו דומה.
מאז שהוספתי סרטון Flash לדף, הכול ממש איטי
הוספת Flash לדף תמיד תאט קצת את העיבוד, כי צריך "לנהל משא ומתן" על הפריסה הסופית של החלון בין הדפדפן לבין הפלאגין של Flash. אם אתם לא יכולים להימנע לחלוטין מהוספת Flash לדפים, הקפידו להגדיר את הפרמטר "wmode" של Flash לערך "window" (שהוא ברירת המחדל). הפעולה הזו תשבית את היכולת לשלב רכיבי HTML ו-Flash (לא תוכלו לראות רכיב HTML שנמצא מעל סרטון Flash, וסרטון ה-Flash לא יוכל להיות שקוף). זה אולי לא נוח, אבל זה ישפר את הביצועים באופן משמעותי. לדוגמה, אפשר לראות איך ב-youtube.com נמנעים בקפידה מהצבת שכבות מעל נגן הסרטים הראשי.
אני שומר דברים ב-localStorage, ועכשיו האפליקציה שלי מגמגמת
כתיבה ב-localStorage היא פעולה סינכרונית שכוללת הפעלה של הכונן הקשיח. לא מומלץ לבצע פעולות סינכרוניות "ארוכות" בזמן הפעלת אנימציות. העבירו את הגישה ל-localStorage למקום בקוד שבו אתם בטוחים שהמשתמש לא פעיל ושאין אנימציות שפועלות.
הפרופיילינג מצביע על כך שסלקטור של jQuery איטי מאוד
קודם כל, צריך לוודא שאפשר להפעיל את הסלקטור באמצעות document.querySelectorAll. אפשר לבדוק את זה בלוח JavaScript. אם יש חריגה, צריך לשכתב את הסלקטור כך שלא ישתמש בתוסף מיוחד של ה-JavaScript framework. הפעולה הזו תאיץ את הסלקטור בדפדפנים מודרניים בסדר גודל שלם.
אם זה לא עוזר, או אם אתם רוצים שהאתר ייטען מהר גם בדפדפנים מודרניים, כדאי לפעול לפי ההנחיות הבאות:
- השתדלו להיות ספציפיים ככל האפשר בצד שמאל של הסלקטור.
- השתמשו בשם תג שאתם לא משתמשים בו לעיתים קרובות כחלק הסלקטור הימני ביותר.
- אם שום דבר לא עוזר, כדאי לשקול לכתוב מחדש את הדברים כדי שתוכלו להשתמש בבורר מזהה
כל המניפולציות האלה ב-DOM נמשכות הרבה זמן
הוספה, הסרה ועדכון של הרבה צומתי DOM יכולים להיות איטיים מאוד. בדרך כלל אפשר לבצע אופטימיזציה על ידי יצירת מחרוזת גדולה של HTML ושימוש ב-domNode.innerHTML = newHTML כדי להחליף את התוכן הישן. חשוב לזכור שזה עלול לפגוע ביכולת התחזוקה וליצור קישורי זיכרון ב-IE, אז צריך להיזהר.
בעיה נפוצה נוספת היא שקוד האתחול עלול ליצור הרבה HTML. לדוגמה, פלאגין של jQuery שהופך תיבת בחירה לקבוצה של רכיבי div כי זה מה שרצו המעצבים, בלי להתחשב בשיטות המומלצות לחוויית המשתמש. אם אתם רוצים שהדף שלכם יהיה מהיר, אל תעשו את זה. במקום זאת, צריך להציג את כל תגי העיצוב מצד השרת בצורה הסופית שלהם. גם בשיטה הזו יש הרבה בעיות, אז כדאי לחשוב טוב אם המהירות שווה את המחיר.
כלים
- JSPerf – השוואה בין קטעי קוד קטנים של JavaScript
- Firebug – ליצירת פרופילים ב-Firefox
- הכלים למפתחים ב-Google Chrome (זמינים כ-WebInspector ב-Safari)
- DOM Monster – לאופטימיזציה של ביצועי DOM
- DynaTrace Ajax Edition – ליצירת פרופילים ואופטימיזציה של רינדור ב-Internet Explorer