การปรับปรุงประสิทธิภาพของแอป HTML5

บทนำ

HTML5 มีเครื่องมือที่ยอดเยี่ยมในการปรับปรุงรูปลักษณ์ของเว็บแอปพลิเคชัน โดยเฉพาะอย่างยิ่งในแวดวงแอนิเมชัน อย่างไรก็ตาม ความสามารถใหม่นี้ก็มาพร้อมกับความท้าทายใหม่ๆ ด้วย จริงๆ แล้วความท้าทายเหล่านี้ไม่ใช่เรื่องใหม่ และบางครั้งคุณอาจต้องถามเพื่อนร่วมงานที่นั่งข้างๆ ซึ่งเป็นโปรแกรมเมอร์ Flash ว่าเธอเอาชนะอุปสรรคที่คล้ายกันนี้ได้อย่างไรในอดีต

อย่างไรก็ตาม เมื่อคุณทำงานด้านภาพเคลื่อนไหว สิ่งสำคัญอย่างยิ่งคือผู้ใช้ต้องรับรู้ว่าภาพเคลื่อนไหวเหล่านี้มีความลื่นไหล สิ่งที่เราต้องตระหนักคือความลื่นไหลในภาพเคลื่อนไหวไม่สามารถสร้างขึ้นได้ด้วยการเพิ่มเฟรมต่อวินาทีให้เกินเกณฑ์การรับรู้ แต่สมองของเราฉลาดกว่านั้น สิ่งที่คุณจะได้เรียนรู้คือภาพเคลื่อนไหว 30 เฟรมต่อวินาที (FPS) ที่แท้จริงนั้นดีกว่า 60 FPS ที่มีเฟรมหายไปเพียงไม่กี่เฟรมในระหว่างการเล่น ผู้คนไม่ชอบความขรุขระ

บทความนี้จะพยายามให้เครื่องมือและเทคนิคต่างๆ แก่คุณเพื่อใช้ปรับปรุงประสบการณ์การใช้งานแอปพลิเคชันของคุณเอง

กลยุทธ์

เราไม่ได้ต้องการกีดกันคุณจากการสร้างแอปที่สวยงามและน่าทึ่งด้วย HTML5

จากนั้นเมื่อคุณสังเกตเห็นว่าประสิทธิภาพอาจดีขึ้นได้อีกเล็กน้อย ให้กลับมาที่นี่และอ่านวิธีปรับปรุงองค์ประกอบต่างๆ ของแอปพลิเคชัน แน่นอนว่าการทำบางสิ่งให้ถูกต้องตั้งแต่แรกอาจช่วยได้ แต่ก็อย่าปล่อยให้สิ่งนั้นมาขัดขวางการทำงานอย่างมีประสิทธิภาพของคุณ

ความแม่นยำของภาพที่เพิ่มขึ้นด้วย HTML5

การเร่งฮาร์ดแวร์

การเร่งฮาร์ดแวร์เป็นก้าวสำคัญสำหรับประสิทธิภาพการแสดงผลโดยรวมในเบราว์เซอร์ รูปแบบทั่วไปคือการถ่ายโอนงานที่ปกติแล้วจะคำนวณโดย CPU หลักไปยังหน่วยประมวลผลกราฟิก (GPU) ในอะแดปเตอร์กราฟิกของคอมพิวเตอร์ ซึ่งจะช่วยเพิ่มประสิทธิภาพได้อย่างมากและยังช่วยลดการใช้ทรัพยากรในอุปกรณ์เคลื่อนที่ด้วย

GPU สามารถเร่งความเร็วของเอกสารในด้านต่างๆ ต่อไปนี้ได้

  • การจัดองค์ประกอบเลย์เอาต์ทั่วไป
  • การเปลี่ยน CSS3
  • การเปลี่ยนรูปแบบ 3 มิติ CSS3
  • ภาพวาด Canvas
  • ภาพวาด 3 มิติของ WebGL

แม้ว่าการเร่งความเร็วของ Canvas และ WebGL จะเป็นฟีเจอร์ที่มีวัตถุประสงค์พิเศษซึ่งอาจใช้ไม่ได้กับแอปพลิเคชันของคุณโดยเฉพาะ แต่ 3 ด้านแรกจะช่วยให้แอปเกือบทุกแอปทำงานได้เร็วขึ้น

สิ่งที่เร่งความเร็วได้

