Il ciclo di vita del service worker è la sua parte più complessa. Se non sai cosa sta cercando di fare e quali sono i vantaggi, può sembrare che stia lottando contro di te. Tuttavia, una volta compreso il funzionamento, puoi fornire agli utenti aggiornamenti fluidi e non invasivi, combinando il meglio dei pattern web e nativi.
Questo è un approfondimento, ma i punti elenco all'inizio di ogni sezione coprono la maggior parte di ciò che devi sapere.
L'intent
Lo scopo del ciclo di vita è:
- Rendi possibile l'approccio offline-first.
- Consenti a un nuovo service worker di prepararsi senza interrompere quello corrente.
- Assicurati che una pagina nell'ambito sia controllata dallo stesso service worker (o da nessun service worker) per tutto il tempo.
- Assicurati che sia in esecuzione una sola versione del tuo sito alla volta.
Quest'ultimo aspetto è molto importante. Senza i service worker, gli utenti possono caricare una scheda sul tuo sito e poi aprirne un'altra. Ciò può comportare l'esecuzione contemporanea di due versioni del sito. A volte questo non è un problema, ma se hai a che fare con lo spazio di archiviazione, puoi facilmente ritrovarti con due schede che hanno opinioni molto diverse su come gestire lo spazio di archiviazione condiviso. Ciò può causare errori o, peggio, la perdita di dati.
Il primo service worker
In breve:
- L'evento
installè il primo evento che riceve un service worker e si verifica una sola volta. - Una promise passata a
installEvent.waitUntil()indica la durata e l'esito positivo o negativo dell'installazione. - Un service worker non riceverà eventi come
fetchepushfinché non avrà completato l'installazione e non sarà diventato "attivo". - Per impostazione predefinita, i recuperi di una pagina non passano attraverso un service worker, a meno che la richiesta della pagina stessa non sia passata attraverso un service worker. Quindi dovrai aggiornare la pagina per vedere gli effetti del service worker.
clients.claim()può eseguire l'override di questa impostazione predefinita e assumere il controllo delle pagine non controllate.
Prendi questo codice 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>
Registra un service worker e aggiunge l'immagine di un cane dopo 3 secondi.
Ecco il suo 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'));
}
});
Memorizza nella cache l'immagine di un gatto e la pubblica ogni volta che viene effettuata una richiesta per /dog.svg. Tuttavia, se esegui l'esempio riportato sopra, la prima volta che carichi la pagina vedrai un cane. Aggiorna la pagina e vedrai il gatto.
Ambito e controllo
L'ambito predefinito di una registrazione del service worker è ./ relativo all'URL dello script. Ciò significa che se registri un service worker in //example.com/foo/bar.js, l'ambito predefinito è //example.com/foo/.
Chiamiamo pagine, worker e worker condivisi clients. Il service worker può controllare solo i client che rientrano nell'ambito. Una volta che un client è "controllato", i suoi recuperi passano attraverso il service worker nell'ambito. Puoi rilevare se un client è controllato tramite navigator.serviceWorker.controller, che sarà null o un'istanza worker.
Download, analisi ed esecuzione
Il tuo primo service worker viene scaricato quando chiami .register(). Se lo script non viene scaricato, analizzato o genera un errore durante l'esecuzione iniziale, la promessa di registrazione viene rifiutata e il service worker viene ignorato.
DevTools di Chrome mostra l'errore nella console e nella sezione del service worker della scheda dell'applicazione:
Installa
Il primo evento che riceve un service worker è install. Viene attivato non appena il worker viene eseguito e viene chiamato una sola volta per service worker. Se modifichi lo script del service worker, il browser lo considera un service worker diverso e riceverà il proprio evento install. Tratterò gli aggiornamenti in dettaglio più avanti.
L'evento install è la tua occasione per memorizzare nella cache tutto ciò di cui hai bisogno prima di poter controllare i client. La promise che passi a event.waitUntil() consente al browser di sapere quando l'installazione è stata completata e se è andata a buon fine.
Se la promessa viene rifiutata, significa che l'installazione non è riuscita e il browser elimina il service worker. Non controllerà mai i client. Ciò significa che possiamo fare affidamento sulla presenza di cat.svg nella cache nei nostri eventi fetch. È una dipendenza.
Attiva
Quando il service worker è pronto per controllare i client e gestire eventi funzionali come push e sync, riceverai un evento activate. Tuttavia, questo non significa che la pagina che ha chiamato .register() verrà controllata.
La prima volta che carichi la demo, anche se dog.svg viene richiesto molto tempo dopo l'attivazione del service worker, quest'ultimo non gestisce la richiesta e continui a vedere l'immagine del cane. L'impostazione predefinita è coerenza: se la pagina viene caricata senza un service worker, non verranno caricate neanche le relative risorse secondarie. Se carichi la demo una seconda volta (in altre parole, aggiorni la pagina), verrà controllata. Sia la pagina che l'immagine passeranno attraverso gli eventi fetch e vedrai un gatto.
clients.claim
Puoi assumere il controllo dei client non controllati chiamando clients.claim() all'interno del service worker una volta attivato.
Ecco una variante della demo precedente che chiama clients.claim() nel suo evento activate. La prima volta dovresti vedere un gatto. Dico "dovrebbe" perché si tratta di un'operazione sensibile al fattore tempo. Vedrai un gatto solo se il service worker si attiva e clients.claim() ha effetto prima che l'immagine tenti di caricarsi.
Se utilizzi il service worker per caricare le pagine in modo diverso da come verrebbero caricate tramite la rete, clients.claim() può essere problematico, poiché il service worker finisce per controllare alcuni client che sono stati caricati senza di esso.
Aggiornamento del service worker
In breve:
- Un aggiornamento viene attivato se si verifica una delle seguenti condizioni:
- La navigazione a una pagina inclusa nell'ambito.
- Un evento funzionale come
pushesync, a meno che non sia stato eseguito un controllo degli aggiornamenti nelle 24 ore precedenti. - Chiamata di
.register()solo se l'URL del service worker è cambiato. Tuttavia, dovresti evitare di modificare l'URL del worker.
- La maggior parte dei browser, tra cui Chrome 68 e versioni successive, ignora per impostazione predefinita le intestazioni di memorizzazione nella cache quando verifica la presenza di aggiornamenti dello script del service worker registrato. Rispettano comunque le intestazioni di memorizzazione nella cache durante il recupero delle risorse caricate all'interno di un service worker tramite
importScripts(). Puoi eseguire l'override di questo comportamento predefinito impostando l'opzioneupdateViaCachedurante la registrazione del service worker. - Il service worker viene considerato aggiornato se è diverso in termini di byte da quello già presente nel browser. (Stiamo estendendo questa funzionalità anche agli script/moduli importati).
- Il service worker aggiornato viene avviato insieme a quello esistente e riceve il proprio evento
install. - Se il nuovo worker ha un codice di stato non ok (ad esempio 404), non viene analizzato, genera un errore durante l'esecuzione o viene rifiutato durante l'installazione, viene eliminato, ma quello corrente rimane attivo.
- Una volta installato correttamente, il worker aggiornato
waitfinché il worker esistente non controlla zero client. (Tieni presente che i client si sovrappongono durante un aggiornamento). self.skipWaiting()impedisce l'attesa, il che significa che il service worker si attiva non appena l'installazione è completata.
Supponiamo di aver modificato lo script del service worker in modo che risponda con l'immagine di un cavallo anziché di un gatto:
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'));
}
});
Guarda una demo di quanto sopra. Dovresti comunque vedere l'immagine di un gatto. Ecco perché…
Installa
Tieni presente che ho cambiato il nome della cache da static-v1 a static-v2. Ciò significa che posso configurare la nuova cache senza sovrascrivere gli elementi di quella corrente, che il vecchio service worker sta ancora utilizzando.
Questo pattern crea cache specifiche per la versione, simili agli asset che un'app nativa raggrupperebbe con il suo eseguibile. Potresti anche avere cache non specifiche per la versione, ad esempio avatars.
In attesa
Una volta installato correttamente, il service worker aggiornato ritarda l'attivazione finché il service worker esistente non controlla più i client. Questo stato è chiamato "in attesa" ed è il modo in cui il browser garantisce che venga eseguita una sola versione del service worker alla volta.
Se hai eseguito la demo aggiornata, dovresti comunque vedere l'immagine di un gatto, perché il worker V2 non è ancora stato attivato. Puoi vedere il nuovo service worker in attesa nella scheda "Applicazione" di DevTools:
Anche se hai una sola scheda aperta per la demo, l'aggiornamento della pagina non è sufficiente per consentire l'applicazione della nuova versione. Ciò è dovuto al modo in cui funzionano le navigazioni del browser. Durante la navigazione, la pagina corrente non scompare finché non vengono ricevute le intestazioni della risposta e, anche in questo caso, la pagina corrente potrebbe rimanere se la risposta ha un'intestazione Content-Disposition. A causa di questa sovrapposizione, il service worker corrente controlla sempre un client durante un aggiornamento.
Per ricevere l'aggiornamento, chiudi o esci da tutte le schede che utilizzano il service worker corrente. Poi, quando accedi di nuovo alla demo, dovresti vedere il cavallo.
Questo pattern è simile a quello degli aggiornamenti di Chrome. Gli aggiornamenti di Chrome vengono scaricati in background, ma non vengono applicati finché Chrome non viene riavviato. Nel frattempo, puoi continuare a utilizzare la versione corrente senza interruzioni. Tuttavia, questo è un problema durante lo sviluppo, ma DevTools offre modi per semplificarlo, di cui parlerò più avanti in questo articolo.
Attiva
Questo evento viene attivato una volta che il vecchio service worker non è più attivo e il nuovo service worker è in grado di controllare i client. Questo è il momento ideale per eseguire operazioni che non potevi eseguire mentre il vecchio worker era ancora in uso, come la migrazione dei database e lo svuotamento delle cache.
Nella demo precedente, mantengo un elenco di cache che mi aspetto di trovare e nell'evento activate elimino tutte le altre, il che rimuove la vecchia cache static-v1.
Se passi una promise a event.waitUntil(), gli eventi funzionali (fetch, push, sync e così via) verranno memorizzati nel buffer fino alla risoluzione della promise. Pertanto, quando viene attivato l'evento fetch, l'attivazione è completamente completata.
Salta la fase di attesa
La fase di attesa significa che stai eseguendo una sola versione del tuo sito alla volta, ma se non hai bisogno di questa funzionalità, puoi attivare il nuovo service worker prima chiamando self.skipWaiting().
In questo modo, il service worker elimina il worker attivo corrente e si attiva non appena entra nella fase di attesa (o immediatamente se è già in questa fase). Non fa sì che il worker salti l'installazione, ma solo che attenda.
Non importa quando chiami skipWaiting(), purché sia durante o prima dell'attesa. È abbastanza comune chiamarlo nell'evento install:
self.addEventListener('install', event => {
self.skipWaiting();
event.waitUntil(
// caching etc
);
});
Tuttavia, potresti volerlo chiamare come risultato di un postMessage() al service worker. Ad esempio, vuoi skipWaiting() in seguito a un'interazione dell'utente.
Ecco una demo che utilizza skipWaiting(). Dovresti vedere l'immagine di una mucca senza dover uscire dalla pagina. Come clients.claim(), è una gara, quindi vedrai la mucca solo se il nuovo service worker recupera, installa e attiva prima che la pagina provi a caricare l'immagine.
Aggiornamenti manuali
Come accennato in precedenza, il browser controlla automaticamente la presenza di aggiornamenti dopo le navigazioni e gli eventi funzionali, ma puoi anche attivarli manualmente:
navigator.serviceWorker.register('/sw.js').then(reg => {
// sometime later…
reg.update();
});
Se prevedi che l'utente utilizzi il tuo sito per un periodo di tempo prolungato senza ricaricarlo, ti consigliamo di chiamare update() a intervalli regolari (ad esempio ogni ora).
Evita di modificare l'URL dello script del service worker
Se hai letto il mio post sulle best practice per la memorizzazione nella cache, potresti prendere in considerazione l'idea di assegnare a ogni versione del service worker un URL univoco. Da evitare In genere, questa è una prassi sconsigliata per i service worker. Aggiorna lo script nella sua posizione attuale.
Può causare un problema come questo:
index.htmlregistrasw-v1.jscome service worker.sw-v1.jsmemorizza nella cache e gestisceindex.htmlin modo che funzioni principalmente offline.- Aggiorni
index.htmlin modo che registri il tuo nuovo e brillantesw-v2.js.
Se segui questa procedura, l'utente non riceverà mai sw-v2.js, perché sw-v1.js pubblica la versione precedente di index.html dalla sua cache. Ti trovi in una situazione in cui devi aggiornare il service worker per aggiornare il service worker. Bleah.
Tuttavia, per la demo riportata sopra, ho modificato l'URL del service worker. In questo modo, ai fini della demo, puoi passare da una versione all'altra. Non è un'operazione che farei in produzione.
Semplificare lo sviluppo
Il ciclo di vita del service worker è progettato pensando all'utente, ma durante lo sviluppo è un po' complicato. Fortunatamente, esistono alcuni strumenti che possono aiutarti:
Aggiorna al ricaricamento
Questo è il mio preferito.
In questo modo, il ciclo di vita diventa più facile da gestire per gli sviluppatori. Ogni navigazione:
- Recupera di nuovo il service worker.
- Installalo come nuova versione anche se è identico a livello di byte, il che significa che l'evento
installviene eseguito e le cache vengono aggiornate. - Salta la fase di attesa in modo che il nuovo service worker si attivi.
- Naviga nella pagina.
Ciò significa che riceverai gli aggiornamenti a ogni navigazione (incluso l'aggiornamento) senza dover ricaricare due volte o chiudere la scheda.
Salta l'attesa
Se hai un worker in attesa, puoi fare clic su "Salta attesa" in DevTools per promuoverlo immediatamente ad "attivo".
Maiusc-Ricarica
Se forzi il ricaricamento della pagina (Maiusc-Ricarica), il service worker viene ignorato completamente. Sarà incontrollato. Questa funzionalità è inclusa nella specifica, quindi funziona in altri browser che supportano i service worker.
Gestione degli aggiornamenti
Il service worker è stato progettato nell'ambito del web estensibile. L'idea è che noi, in qualità di sviluppatori di browser, riconosciamo di non essere più bravi nello sviluppo web degli sviluppatori web. Pertanto, non dovremmo fornire API di alto livello limitate che risolvono un problema specifico utilizzando pattern che piacciono a noi, ma dovremmo darti accesso alle funzionalità interne del browser e consentirti di utilizzarle come preferisci, nel modo più adatto ai tuoi utenti.
Per abilitare il maggior numero possibile di pattern, l'intero ciclo di aggiornamento è osservabile:
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.
});
Il ciclo di vita continua
Come puoi vedere, è utile comprendere il ciclo di vita del service worker e, con questa comprensione, i comportamenti del service worker dovrebbero sembrare più logici e meno misteriosi. Queste conoscenze ti daranno maggiore sicurezza durante il deployment e l'aggiornamento dei service worker.