เพิ่มความเร็วของ Service Worker ด้วยการโหลดการนำทางล่วงหน้า

การโหลดการนำทางล่วงหน้าช่วยให้คุณเอาชนะเวลาเริ่มต้นของ Service Worker ได้ด้วยการส่งคำขอแบบขนาน

Browser Support

  • Chrome: 59.
  • Edge: 18.
  • Firefox: 99.
  • Safari: 15.4.

Source

สรุป

ปัญหา

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

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

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

การเปิดเครื่อง SW
คำขอการนำทาง

คำขอเครือข่ายล่าช้าเนื่องจากการเปิดเครื่อง Service Worker

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

Facebook ได้แจ้งให้เราทราบถึงผลกระทบของปัญหานี้ และขอวิธีส่งคำขอการนำทางแบบคู่ขนาน ดังนี้

การเปิดเครื่อง SW
คำขอการนำทาง

การโหลดการนำทางล่วงหน้าช่วยแก้ปัญหานี้ได้

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

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

ต่อไปนี้เป็นวิดีโอที่แสดงการทำงานของ Service Worker ที่มีการหน่วงเวลาเริ่มต้น 500 มิลลิวินาทีโดยเจตนาโดยใช้ while-loop

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

เปิดใช้งานการโหลดการนำทางล่วงหน้า

addEventListener('activate',> event = {
  event.waitUntil(async function() {
    // Feature-detect
    if (self.registration.navigationPreload) {
      // Enable navigation preloads!
      await self.registration.navigationPreload.enable();
    }
  }());
});

คุณสามารถเรียกใช้ navigationPreload.enable() ได้ทุกเมื่อที่ต้องการ หรือปิดใช้ด้วย navigationPreload.disable() อย่างไรก็ตาม เนื่องจากเหตุการณ์ fetch ต้องใช้เหตุการณ์ดังกล่าว คุณจึงควรเปิดและปิดใช้ในเหตุการณ์ activate ของ Service Worker

การใช้คำตอบที่โหลดไว้ล่วงหน้า

ตอนนี้เบราว์เซอร์จะทำการโหลดล่วงหน้าสำหรับการนำทาง แต่คุณยังคงต้องใช้การตอบกลับ ดังนี้

addEventListener('fetch',> event = {
  event.respondWith(async function() {
    // Respond from the cache if we can
    const cachedResponse = await caches.match(event.request);
    if (cachedResponse) return cachedResponse;

    // Else, use the preloaded response, if it's there
    const response = await event.preloadResponse;
    if (response) return response;

    // Else try the network.
    return fetch(event.request);
  }());
});

event.preloadResponse คือสัญญาที่ได้รับการแก้ไขด้วยการตอบกลับ หากเป็นไปตามเงื่อนไขต่อไปนี้

  • เปิดใช้การโหลดการนำทางล่วงหน้าแล้ว
  • คำขอดังกล่าวเป็นคำขอGET
  • คำขอเป็นคำขอการนำทาง (ซึ่งเบราว์เซอร์สร้างขึ้นเมื่อโหลดหน้าเว็บ รวมถึง iframe)

มิเช่นนั้น event.preloadResponse จะยังคงอยู่ แต่จะแก้ไขด้วย undefined

หากหน้าเว็บต้องการข้อมูลจากเครือข่าย วิธีที่เร็วที่สุดคือการขอข้อมูลใน Service Worker และสร้างการตอบกลับแบบสตรีมรายการเดียวซึ่งมีส่วนต่างๆ จากแคชและส่วนต่างๆ จากเครือข่าย

สมมติว่าเราต้องการแสดงบทความต่อไปนี้