การเร่ง GPU ทำงานโดยการถ่ายโอนงานที่กำหนดไว้อย่างชัดเจนและเฉพาะเจาะจงไปยังฮาร์ดแวร์เพื่อวัตถุประสงค์พิเศษ รูปแบบทั่วไปคือเอกสารของคุณจะแบ่งออกเป็น "เลเยอร์" หลายเลเยอร์ซึ่งไม่แปรผันตามแง่มุมของหน้าเว็บที่เร่งความเร็ว เลเยอร์เหล่านี้จะแสดงผลโดยใช้ไปป์ไลน์การแสดงผลแบบดั้งเดิม จากนั้น GPU จะใช้เพื่อจัดองค์ประกอบเลเยอร์ลงในหน้าเดียวโดยใช้ "เอฟเฟกต์" ที่สามารถเร่งได้ทันที ผลลัพธ์ที่เป็นไปได้คือออบเจ็กต์ที่เคลื่อนไหวบนหน้าจอไม่จำเป็นต้อง "จัดเลย์เอาต์ใหม่" หน้าเว็บเพียงครั้งเดียวขณะที่เกิดภาพเคลื่อนไหว

สิ่งที่คุณต้องจำไว้คือคุณต้องทำให้เครื่องมือแสดงผลระบุได้ง่ายว่าเมื่อใดที่สามารถใช้ความสามารถในการเร่ง GPU ได้ ลองดูตัวอย่างต่อไปนี้

แม้ว่าวิธีนี้จะได้ผล แต่เบราว์เซอร์ไม่ทราบจริงๆ ว่าคุณกำลังดำเนินการบางอย่างที่ควรรับรู้ว่าเป็นภาพเคลื่อนไหวที่ราบรื่นโดยมนุษย์ ลองพิจารณาสิ่งที่เกิดขึ้นเมื่อคุณได้ภาพที่เหมือนกันโดยใช้การเปลี่ยน CSS3 แทน

วิธีที่เบราว์เซอร์ใช้ภาพเคลื่อนไหวนี้จะซ่อนจากนักพัฒนาแอปโดยสมบูรณ์ ซึ่งหมายความว่าเบราว์เซอร์จะใช้เทคนิคต่างๆ เช่น การเร่ง GPU เพื่อให้บรรลุเป้าหมายที่กำหนดไว้ได้

มี Flag บรรทัดคำสั่ง 2 รายการที่มีประโยชน์สำหรับ Chrome เพื่อช่วยแก้ไขข้อบกพร่องในการเร่งความเร็ว GPU ดังนี้

  1. --show-composited-layer-borders แสดงเส้นขอบสีแดงรอบองค์ประกอบที่กำลังถูกจัดการที่ระดับ GPU เหมาะสำหรับการยืนยันว่าการจัดการเกิดขึ้นภายในเลเยอร์ GPU
  2. --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

เราเชื่อว่าคุณเคยสร้างภาพเคลื่อนไหวของตำแหน่ง x/y ขององค์ประกอบในหน้าเว็บมาก่อน คุณอาจจัดการพร็อพเพอร์ตี้ด้านซ้ายและด้านบนของสไตล์ในบรรทัด เมื่อใช้การเปลี่ยนรูปแบบ 2 มิติ เราสามารถใช้ฟังก์ชัน 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 2 มิติและการเปลี่ยน CSS หากเป็นเช่นนั้น เราจะใช้การแปลเพื่อเปลี่ยนตำแหน่ง หากมีการเคลื่อนไหวโดยใช้การเปลี่ยนภาพ ก็มีโอกาสสูงที่เบราว์เซอร์จะเร่งฮาร์ดแวร์ได้ หากต้องการให้เบราว์เซอร์ทำงานได้ถูกต้องมากขึ้น เราจะใช้ "สัญลักษณ์หัวข้อย่อย CSS มหัศจรรย์" จากด้านบน

หากเบราว์เซอร์ของเรามีความสามารถน้อยกว่า เราจะใช้ jQuery เพื่อย้ายองค์ประกอบ คุณสามารถเลือกใช้ปลั๊กอิน Polyfill ของ jQuery Transform โดย Louis-Remi Babe เพื่อทำให้กระบวนการทั้งหมดนี้เป็นแบบอัตโนมัติ

window.requestAnimationFrame

