วงจรของ Service Worker เป็นส่วนที่ซับซ้อนที่สุด หากคุณไม่รู้ว่าระบบพยายามทำอะไรและมีประโยชน์อย่างไร คุณอาจรู้สึกว่าระบบกำลังต่อต้านคุณอยู่ แต่เมื่อทราบวิธีการทำงานแล้ว คุณจะสามารถส่งมอบการอัปเดตที่ราบรื่นและไม่รบกวนผู้ใช้ โดยผสมผสานรูปแบบเว็บและรูปแบบเนทีฟที่ดีที่สุดเข้าด้วยกัน
แม้ว่านี่จะเป็นข้อมูลเจาะลึก แต่หัวข้อย่อยที่จุดเริ่มต้นของแต่ละส่วนก็ครอบคลุมข้อมูลส่วนใหญ่ที่คุณจำเป็นต้องทราบ
ความตั้งใจ
วัตถุประสงค์ของวงจรนี้คือเพื่อ
- ทำให้การทำงานแบบออฟไลน์เป็นหลักเป็นไปได้
- อนุญาตให้ Service Worker ใหม่เตรียมพร้อมโดยไม่รบกวน Service Worker ปัจจุบัน
- ตรวจสอบว่าหน้าเว็บที่อยู่ในขอบเขตได้รับการควบคุมโดย Service Worker เดียวกัน (หรือไม่มี Service Worker) ตลอดทั้งหน้า
- ตรวจสอบว่าเว็บไซต์ของคุณทำงานเพียงเวอร์ชันเดียวในแต่ละครั้ง
ข้อสุดท้ายนี้สำคัญมาก หากไม่มี Service Worker ผู้ใช้จะโหลดแท็บหนึ่งไปยังเว็บไซต์ของคุณ แล้วเปิดอีกแท็บหนึ่งในภายหลังได้ ซึ่งอาจส่งผลให้เว็บไซต์ทั้ง 2 เวอร์ชันทำงานพร้อมกัน บางครั้งก็ไม่มีปัญหาอะไร แต่หากคุณกำลังจัดการกับพื้นที่เก็บข้อมูล คุณอาจพบว่าแท็บ 2 แท็บมีความเห็นที่แตกต่างกันมากเกี่ยวกับวิธีจัดการพื้นที่เก็บข้อมูลที่ใช้ร่วมกัน ซึ่งอาจทำให้เกิดข้อผิดพลาด หรือที่แย่กว่านั้นคือข้อมูลรั่วไหล
Service Worker รายแรก
เคล็ดลับโดยสรุปมีดังนี้
- เหตุการณ์
installเป็นเหตุการณ์แรกที่ Service Worker ได้รับ และจะเกิดขึ้นเพียงครั้งเดียว - สัญญาที่ส่งไปยัง
installEvent.waitUntil()จะส่งสัญญาณระยะเวลาและความสำเร็จหรือความล้มเหลวของการติดตั้ง - Service Worker จะไม่ได้รับเหตุการณ์อย่าง
fetchและpushจนกว่าจะติดตั้งเสร็จสมบูรณ์และ "ทำงานอยู่" - โดยค่าเริ่มต้น การดึงข้อมูลของหน้าเว็บจะไม่ผ่าน Service Worker เว้นแต่คำขอหน้าเว็บจะผ่าน Service Worker ดังนั้นคุณจะต้องรีเฟรชหน้าเพื่อดูผลลัพธ์ของ Service Worker
clients.claim()สามารถลบล้างค่าเริ่มต้นนี้และควบคุมหน้าที่ไม่ได้ควบคุมได้
ใช้ HTML นี้
<!DOCTYPE html>
An image will appear here in 3 seconds:
<script>
navigator.serviceWorker.register('/sw.js')
.then(reg => console.log('SW registered!', reg))
.catch(err => console.log('Boo!', err));
setTimeout(() => {
const img = new Image();
img.src = '/dog.svg';
document.body.appendChild(img);
}, 3000);
</script>
โดยจะลงทะเบียน Service Worker และเพิ่มรูปภาพสุนัขหลังจากผ่านไป 3 วินาที
Service Worker ของเว็บไซต์ดังกล่าวคือ sw.js
self.addEventListener('install', event => {
console.log('V1 installing…');
// cache a cat SVG
event.waitUntil(
caches.open('static-v1').then(cache => cache.add('/cat.svg'))
);
});
self.addEventListener('activate', event => {
console.log('V1 now ready to handle fetches!');
});
self.addEventListener('fetch', event => {
const url = new URL(event.request.url);
// serve the cat SVG from the cache if the request is
// same-origin and the path is '/dog.svg'
if (url.origin == location.origin && url.pathname == '/dog.svg') {
event.respondWith(caches.match('/cat.svg'));
}
});
โดยจะแคชรูปภาพแมวและแสดงรูปภาพนั้นเมื่อใดก็ตามที่มีคำขอ /dog.svg อย่างไรก็ตาม หากคุณเรียกใช้ตัวอย่างข้างต้น คุณจะเห็นสุนัขในครั้งแรกที่โหลดหน้าเว็บ กดรีเฟรช แล้วคุณจะเห็นแมว
ขอบเขตและการควบคุม
ขอบเขตเริ่มต้นของการลงทะเบียน Service Worker คือ ./ ซึ่งสัมพันธ์กับ URL ของสคริปต์ ซึ่งหมายความว่าหากคุณลงทะเบียน Service Worker ที่ //example.com/foo/bar.js จะมีขอบเขตเริ่มต้นเป็น //example.com/foo/
เราเรียกหน้าเว็บ, Worker และ Shared Worker ว่าclients Service Worker ของคุณจะควบคุมได้เฉพาะไคลเอ็นต์ที่อยู่ในขอบเขตเท่านั้น เมื่อไคลเอ็นต์ถูก "ควบคุม" การดึงข้อมูลจะผ่าน Service Worker ที่อยู่ในขอบเขต คุณสามารถตรวจหาได้ว่าไคลเอ็นต์ได้รับการควบคุมผ่าน navigator.serviceWorker.controller หรือไม่ ซึ่งจะเป็นค่า Null หรืออินสแตนซ์ Worker ของบริการ
ดาวน์โหลด แยกวิเคราะห์ และดำเนินการ
Service Worker แรกสุดจะดาวน์โหลดเมื่อคุณเรียกใช้ .register() หากสคริปต์ดาวน์โหลด แยกวิเคราะห์ หรือแสดงข้อผิดพลาดในการดำเนินการครั้งแรกไม่สำเร็จ สัญญาการลงทะเบียนจะปฏิเสธ และระบบจะทิ้ง Service Worker
เครื่องมือสำหรับนักพัฒนาเว็บใน Chrome จะแสดงข้อผิดพลาดในคอนโซลและในส่วน Service Worker ของแท็บแอปพลิเคชัน ดังนี้
ติดตั้ง
เหตุการณ์แรกที่ Service Worker ได้รับคือ install โดยจะทริกเกอร์ทันทีที่เวิร์กเกอร์ทำงาน และจะเรียกใช้เพียงครั้งเดียวต่อ Service Worker หากคุณแก้ไขสคริปต์ Service Worker เบราว์เซอร์จะถือว่าเป็น Service Worker อื่น และจะได้รับเหตุการณ์ install ของตัวเอง เราจะพูดถึงรายละเอียดการอัปเดตในภายหลัง
เหตุการณ์ install เป็นโอกาสให้คุณแคชทุกอย่างที่ต้องการก่อนที่จะควบคุมไคลเอ็นต์ได้ Promise ที่คุณส่งไปยัง event.waitUntil() จะช่วยให้เบราว์เซอร์ทราบเมื่อการติดตั้งเสร็จสมบูรณ์ และทราบว่าการติดตั้งสำเร็จหรือไม่
หาก Promise ปฏิเสธ แสดงว่าการติดตั้งไม่สำเร็จ และเบราว์เซอร์จะทิ้ง Service Worker และจะไม่มีวันควบคุมไคลเอ็นต์ ซึ่งหมายความว่าเราสามารถใช้ cat.svg ที่มีอยู่ในแคชในเหตุการณ์ fetch ได้ ซึ่งเป็นการขึ้นต่อกัน
เปิดใช้งาน
เมื่อ Service Worker พร้อมที่จะควบคุมไคลเอ็นต์และจัดการเหตุการณ์ที่ทำงานได้ เช่น push และ sync คุณจะได้รับเหตุการณ์ activate แต่ไม่ได้หมายความว่าหน้าเว็บที่เรียก .register() จะได้รับการควบคุม
ครั้งแรกที่คุณโหลดเดโม แม้ว่าจะมีการขอ dog.svg เป็นเวลานานหลังจากที่ Service Worker เปิดใช้งาน แต่ก็ไม่ได้จัดการคำขอ และคุณยังคงเห็นรูปภาพสุนัข ค่าเริ่มต้นคือความสอดคล้อง หากการโหลดหน้าเว็บของคุณไม่มี Service Worker ทรัพยากรย่อยก็จะไม่โหลดเช่นกัน หากคุณโหลดเดโมเป็นครั้งที่ 2 (หรือพูดอีกอย่างคือรีเฟรชหน้า) ระบบจะควบคุมเดโมดังกล่าว ทั้งหน้าเว็บและรูปภาพจะผ่านเหตุการณ์ fetch และคุณจะเห็นแมวแทน
clients.claim
คุณสามารถควบคุมไคลเอ็นต์ที่ไม่มีการควบคุมได้โดยเรียกใช้ clients.claim() ภายใน Service Worker เมื่อเปิดใช้งานแล้ว
ต่อไปนี้คือรูปแบบต่างๆ ของการสาธิตด้านบนซึ่งเรียกใช้ clients.claim() ในเหตุการณ์ activate คุณควรเห็นแมวในครั้งแรก ที่บอกว่า "ควร" ก็เพราะว่าเรื่องนี้ขึ้นอยู่กับเวลา คุณจะเห็นแมวก็ต่อเมื่อ Service Worker เปิดใช้งานและ clients.claim() มีผลก่อนที่รูปภาพจะพยายามโหลด
หากคุณใช้ Service Worker เพื่อโหลดหน้าเว็บแตกต่างจากที่โหลดผ่านเครือข่าย clients.claim() อาจทำให้เกิดปัญหาได้ เนื่องจาก Service Worker จะควบคุมไคลเอ็นต์บางรายการที่โหลดโดยไม่มี Service Worker
กำลังอัปเดต Service Worker
เคล็ดลับโดยสรุปมีดังนี้
- ระบบจะทริกเกอร์การอัปเดตหากเกิดเหตุการณ์ต่อไปนี้
- การไปยังหน้าเว็บที่อยู่ในขอบเขต
- เหตุการณ์ที่เกี่ยวข้องกับฟังก์ชันการทำงาน เช่น
pushและsyncเว้นแต่จะมีการตรวจสอบการอัปเดตภายใน 24 ชั่วโมงที่ผ่านมา - การเรียกใช้
.register()เฉพาะในกรณีที่ URL ของ Service Worker มีการเปลี่ยนแปลง อย่างไรก็ตาม คุณควรหลีกเลี่ยงการเปลี่ยน URL ของ Worker
- เบราว์เซอร์ส่วนใหญ่ รวมถึง Chrome 68 ขึ้นไป จะละเว้นส่วนหัวของการแคชโดยค่าเริ่มต้นเมื่อตรวจหาการอัปเดตสคริปต์ Service Worker ที่ลงทะเบียนไว้ แต่จะยังคงใช้ส่วนหัวการแคชเมื่อดึงข้อมูลทรัพยากรที่โหลดภายใน Service Worker ผ่าน
importScripts()คุณลบล้างลักษณะการทำงานเริ่มต้นนี้ได้โดยตั้งค่าตัวเลือกupdateViaCacheเมื่อลงทะเบียน Service Worker - ระบบจะถือว่า Service Worker ได้รับการอัปเดตหากมีไบต์แตกต่างจากที่เบราว์เซอร์มีอยู่แล้ว (เรากำลังขยายการรองรับนี้ให้ครอบคลุมสคริปต์/โมดูลที่นำเข้าด้วย)
- Service Worker ที่อัปเดตจะเปิดขึ้นพร้อมกับ Service Worker ที่มีอยู่ และได้รับเหตุการณ์
installของตัวเอง - หาก Worker ใหม่มีรหัสสถานะที่ไม่ใช่ OK (เช่น 404) แยกวิเคราะห์ไม่สำเร็จ แสดงข้อผิดพลาดระหว่างการดำเนินการ หรือปฏิเสธระหว่างการติดตั้ง ระบบจะทิ้ง Worker ใหม่ แต่ Worker ปัจจุบันจะยังคงทำงานอยู่
- เมื่อติดตั้งเรียบร้อยแล้ว Worker ที่อัปเดตจะ
waitจนกว่า Worker ที่มีอยู่จะควบคุมไคลเอ็นต์เป็นศูนย์ (โปรดทราบว่าไคลเอ็นต์จะทับซ้อนกันระหว่างการรีเฟรช) self.skipWaiting()จะป้องกันการรอ ซึ่งหมายความว่า Service Worker จะเปิดใช้งานทันทีที่ติดตั้งเสร็จ
สมมติว่าเราเปลี่ยนสคริปต์ Service Worker ให้ตอบกลับด้วยรูปภาพม้าแทนแมว
const expectedCaches = ['static-v2'];
self.addEventListener('install', event => {
console.log('V2 installing…');
// cache a horse SVG into a new cache, static-v2
event.waitUntil(
caches.open('static-v2').then(cache => cache.add('/horse.svg'))
);
});
self.addEventListener('activate', event => {
// delete any caches that aren't in expectedCaches
// which will get rid of static-v1
event.waitUntil(
caches.keys().then(keys => Promise.all(
keys.map(key => {
if (!expectedCaches.includes(key)) {
return caches.delete(key);
}
})
)).then(() => {
console.log('V2 now ready to handle fetches!');
})
);
});
self.addEventListener('fetch', event => {
const url = new URL(event.request.url);
// serve the horse SVG from the cache if the request is
// same-origin and the path is '/dog.svg'
if (url.origin == location.origin && url.pathname == '/dog.svg') {
event.respondWith(caches.match('/horse.svg'));
}
});
ดูเดโมของฟีเจอร์ข้างต้น คุณควรจะยังเห็นรูปภาพแมวอยู่ โดยมีสาเหตุดังนี้…
ติดตั้ง
โปรดทราบว่าฉันได้เปลี่ยนชื่อแคชจาก static-v1 เป็น static-v2 แล้ว ซึ่งหมายความว่าฉันสามารถตั้งค่าแคชใหม่ได้โดยไม่ต้องเขียนทับสิ่งต่างๆ ในแคชปัจจุบัน ซึ่ง Service Worker เก่ายังคงใช้อยู่
รูปแบบนี้จะสร้างแคชเฉพาะเวอร์ชัน ซึ่งคล้ายกับเนื้อหาที่แอปที่มาพร้อมเครื่องจะรวมไว้กับไฟล์ปฏิบัติการ นอกจากนี้ คุณอาจมีแคชที่ไม่ได้เจาะจงเวอร์ชัน เช่น avatars
กำลังรอ
หลังจากติดตั้งเรียบร้อยแล้ว Service Worker ที่อัปเดตจะเลื่อนเวลาเปิดใช้งานออกไปจนกว่า Service Worker ที่มีอยู่จะไม่ควบคุมไคลเอ็นต์อีกต่อไป สถานะนี้เรียกว่า "กำลังรอ" และเป็นวิธีที่เบราว์เซอร์ใช้เพื่อให้แน่ใจว่ามี Service Worker เพียงเวอร์ชันเดียวที่ทำงานพร้อมกัน
หากเรียกใช้เดโมที่อัปเดตแล้ว คุณควรยังคงเห็นรูปภาพแมว เนื่องจาก Service Worker เวอร์ชัน 2 ยังไม่ได้เปิดใช้งาน คุณจะเห็น Service Worker ใหม่ที่รออยู่ในแท็บ "แอปพลิเคชัน" ของเครื่องมือสำหรับนักพัฒนาเว็บ
แม้ว่าคุณจะเปิดแท็บสาธิตไว้เพียงแท็บเดียว แต่การรีเฟรชหน้าเว็บก็ไม่เพียงพอที่จะทำให้เวอร์ชันใหม่เข้ามาแทนที่ได้ ซึ่งเป็นผลมาจากวิธีการทำงานของการไปยังส่วนต่างๆ ของเบราว์เซอร์ เมื่อคุณไปยังส่วนต่างๆ หน้าปัจจุบันจะไม่หายไปจนกว่าจะได้รับส่วนหัวการตอบกลับ และแม้ว่าหน้าปัจจุบันจะยังคงอยู่หากการตอบกลับมีส่วนหัว Content-Disposition เนื่องจากมีการทับซ้อนกันนี้ Service Worker ปัจจุบันจึงควบคุมไคลเอ็นต์ระหว่างการรีเฟรชเสมอ
หากต้องการรับการอัปเดต ให้ปิดหรือออกจากแท็บทั้งหมดที่ใช้ Service Worker ปัจจุบัน จากนั้นเมื่อไปยังหน้าสาธิตอีกครั้ง คุณควรเห็นม้า
รูปแบบนี้คล้ายกับวิธีที่ Chrome อัปเดต การอัปเดต Chrome จะดาวน์โหลดในเบื้องหลัง แต่จะไม่มีผลจนกว่าจะรีสตาร์ท Chrome ในระหว่างนี้ คุณจะใช้เวอร์ชันปัจจุบันต่อไปได้โดยไม่มีการหยุดชะงัก อย่างไรก็ตาม การดำเนินการนี้อาจเป็นเรื่องยุ่งยากในระหว่างการพัฒนา แต่เครื่องมือสำหรับนักพัฒนาเว็บมีวิธีที่ช่วยให้ดำเนินการได้ง่ายขึ้น ซึ่งเราจะพูดถึงในบทความนี้
เปิดใช้งาน
ซึ่งจะเริ่มทำงานเมื่อ Service Worker เก่าหายไป และ Service Worker ใหม่สามารถควบคุมไคลเอ็นต์ได้ นี่เป็นเวลาที่เหมาะสำหรับการดำเนินการต่างๆ ที่คุณทำไม่ได้ขณะที่ยังใช้ Worker เก่าอยู่ เช่น การย้ายฐานข้อมูลและการล้างแคช
ในการสาธิตด้านบน ฉันเก็บรักษารายการแคชที่คาดว่าจะมีไว้ และในเหตุการณ์ activate ฉันจะกำจัดแคชอื่นๆ ซึ่งจะนำแคช static-v1 เก่าออก
หากคุณส่ง Promise ไปยัง event.waitUntil() ระบบจะบัฟเฟอร์เหตุการณ์ที่เกี่ยวข้องกับฟังก์ชัน (fetch, push, sync ฯลฯ) จนกว่า Promise จะได้รับการแก้ไข ดังนั้นเมื่อเหตุการณ์ fetch เริ่มทำงาน การเปิดใช้งานจะเสร็จสมบูรณ์
ข้ามระยะเวลารอ
ระยะรอหมายความว่าคุณกำลังเรียกใช้เว็บไซต์เพียงเวอร์ชันเดียวในแต่ละครั้ง แต่หากไม่ต้องการฟีเจอร์ดังกล่าว คุณสามารถทำให้ Service Worker ใหม่เปิดใช้งานได้เร็วขึ้นโดยเรียกใช้ self.skipWaiting()
ซึ่งจะทำให้ Service Worker ไล่ Worker ที่ทำงานอยู่ในปัจจุบันออกและเปิดใช้งานตัวเองทันทีที่เข้าสู่ระยะรอ (หรือทันทีหากอยู่ในระยะรออยู่แล้ว) ซึ่งไม่ได้ทำให้ผู้ปฏิบัติงานข้ามการติดตั้ง แต่จะรอเท่านั้น
คุณจะเรียกใช้ skipWaiting() เมื่อใดก็ได้ ตราบใดที่เรียกใช้ระหว่างหรือก่อนการรอ โดยทั่วไปแล้วจะเรียกใช้ในเหตุการณ์ install ดังนี้
self.addEventListener('install', event => {
self.skipWaiting();
event.waitUntil(
// caching etc
);
});
แต่คุณอาจต้องการเรียกใช้เมธอดนี้เนื่องจากมีการเรียกใช้ postMessage() ไปยัง Service Worker เช่น คุณต้องการskipWaiting()หลังจากการโต้ตอบของผู้ใช้
นี่คือเดโมที่ใช้ skipWaiting() คุณจะเห็นรูปภาพวัวโดยไม่ต้องออกจากหน้าเว็บ เช่นเดียวกับ clients.claim() นี่คือการแข่งขัน ดังนั้นคุณจะเห็นวัวก็ต่อเมื่อ Service Worker ใหม่ดึงข้อมูล ติดตั้ง และเปิดใช้งานก่อนที่หน้าเว็บจะพยายามโหลดรูปภาพ
การอัปเดตด้วยตนเอง
ดังที่กล่าวไว้ก่อนหน้านี้ เบราว์เซอร์จะตรวจสอบการอัปเดตโดยอัตโนมัติหลังจากการนําทางและเหตุการณ์ที่ทํางาน แต่คุณก็ทริกเกอร์การอัปเดตด้วยตนเองได้เช่นกัน โดยทำดังนี้
navigator.serviceWorker.register('/sw.js').then(reg => {
// sometime later…
reg.update();
});
หากคาดว่าผู้ใช้จะใช้เว็บไซต์เป็นเวลานานโดยไม่โหลดซ้ำ คุณอาจต้องเรียกใช้ update() เป็นระยะๆ (เช่น ทุกชั่วโมง)
หลีกเลี่ยงการเปลี่ยน URL ของสคริปต์ Service Worker
หากคุณได้อ่านโพสต์ของฉันเกี่ยวกับแนวทางปฏิบัติแนะนำในการแคช คุณอาจพิจารณาให้ Service Worker แต่ละเวอร์ชันมี URL ที่ไม่ซ้ำกัน อย่าทำแบบนี้ ซึ่งมักเป็นแนวทางปฏิบัติที่ไม่ดีสำหรับ Service Worker เพียงแค่อัปเดตสคริปต์ที่ตำแหน่งปัจจุบัน
ซึ่งอาจทำให้คุณประสบปัญหาต่อไปนี้
index.htmlลงทะเบียนsw-v1.jsเป็น Service Workersw-v1.jsจะแคชและแสดงindex.htmlเพื่อให้ทำงานแบบออฟไลน์ก่อนได้- คุณอัปเดต
index.htmlเพื่อให้ลงทะเบียนsw-v2.jsใหม่ที่ยอดเยี่ยมของคุณ
หากคุณทำตามขั้นตอนข้างต้น ผู้ใช้จะไม่ได้รับ sw-v2.js เนื่องจาก sw-v1.js แสดง index.html เวอร์ชันเก่าจากแคช คุณได้ทำให้ตัวเองอยู่ในสถานการณ์ที่ต้องอัปเดต Service Worker เพื่ออัปเดต Service Worker แหวะ
อย่างไรก็ตาม สำหรับการสาธิตด้านบน ฉันได้เปลี่ยน URL ของ Service Worker ซึ่งจะช่วยให้คุณสลับไปมาระหว่างเวอร์ชันต่างๆ ได้เพื่อวัตถุประสงค์ในการสาธิต ซึ่งไม่ใช่สิ่งที่ฉันจะทำในเวอร์ชันที่ใช้งานจริง
ทำให้การพัฒนาเป็นเรื่องง่าย
วงจรของ Service Worker สร้างขึ้นโดยคำนึงถึงผู้ใช้ แต่ในระหว่างการพัฒนาอาจสร้างความยุ่งยากเล็กน้อย โชคดีที่มีเครื่องมือบางอย่างที่ช่วยได้ ดังนี้
อัปเดตเมื่อโหลดซ้ำ
ฉันชอบอันนี้ที่สุด
การเปลี่ยนแปลงนี้จะทำให้วงจรเป็นมิตรกับนักพัฒนาแอปมากขึ้น การไปยังส่วนต่างๆ แต่ละครั้งจะทำสิ่งต่อไปนี้
- ดึงข้อมูล Service Worker อีกครั้ง
- ติดตั้งเป็นเวอร์ชันใหม่แม้ว่าจะเป็นไบต์ที่เหมือนกัน ซึ่งหมายความว่าเหตุการณ์
installจะทำงานและแคชจะอัปเดต - ข้ามระยะรอเพื่อให้ Service Worker ใหม่เปิดใช้งาน
- ไปยังส่วนต่างๆ ของหน้าเว็บ
ซึ่งหมายความว่าคุณจะได้รับการอัปเดตในการไปยังส่วนต่างๆ แต่ละครั้ง (รวมถึงการรีเฟรช) โดยไม่ต้องโหลดซ้ำ 2 ครั้งหรือปิดแท็บ
ข้ามการรอ
หากมี Worker ที่รออยู่ คุณสามารถกด "ข้ามการรอ" ในเครื่องมือสำหรับนักพัฒนาเว็บเพื่อเลื่อนขั้นเป็น "ใช้งานอยู่" ได้ทันที
Shift-reload
หากคุณบังคับให้โหลดหน้าเว็บซ้ำ (Shift-Reload) ระบบจะข้าม Service Worker ไปเลย โดยจะไม่มีการควบคุม ฟีเจอร์นี้อยู่ในข้อกำหนดเฉพาะ จึงใช้งานได้ในเบราว์เซอร์อื่นๆ ที่รองรับ Service Worker
การจัดการการอัปเดต
Service Worker ได้รับการออกแบบให้เป็นส่วนหนึ่งของเว็บที่ขยายได้ แนวคิดก็คือเราในฐานะนักพัฒนาเบราว์เซอร์ยอมรับว่าเราไม่ได้พัฒนาเว็บได้ดีไปกว่านักพัฒนาเว็บ ดังนั้น เราจึงไม่ควรจัดเตรียม API ระดับสูงแบบแคบๆ ที่แก้ปัญหาเฉพาะโดยใช้รูปแบบที่เราชอบ แต่ควรให้คุณเข้าถึงส่วนสำคัญของเบราว์เซอร์และให้คุณทำสิ่งต่างๆ ได้ตามต้องการในลักษณะที่เหมาะกับผู้ใช้ของคุณมากที่สุด
ดังนั้น เพื่อให้สามารถใช้รูปแบบต่างๆ ได้มากที่สุดเท่าที่จะทำได้ คุณจึงสังเกตวงจรการอัปเดตทั้งหมดได้ดังนี้
navigator.serviceWorker.register('/sw.js').then(reg => {
reg.installing; // the installing worker, or undefined
reg.waiting; // the waiting worker, or undefined
reg.active; // the active worker, or undefined
reg.addEventListener('updatefound', () => {
// A wild service worker has appeared in reg.installing!
const newWorker = reg.installing;
newWorker.state;
// "installing" - the install event has fired, but not yet complete
// "installed" - install complete
// "activating" - the activate event has fired, but not yet complete
// "activated" - fully active
// "redundant" - discarded. Either failed install, or it's been
// replaced by a newer version
newWorker.addEventListener('statechange', () => {
// newWorker.state has changed
});
});
});
navigator.serviceWorker.addEventListener('controllerchange', () => {
// This fires when the service worker controlling this page
// changes, eg a new worker has skipped waiting and become
// the new active worker.
});
วงจรชีวิตดำเนินต่อไปเรื่อยๆ
อย่างที่คุณเห็น การทำความเข้าใจวงจรของ Service Worker นั้นมีประโยชน์ และเมื่อเข้าใจแล้ว พฤติกรรมของ Service Worker ก็จะดูสมเหตุสมผลมากขึ้นและลึกลับน้อยลง ความรู้นี้จะช่วยให้คุณมั่นใจมากขึ้นเมื่อติดตั้งใช้งานและอัปเดต Service Worker