addEventListener('fetch',> event = {
  const url = new URL(event.request.url);
  const includeURL = new URL(url);
  includeURL.pathname += 'include';

  if (isArticleURL(url)) {
    event.respondWith(async function() {
      // We're going to build a single request from multiple parts.
      const parts = [
        // The top of the page.
        caches.match('/article-top.include'),
        // The primary content
        fetch(includeURL)
          // A fallback if the network >fails.
          .catch(() = caches.match('/article-offline.include')),
        // The bottom of the page
        caches.match('/article-bottom.include')
      ];

      // Merge them all together.
      const {done, response} = await mergeResponses(parts);

      // Wait until the stream is complete.
      event.waitUntil(done);

      // Return the merged response.
      return response;
    }());
  }
});

ในตัวอย่างข้างต้น mergeResponses เป็นฟังก์ชันเล็กๆ ที่ผสานสตรีมของคำขอแต่ละรายการ ซึ่งหมายความว่าเราสามารถแสดงส่วนหัวที่แคชไว้ขณะที่เนื้อหาเครือข่ายสตรีมเข้ามาได้

วิธีนี้เร็วกว่าโมเดล "App Shell" เนื่องจากคำขอเครือข่ายจะส่งไปพร้อมกับคำขอหน้าเว็บ และเนื้อหาจะสตรีมได้โดยไม่ต้องใช้การแฮ็กครั้งใหญ่

อย่างไรก็ตาม คำขอ includeURL จะล่าช้าตามเวลาเริ่มต้นของ Service Worker เราสามารถใช้การโหลดการนำทางล่วงหน้าเพื่อแก้ไขปัญหานี้ได้เช่นกัน แต่ในกรณีนี้เราไม่ต้องการโหลดทั้งหน้าล่วงหน้า แต่ต้องการโหลดส่วนที่รวมไว้ล่วงหน้า

เพื่อรองรับการดำเนินการนี้ ระบบจะส่งส่วนหัวพร้อมกับคำขอโหลดล่วงหน้าทุกรายการ ดังนี้

Service-Worker-Navigation-Preload: true

เซิร์ฟเวอร์สามารถใช้ข้อมูลนี้เพื่อส่งเนื้อหาที่แตกต่างกันสำหรับคำขอโหลดการนำทางล่วงหน้าเมื่อเทียบกับคำขอการนำทางปกติ อย่าลืมเพิ่มส่วนหัว Vary: Service-Worker-Navigation-Preload เพื่อให้แคชทราบว่าการตอบกลับของคุณแตกต่างกัน

ตอนนี้เราสามารถใช้คำขอโหลดล่วงหน้าได้แล้ว

// Try to use the preload
const networkContent = Promise.resolve(event.preloadResponse)
  // Else do a normal fetch
  .then(r => r || fetch(includeURL))
  // A fallback if the network fails.
  .catch(() => caches.match('/article-offline.include'));

const parts = [
  caches.match('/article-top.include'),
  networkContent,
  caches.match('/article-bottom')
];

เปลี่ยนส่วนหัว

โดยค่าเริ่มต้น ค่าของส่วนหัว Service-Worker-Navigation-Preload คือ true แต่คุณสามารถตั้งค่าเป็นค่าใดก็ได้ตามต้องการ ดังนี้

navigator.serviceWorker.ready.then(registration => {
  return registration.navigationPreload.setHeaderValue(newValue);
}).then(() => {
  console.log('Done!';);
});

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

กำลังรับสถานะ

คุณสามารถค้นหาสถานะของการโหลดการนำทางล่วงหน้าได้โดยใช้ getState ดังนี้

navigator.serviceWorker.ready.then(registration => {
  return registration.navigationPreload.getState();
}).then(state => {
  console.log(state.enabled); // boolean
  console.log(state.headerValue); // string
});

ขอขอบคุณ Matt Falkenhagen และ Tsuyoshi Horo เป็นอย่างยิ่งที่ได้พัฒนาฟีเจอร์นี้และช่วยเขียนบทความนี้ และขอขอบคุณทุกคนที่มีส่วนร่วมในการสร้างมาตรฐาน