requestAnimationFrame ได้รับการแนะนำโดย Mozilla และทำซ้ำโดย WebKit โดยมีเป้าหมายเพื่อมอบ API แบบเนทีฟสำหรับการเรียกใช้ภาพเคลื่อนไหว ไม่ว่าจะเป็นแบบ DOM/CSS หรือใน <canvas> หรือ WebGL เบราว์เซอร์สามารถเพิ่มประสิทธิภาพภาพเคลื่อนไหวที่เกิดขึ้นพร้อมกันให้เป็นวงจรการจัดเรียงใหม่และการวาดใหม่เพียงวงจรเดียว ซึ่งจะทำให้ภาพเคลื่อนไหวมีคุณภาพสูงขึ้น เช่น ภาพเคลื่อนไหวที่ใช้ JS ซึ่งซิงค์กับการเปลี่ยน CSS หรือ SVG SMIL นอกจากนี้ หากคุณเรียกใช้ลูปภาพเคลื่อนไหวในแท็บที่มองไม่เห็น เบราว์เซอร์จะไม่ทำให้ลูปทำงานต่อไป ซึ่งหมายความว่าการใช้งาน CPU, GPU และหน่วยความจำจะลดลง ส่งผลให้แบตเตอรี่ใช้งานได้นานขึ้นมาก

ดูรายละเอียดเพิ่มเติมเกี่ยวกับวิธีและเหตุผลในการใช้ requestAnimationFrame ได้ที่บทความ requestAnimationFrame for smart animating ของ Paul Irish

การทำโปรไฟล์

เมื่อพบว่าความเร็วของแอปพลิเคชันสามารถปรับปรุงได้ ก็ถึงเวลาเจาะลึกการทำโปรไฟล์เพื่อดูว่าการเพิ่มประสิทธิภาพจะให้ประโยชน์สูงสุดที่ใด การเพิ่มประสิทธิภาพมักส่งผลเสียต่อความสามารถในการบำรุงรักษาซอร์สโค้ด จึงควรใช้เมื่อจำเป็นเท่านั้น การทำโปรไฟล์จะบอกให้คุณทราบว่าโค้ดส่วนใดจะให้ประโยชน์สูงสุดเมื่อปรับปรุงประสิทธิภาพ

การสร้างโปรไฟล์ 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 ในลักษณะที่สิ้นเปลืองมาก

กลเม็ดเคล็ดลับ

ฟังก์ชันที่ไม่ระบุชื่อ

ฟังก์ชัน Anonymous ไม่ใช่เรื่องง่ายที่จะทำโปรไฟล์ เนื่องจากโดยเนื้อแท้แล้วไม่มีชื่อที่สามารถแสดงในเครื่องมือสร้างโปรไฟล์ได้ คุณสามารถแก้ปัญหานี้ได้ 2 วิธีดังนี้

$('.stuff').each(function() { ... });

เขียนใหม่เป็น:

$('.stuff').each(function workOnStuff() { ... });

โดยทั่วไปแล้ว ผู้คนไม่ค่อยทราบว่า JavaScript รองรับนิพจน์ฟังก์ชันที่มีชื่อ การดำเนินการนี้จะทำให้แสดงในเครื่องมือวิเคราะห์ได้อย่างสมบูรณ์แบบ วิธีแก้ปัญหานี้มีปัญหาอยู่ 1 อย่าง นั่นคือ นิพจน์ที่มีชื่อจะใส่ชื่อฟังก์ชันลงในขอบเขตคำศัพท์ปัจจุบันจริงๆ ซึ่งอาจทำให้สัญลักษณ์อื่นๆ เสียหายได้ ดังนั้นโปรดระมัดระวัง

การทำโปรไฟล์ฟังก์ชันที่ใช้เวลานาน

สมมติว่าคุณมีฟังก์ชันที่ยาวและสงสัยว่าส่วนเล็กๆ ของฟังก์ชันนั้นอาจเป็นสาเหตุของปัญหาด้านประสิทธิภาพ คุณสามารถดูว่าส่วนใดเป็นปัญหาได้ 2 วิธีดังนี้

  1. วิธีที่ถูกต้อง: ปรับโครงสร้างโค้ดใหม่เพื่อไม่ให้มีฟังก์ชันที่ยาวเกินไป
  2. วิธีที่แย่ในการทำให้งานเสร็จคือการเพิ่มคำสั่งในรูปแบบของฟังก์ชันที่เรียกตัวเองซึ่งมีชื่อลงในโค้ด หากคุณระมัดระวังเล็กน้อย การดำเนินการนี้จะไม่เปลี่ยนความหมายและทำให้บางส่วนของฟังก์ชันปรากฏเป็นฟังก์ชันเดี่ยวๆ ในเครื่องมือวิเคราะห์ประสิทธิภาพ ดังนี้ js function myLongFunction() { ... (function doAPartOfTheWork() { ... })(); ... } อย่าลืมนำฟังก์ชันเพิ่มเติมเหล่านี้ออกหลังจากวิเคราะห์ประสิทธิภาพเสร็จแล้ว หรือแม้แต่ใช้ฟังก์ชันเหล่านี้เป็นจุดเริ่มต้นในการเปลี่ยนโครงสร้างภายในโค้ด

การทำโปรไฟล์ DOM

เครื่องมือสำหรับนักพัฒนาซอฟต์แวร์ Chrome Web Inspector เวอร์ชันล่าสุดมี "มุมมองไทม์ไลน์" ใหม่ซึ่งแสดงไทม์ไลน์ของการดำเนินการระดับต่ำที่เบราว์เซอร์ทำ คุณสามารถใช้ข้อมูลนี้เพื่อเพิ่มประสิทธิภาพการดำเนินการ DOM ได้ คุณควรตั้งเป้าที่จะลดจำนวน "การดำเนินการ" ที่เบราว์เซอร์ต้องทำขณะที่โค้ดทำงาน

มุมมองไทม์ไลน์สามารถสร้างข้อมูลจำนวนมหาศาลได้ ดังนั้น คุณควรพยายามสร้างกรอบการทดสอบขั้นต่ำที่สามารถดำเนินการได้อย่างอิสระ

การทำโปรไฟล์ DOM

รูปภาพด้านบนแสดงเอาต์พุตของมุมมองไทม์ไลน์สำหรับสคริปต์ที่เรียบง่าย แผงด้านซ้ายแสดงการดำเนินการที่เบราว์เซอร์ทำตามลำดับเวลา ส่วนไทม์ไลน์ในแผงด้านขวาแสดงเวลาจริงที่ใช้ในการดำเนินการแต่ละรายการ

ข้อมูลเพิ่มเติมเกี่ยวกับมุมมองไทม์ไลน์ เครื่องมือทางเลือกสำหรับการทำโปรไฟล์ใน Internet Explorer คือ DynaTrace Ajax Edition

กลยุทธ์การทำโปรไฟล์

แยกแยะแง่มุมต่างๆ

เมื่อต้องการทำโปรไฟล์แอปพลิเคชัน ให้พยายามแยกแยะแง่มุมของฟังก์ชันการทำงานที่อาจทำให้เกิดความล่าช้าให้ใกล้เคียงที่สุด จากนั้นลองเรียกใช้โปรไฟล์ที่เรียกใช้เฉพาะส่วนของโค้ดที่เกี่ยวข้องกับแง่มุมเหล่านี้ของแอปพลิเคชัน วิธีนี้จะช่วยให้ตีความข้อมูลการทำโปรไฟล์ได้ง่ายขึ้น เนื่องจากไม่ได้ผสมกับเส้นทางโค้ดที่ไม่เกี่ยวข้องกับปัญหาที่เกิดขึ้นจริง ตัวอย่างที่ดีสำหรับแง่มุมต่างๆ ของแอปพลิเคชันอาจเป็นดังนี้

  1. เวลาเริ่มต้น (เปิดใช้งานเครื่องมือวิเคราะห์ประสิทธิภาพ โหลดแอปพลิเคชันซ้ำ รอจนกว่าการเริ่มต้นจะเสร็จสมบูรณ์ หยุดเครื่องมือวิเคราะห์ประสิทธิภาพ
  2. คลิกปุ่มและภาพเคลื่อนไหวที่ตามมา (เริ่มเครื่องมือวิเคราะห์ คลิกปุ่ม รอจนกว่าภาพเคลื่อนไหวจะเสร็จสมบูรณ์ หยุดเครื่องมือวิเคราะห์)
การทำโปรไฟล์ GUI

การเรียกใช้เฉพาะส่วนที่เหมาะสมของแอปพลิเคชันอาจทำได้ยากกว่าในโปรแกรม GUI เมื่อเทียบกับการเพิ่มประสิทธิภาพ เช่น Ray Tracer ของเครื่องมือ 3 มิติ ตัวอย่างเช่น เมื่อต้องการทำโปรไฟล์สิ่งที่เกิดขึ้นเมื่อคลิกปุ่ม คุณอาจทริกเกอร์เหตุการณ์การวางเมาส์เหนือสิ่งต่างๆ ที่ไม่เกี่ยวข้องไปพร้อมกัน ซึ่งทำให้ผลลัพธ์สรุปได้ยากขึ้น พยายามหลีกเลี่ยงการทำเช่นนั้น :)

อินเทอร์เฟซแบบเป็นโปรแกรม

นอกจากนี้ยังมีอินเทอร์เฟซแบบเป็นโปรแกรมเพื่อเปิดใช้งานโปรแกรมแก้ไขข้อบกพร่องด้วย ซึ่งจะช่วยให้ควบคุมได้อย่างแม่นยำว่าการสร้างโปรไฟล์จะเริ่มและสิ้นสุดเมื่อใด

เริ่มการทำโปรไฟล์ด้วย:

console.profile()

หยุดการทำโปรไฟล์ด้วย:

console.profileEnd()

ความสามารถในการทำซ้ำ

เมื่อทำการโปรไฟล์ ให้ตรวจสอบว่าคุณสามารถจำลองผลลัพธ์ได้จริง เมื่อทำเช่นนี้แล้ว คุณจึงจะบอกได้ว่าการเพิ่มประสิทธิภาพช่วยปรับปรุงสิ่งต่างๆ ได้จริงหรือไม่ นอกจากนี้ การทำโปรไฟล์ระดับฟังก์ชันจะดำเนินการในบริบทของคอมพิวเตอร์ทั้งเครื่อง ซึ่งไม่ใช่เรื่องที่แน่นอน การเรียกใช้โปรไฟล์แต่ละรายการอาจได้รับอิทธิพลจากสิ่งอื่นๆ อีกมากมายที่เกิดขึ้นในคอมพิวเตอร์ของคุณ เช่น

  1. ตัวจับเวลาที่ไม่เกี่ยวข้องในแอปพลิเคชันของคุณเองซึ่งเริ่มทำงานขณะที่คุณวัดสิ่งอื่น
  2. เครื่องมือเก็บหน่วยความจำแอปกำลังทำงาน
  3. แท็บอื่นในเบราว์เซอร์กำลังทำงานหนักในชุดข้อความการทำงานเดียวกัน
  4. โปรแกรมอื่นในคอมพิวเตอร์ใช้ CPU จนหมด ทำให้แอปพลิเคชันทำงานช้าลง
  5. การเปลี่ยนแปลงอย่างกะทันหันในสนามแรงโน้มถ่วงของโลก

นอกจากนี้ การเรียกใช้เส้นทางโค้ดเดียวกันหลายครั้งในเซสชันการทำโปรไฟล์เดียวก็เป็นเรื่องที่สมเหตุสมผล วิธีนี้จะช่วยลดอิทธิพลของปัจจัยข้างต้น และส่วนที่ช้าอาจโดดเด่นยิ่งขึ้น

วัดผล ปรับปรุง วัดผล

เมื่อระบุจุดที่ช้าในโปรแกรมได้แล้ว ให้ลองคิดหาวิธีปรับปรุงลักษณะการทำงานของการดำเนินการ หลังจากเปลี่ยนโค้ดแล้ว ให้ทำโปรไฟล์อีกครั้ง หากพอใจกับผลลัพธ์ ให้ดำเนินการต่อ หากไม่เห็นการปรับปรุง คุณควรย้อนกลับการเปลี่ยนแปลงและไม่ปล่อยทิ้งไว้ "เพราะไม่เป็นไร"

กลยุทธ์การเพิ่มประสิทธิภาพ

ลดการโต้ตอบ 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 โดยหลักการแล้ว คุณควรจัดกลุ่มโค้ดเป็น 2 ระยะเสมอ ดังนี้

  • ระยะที่ 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() จากด้านบนจะสร้างรูปภาพนี้

paintSlow()

การเปลี่ยนไปใช้การติดตั้งใช้งานที่เร็วขึ้นจะทำให้ได้รูปภาพนี้

การนำไปใช้งานที่รวดเร็วยิ่งขึ้น

รูปภาพเหล่านี้แสดงให้เห็นว่าการจัดเรียงวิธีที่โค้ดเข้าถึง DOM ใหม่จะช่วยเพิ่มประสิทธิภาพการแสดงผลได้อย่างมาก ในกรณีนี้ โค้ดเดิมจะต้องคำนวณสไตล์และเลย์เอาต์หน้าเว็บใหม่ 2 ครั้งเพื่อสร้างผลลัพธ์เดียวกัน การเพิ่มประสิทธิภาพที่คล้ายกันนี้สามารถนำไปใช้กับโค้ด "ในชีวิตจริง" ทั้งหมดและให้ผลลัพธ์ที่น่าทึ่งได้

อ่านเพิ่มเติม: การแสดงผล: การวาดใหม่ การจัดเรียงใหม่/การจัดเลย์เอาต์ใหม่ การจัดสไตล์ใหม่ โดย Stoyan Stefanov

การวาดใหม่และวนรอบเหตุการณ์

การดำเนินการ JavaScript ในเบราว์เซอร์จะเป็นไปตามโมเดล "วนรอบเหตุการณ์" โดยค่าเริ่มต้น เบราว์เซอร์จะอยู่ในสถานะ "ไม่มีการใช้งาน" สถานะนี้อาจถูกขัดจังหวะด้วยเหตุการณ์จากการโต้ตอบของผู้ใช้หรือสิ่งต่างๆ เช่น ตัวจับเวลา JavaScript หรือ Callback ของ Ajax เมื่อใดก็ตามที่ JavaScript ทำงานที่จุดขัดจังหวะดังกล่าว โดยปกติแล้วเบราว์เซอร์จะรอให้ JavaScript ทำงานเสร็จจนกว่าจะวาดหน้าจอใหม่ (อาจมีข้อยกเว้นสำหรับ JavaScript ที่ทำงานเป็นเวลานานมาก หรือในกรณีต่างๆ เช่น กล่องแจ้งเตือนที่ขัดจังหวะการทำงานของ JavaScript อย่างมีประสิทธิภาพ)

ผลที่ตามมา

  1. หากรอบภาพเคลื่อนไหว JavaScript ใช้เวลาดำเนินการนานกว่า 1/30 วินาที คุณจะสร้างภาพเคลื่อนไหวที่ราบรื่นไม่ได้เนื่องจากเบราว์เซอร์จะไม่วาดใหม่ระหว่างการดำเนินการ JS เมื่อคุณคาดว่าจะต้องจัดการเหตุการณ์ของผู้ใช้ด้วย คุณจะต้องดำเนินการให้เร็วขึ้นมาก
  2. บางครั้งการเลื่อนการดำเนินการ JavaScript บางอย่างออกไปสักครู่ก็มีประโยชน์ เช่น setTimeout(function() { ... }, 0) ซึ่งจะบอกให้เบราว์เซอร์เรียกใช้ Callback ทันทีที่วนรอบเหตุการณ์ไม่มีการทำงานอีกครั้ง (เบราว์เซอร์บางตัวจะรออย่างน้อย 10 มิลลิวินาที) คุณต้องทราบว่าการดำเนินการนี้จะสร้างรอบการดำเนินการ JavaScript 2 รอบซึ่งมีเวลาใกล้เคียงกันมาก ทั้ง 2 อย่างอาจทริกเกอร์การวาดหน้าจอใหม่ ซึ่งอาจเพิ่มเวลาที่ใช้ในการวาดโดยรวมเป็น 2 เท่า การดำเนินการนี้จะทริกเกอร์การแสดงผล 2 ครั้งจริงหรือไม่นั้นขึ้นอยู่กับฮิวริสติกในเบราว์เซอร์

เวอร์ชันปกติ:

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)
}
ล่าช้า

เวอร์ชันที่ล่าช้าแสดงให้เห็นว่าเบราว์เซอร์แสดงผล 2 ครั้ง แม้ว่าการเปลี่ยนแปลง 2 ครั้งในหน้าเว็บจะห่างกันเพียง 1/100 วินาทีก็ตาม

การเริ่มต้นแบบ Lazy

ผู้ใช้ต้องการเว็บแอปที่โหลดเร็วและตอบสนองได้ดี อย่างไรก็ตาม ผู้ใช้มีเกณฑ์ที่แตกต่างกันในการรับรู้ว่าสิ่งใดช้า โดยขึ้นอยู่กับการดำเนินการที่ทำ เช่น แอปไม่ควรทำการประมวลผลจำนวนมากในเหตุการณ์เมาส์โอเวอร์ เนื่องจากอาจสร้างประสบการณ์ของผู้ใช้ที่ไม่ดีขณะที่ผู้ใช้ยังคงเลื่อนเมาส์ต่อไป อย่างไรก็ตาม ผู้ใช้คุ้นเคยกับการยอมรับความล่าช้าเล็กน้อยหลังจากคลิกปุ่ม

ดังนั้นจึงควรย้ายโค้ดการเริ่มต้นให้ทำงานช้าที่สุดเท่าที่จะเป็นไปได้ (เช่น เมื่อผู้ใช้คลิกปุ่มที่เปิดใช้งานคอมโพเนนต์หนึ่งๆ ของแอปพลิเคชัน)

ก่อน: js var things = $('.ele > .other * div.className'); $('#button').click(function() { things.show() });

หลังวันที่ js $('#button').click(function() { $('.ele > .other * div.className').show() });

การมอบสิทธิ์เหตุการณ์

การกระจายเครื่องจัดการเหตุการณ์ไปทั่วทั้งหน้าอาจใช้เวลานานและอาจน่าเบื่อเมื่อมีการแทนที่องค์ประกอบแบบไดนามิก ซึ่งจะต้องแนบเครื่องจัดการเหตุการณ์กับองค์ประกอบใหม่อีกครั้ง

วิธีแก้ปัญหาในกรณีนี้คือการใช้เทคนิคที่เรียกว่าการมอบสิทธิ์เหตุการณ์ แทนที่จะแนบเครื่องจัดการเหตุการณ์แต่ละรายการกับองค์ประกอบ ระบบจะใช้ลักษณะการส่งต่อเหตุการณ์ของเบราว์เซอร์จำนวนมากโดยแนบเครื่องจัดการเหตุการณ์กับโหนดหลักและตรวจสอบโหนดเป้าหมายของเหตุการณ์เพื่อดูว่าเหตุการณ์นั้นเป็นที่สนใจหรือไม่

ใน jQuery สามารถแสดงนิพจน์นี้ได้อย่างง่ายดายดังนี้

$('#parentNode').delegate('.button', 'click', function() { ... });

กรณีที่ไม่ควรใช้การมอบสิทธิ์เหตุการณ์

บางครั้งอาจเกิดกรณีตรงกันข้าม นั่นคือคุณใช้การมอบสิทธิ์เหตุการณ์และพบปัญหาด้านประสิทธิภาพ โดยพื้นฐานแล้ว การมอบสิทธิ์เหตุการณ์จะช่วยให้เวลาในการเริ่มต้นมีความซับซ้อนคงที่ อย่างไรก็ตาม คุณจะต้องจ่ายค่าตรวจสอบว่าเหตุการณ์เป็นที่สนใจหรือไม่สำหรับการเรียกใช้เหตุการณ์นั้นทุกครั้ง ซึ่งอาจมีค่าใช้จ่ายสูง โดยเฉพาะอย่างยิ่งสำหรับเหตุการณ์ที่เกิดขึ้นบ่อยๆ เช่น "mouseover" หรือแม้แต่ "mousemove"

ปัญหาทั่วไปและวิธีแก้ไข

สิ่งที่ฉันทำใน $(document).ready ใช้เวลานาน

คำแนะนำส่วนตัวของ Malte: อย่าทำอะไรใน $(document).ready พยายามส่งเอกสารในรูปแบบสุดท้าย คุณสามารถลงทะเบียน Listener เหตุการณ์ได้ แต่ต้องใช้ตัวเลือกรหัสและ/หรือการมอบสิทธิ์เหตุการณ์เท่านั้น สำหรับเหตุการณ์ที่ใช้ทรัพยากรมาก เช่น "mousemove" ให้เลื่อนการลงทะเบียนออกไปจนกว่าจะจำเป็น (เหตุการณ์ mouseover ในองค์ประกอบที่เกี่ยวข้อง)

และหากคุณจำเป็นต้องดำเนินการบางอย่าง เช่น ส่งคำขอ Ajax เพื่อรับข้อมูลจริง ให้แสดงภาพเคลื่อนไหวที่สวยงาม คุณอาจต้องการรวมภาพเคลื่อนไหวเป็น URI ข้อมูลหากเป็น GIF ภาพเคลื่อนไหว หรืออื่นๆ ที่คล้ายกัน

ตั้งแต่ฉันเพิ่มภาพยนตร์ Flash ลงในหน้าเว็บ ทุกอย่างก็ช้าไปหมด

การเพิ่ม Flash ลงในหน้าเว็บจะทำให้การแสดงผลช้าลงเล็กน้อยเสมอ เนื่องจากเลย์เอาต์สุดท้ายของหน้าต่างต้องมีการ "เจรจา" ระหว่างเบราว์เซอร์กับปลั๊กอิน Flash หากหลีกเลี่ยงการใส่ Flash ในหน้าเว็บไม่ได้ ให้ตรวจสอบว่าคุณได้ตั้งค่าพารามิเตอร์ Flash "wmode" เป็นค่า "window" (ซึ่งเป็นค่าเริ่มต้น) ซึ่งจะปิดใช้ความสามารถในการรวมองค์ประกอบ HTML และ Flash (คุณจะไม่เห็นองค์ประกอบ HTML ที่อยู่เหนือภาพยนตร์ Flash และภาพยนตร์ Flash จะโปร่งใสไม่ได้) ซึ่งอาจทำให้คุณไม่สะดวก แต่จะช่วยปรับปรุงประสิทธิภาพได้อย่างมาก ตัวอย่างเช่น ลองดูวิธีที่ youtube.com หลีกเลี่ยงการวางเลเยอร์ไว้เหนือโปรแกรมเล่นวิดีโอหลักอย่างระมัดระวัง

ฉันกำลังบันทึกข้อมูลลงใน localStorage แต่ตอนนี้แอปพลิเคชันของฉันทำงานติดขัด

การเขียนไปยัง localStorage เป็นการดำเนินการแบบซิงโครนัสที่เกี่ยวข้องกับการหมุนฮาร์ดดิสก์ คุณไม่ควรดำเนินการแบบซิงโครนัสที่ "ใช้เวลานาน" ขณะแสดงภาพเคลื่อนไหว ย้ายการเข้าถึง localStorage ไปยังจุดในโค้ดที่คุณแน่ใจว่าผู้ใช้ไม่มีการใช้งานและไม่มีภาพเคลื่อนไหวใดๆ ทำงานอยู่

การทำโปรไฟล์ชี้ให้เห็นว่าตัวเลือก jQuery ทำงานช้ามาก

ก่อนอื่น คุณต้องตรวจสอบว่าตัวเลือกสามารถเรียกใช้ผ่าน document.querySelectorAll ได้ คุณทดสอบได้ในคอนโซล JavaScript หากมีข้อยกเว้น ให้เขียนตัวเลือกใหม่เพื่อไม่ให้ใช้ส่วนขยายพิเศษของเฟรมเวิร์ก JavaScript ซึ่งจะช่วยเพิ่มความเร็วให้ตัวเลือกในเบราว์เซอร์ที่ทันสมัยได้เป็นอย่างมาก

หากวิธีนี้ไม่ได้ผลหรือหากคุณต้องการให้เว็บไซต์ทำงานได้รวดเร็วในเบราว์เซอร์ที่ทันสมัยด้วย ให้ทำตามหลักเกณฑ์ต่อไปนี้

  • ระบุข้อมูลทางด้านขวาของตัวเลือกให้เจาะจงที่สุดเท่าที่จะทำได้
  • ใช้ชื่อแท็กที่คุณไม่ได้ใช้บ่อยเป็นส่วนตัวเลือกด้านขวาสุด
  • หากไม่มีวิธีใดช่วยได้ ให้ลองเขียนโค้ดใหม่เพื่อให้ใช้ตัวเลือกรหัสได้

การจัดการ DOM ทั้งหมดนี้ใช้เวลานาน

การแทรก การนำออก และการอัปเดตโหนด DOM จำนวนมากอาจช้ามาก โดยทั่วไปแล้ว ปัญหานี้สามารถเพิ่มประสิทธิภาพได้โดยการสร้างสตริง HTML ขนาดใหญ่และใช้ domNode.innerHTML = newHTML เพื่อแทนที่เนื้อหาเก่า โปรดทราบว่าวิธีนี้อาจส่งผลเสียต่อความสามารถในการบำรุงรักษาและอาจสร้างลิงก์หน่วยความจำใน IE ดังนั้นโปรดใช้ความระมัดระวัง

ปัญหาที่พบได้ทั่วไปอีกอย่างหนึ่งคือโค้ดการเริ่มต้นอาจสร้าง HTML จำนวนมาก เช่น ปลั๊กอิน jQuery ที่เปลี่ยนช่องเลือกเป็น div จำนวนมาก เนื่องจากเป็นสิ่งที่นักออกแบบต้องการโดยไม่สนใจแนวทางปฏิบัติแนะนำด้าน UX หากต้องการให้หน้าเว็บโหลดเร็ว อย่าทำเช่นนั้นโดยเด็ดขาด แต่ให้แสดงมาร์กอัปทั้งหมดจากฝั่งเซิร์ฟเวอร์ในรูปแบบสุดท้ายแทน วิธีนี้ก็มีปัญหาหลายอย่างเช่นกัน ดังนั้นโปรดพิจารณาให้ดีว่าความเร็วคุ้มค่ากับสิ่งที่ต้องแลกหรือไม่

เครื่องมือ

  1. JSPerf - เปรียบเทียบข้อมูลโค้ด JavaScript ขนาดเล็ก
  2. Firebug - สำหรับการทำโปรไฟล์ใน Firefox
  3. เครื่องมือสำหรับนักพัฒนาซอฟต์แวร์ Google Chrome (ใช้ได้ในชื่อ WebInspector ใน Safari)
  4. DOM Monster - สำหรับการเพิ่มประสิทธิภาพ DOM
  5. DynaTrace Ajax Edition - สำหรับการทำโปรไฟล์และการเพิ่มประสิทธิภาพการแสดงผลใน Internet Explorer

อ่านเพิ่มเติม

  1. Google Speed
  2. Paul Irish on jQuery Performance
  3. ประสิทธิภาพ JavaScript ขั้นสุด (ชุดสไลด์)