Comment utiliser l'API du cache d'application HTML5 (Débrantes, utiliser des travailleurs de service à la place)?

L'API de cache d'application HTML5, bien que déconseillée, a été utilisée pour permettre aux applications Web de travailler hors ligne en mettant en cache des ressources. Voici comment vous l'auriez utilisé:

1. Fichier manifeste : créez un fichier manifeste avec une extension .appcache . Ce fichier répertorie les ressources que le navigateur doit mettre en cache. Le format du fichier manifeste est le suivant:

    <code>CACHE MANIFEST # v1 CACHE: /index.html /styles.css /script.js NETWORK: * FALLBACK: / /offline.html</code>

2. Référence HTML : référence au fichier manifeste dans votre fichier html en incluant l'attribut manifest dans la balise :

    <code class="html"></code>

3. Cache de navigateur : Lorsque la page se charge, le navigateur vérifiera le fichier manifeste et commencera la mise en cache des ressources répertoriées dans la section CACHE .
4. Mise à jour et actualiser : le navigateur vérifie périodiquement les mises à jour du fichier manifeste. Si des modifications sont détectées (par exemple, en mettant à jour la version de commentaire), il redémarrera les ressources et mettra à jour le cache.
5. Fallback hors ligne : les ressources répertoriées dans la section NETWORK ne sont jamais mises en cache, ce qui signifie qu'elles sont toujours récupérées du réseau. La section FALLBACK spécifie les pages de secours à servir lorsque l'utilisateur est hors ligne.

Remarque importante : Bien que ces étapes détaillent le fonctionnement de l'API du cache d'application, il est obsolète et ne doit pas être utilisé pour de nouveaux projets. Au lieu de cela, les développeurs devraient passer aux travailleurs des services pour gérer les fonctionnalités hors ligne.

Quelles sont les étapes pour passer de l'API du cache d'application aux travailleurs de service pour les fonctionnalités hors ligne?

La transition de l'API de cache d'application aux employés de services implique plusieurs étapes pour assurer une migration en douceur:

1. Comprendre les travailleurs du service : vous familiarisez-vous avec les travailleurs du service, qui sont des scripts qui s'exécutent en arrière-plan, séparés d'une page Web, et peuvent intercepter et gérer les demandes de réseau. Ils fournissent un moyen plus puissant de gérer les fonctionnalités et la mise en cache hors ligne.
2. Supprimez les références de cache d'application : supprimez l'attribut manifest de vos fichiers HTML et supprimez les fichiers manifestes .appcache .

3. Implémentation du travailleur des services : enregistrez un travailleur des services dans votre fichier JavaScript principal:

    <code class="javascript">if ('serviceWorker' in navigator) { window.addEventListener('load', function() { navigator.serviceWorker.register('/service-worker.js').then(function(registration) { console.log('ServiceWorker registration successful with scope: ', registration.scope); }, function(err) { console.log('ServiceWorker registration failed: ', err); }); }); }</code>

4. écrivez le service de service : créez un fichier de service-worker.js pour gérer la logique de mise en cache. Utilisez l' Cache API pour stocker les ressources:

    <code class="javascript">self.addEventListener('install', function(event) { event.waitUntil( caches.open('my-cache').then(function(cache) { return cache.addAll([ '/', '/index.html', '/styles.css', '/script.js' ]); }) ); }); self.addEventListener('fetch', function(event) { event.respondWith( caches.match(event.request).then(function(response) { return response || fetch(event.request); }) ); });</code>

5. Tester et déboguer : assurez-vous que votre travailleur de service cache correctement les ressources et les sert hors ligne. Utilisez des outils de développeur de navigateur pour inspecter et déboguer le travailleur des services.
6. Mettre à jour le contenu : mettez régulièrement à mettre à jour votre travailleur de service pour gérer les mises à jour de cache. Utilisez le versioning ou d'autres stratégies pour actualiser le contenu mis en cache.

Comment puis-je m'assurer que mon application Web reste hors ligne après avoir migré à partir de l'API du cache d'application?

Pour vous assurer que votre application Web reste hors ligne après avoir migré de l'API de cache d'application aux travailleurs du service, considérez ce qui suit:

1. Cache complète : assurez-vous que toutes les ressources critiques nécessaires pour que votre application fonctionne hors ligne soit mise en cache. Cela inclut HTML, CSS, JavaScript, Images et tout autre actif. Utilisez l' Cache API au sein de votre travailleur de service pour gérer ceci:

    <code class="javascript">self.addEventListener('install', function(event) { event.waitUntil( caches.open('my-cache').then(function(cache) { return cache.addAll([ '/', '/index.html', '/styles.css', '/script.js', '/offline.html' ]); }) ); });</code>

2. Gérer les demandes de réseau : utilisez l'événement fetch pour intercepter et gérer toutes les demandes de réseau. Si une ressource n'est pas trouvée dans le cache, vous pouvez tenter de le récupérer à partir du réseau, puis mettre en cache la réponse:

    <code class="javascript">self.addEventListener('fetch', function(event) { event.respondWith( caches.match(event.request).then(function(response) { return response || fetch(event.request).then(function(response) { return caches.open('my-cache').then(function(cache) { cache.put(event.request, response.clone()); return response; }); }); }) ); });</code>

3. Fallback hors ligne : implémentez une stratégie de replls hors ligne. Si une demande échoue, vous pouvez servir une page de secours à partir du cache:

    <code class="javascript">self.addEventListener('fetch', function(event) { event.respondWith( fetch(event.request).catch(function() { return caches.match('/offline.html'); }) ); });</code>

4. Stratégie de mise à jour : assurez-vous que votre travailleur de service peut se mettre à jour et le cache. Utilisez le versioning et l'événement activate pour gérer les mises à jour:

    <code class="javascript">self.addEventListener('activate', function(event) { var cacheWhitelist = ['my-cache-v2']; event.waitUntil( caches.keys().then(function(cacheNames) { return Promise.all( cacheNames.map(function(cacheName) { if (cacheWhitelist.indexOf(cacheName) === -1) { return caches.delete(cacheName); } }) ); }) ); });</code>

5. Tests : Testez régulièrement vos fonctionnalités hors ligne à l'aide d'outils de développement de navigateur. Simulez le mode hors ligne et vérifiez que toutes les ressources nécessaires sont servies à partir du cache.

Quelles sont les principales différences entre l'API de cache d'application et les travailleurs de service que je devrais être conscient pendant le processus de migration?

Lors de la migration de l'API de cache d'application vers les travailleurs des services, il est important de comprendre les principales différences suivantes:

1. Flexibilité et contr?le :

   • API du cache d'application : il a une approche rigide et déclarative pour la mise en cache via le fichier manifeste. Une fois les ressources spécifiées dans le manifeste, elles sont mises en cache et servies automatiquement.
   • Travailleurs de services : ils offrent un contr?le programmatique sur les demandes de mise en cache et de réseau. Vous pouvez définir la logique personnalisée pour la mise en cache, la mise à jour et la service des ressources, permettant un comportement plus complexe et dynamique.

2. Portée et capacités :

   • API du cache d'application : il est limité à la mise en cache des ressources spécifiées dans le fichier manifeste et les servant hors ligne. Il n'a aucun contr?le sur les demandes de réseau au-delà de ce qui est spécifié dans le manifeste.
   • Travailleurs de services : ils peuvent intercepter et gérer toutes les demandes de réseau, gérer les notifications push, la synchronisation des antécédents et même fournir des mises à jour périodiques. Ils ont une portée et des capacités plus larges au-delà de la mise en cache hors ligne.

3. Mécanisme de mise à jour :

   • API du cache d'application : les mises à jour sont basées sur des modifications du fichier manifeste, ce qui peut parfois conduire à un comportement ou à des conditions de course inattendu où les mises à jour ne sont pas correctement appliquées.
   • Travailleurs de services : les mises à jour sont gérées via le contr?le de version et l'événement activate . Vous pouvez explicitement définir quand et comment les caches sont mises à jour, offrant des mises à jour plus prévisibles et contr?lées.

4. Performance et efficacité :

   • API du cache d'application : il peut souffrir de problèmes de performances en raison de son approche de mise en cache tout ou rien, où une mise à jour entière de cache est requise même pour de petits changements.
   • Travailleurs de services : Ils permettent une mise en cache à grain fin, permettant une gestion des ressources plus efficace. Vous pouvez mettre à jour les ressources individuelles sans affecter l'intégralité du cache.

5. Prise en charge et dépréciation du navigateur :

   • API du cache d'application : il est déprécié et non pris en charge dans les navigateurs modernes, ce qui le rend inadapté à de nouveaux projets ou à une utilisation à long terme.
   • Travailleurs de services : Ils sont la norme moderne recommandée pour les capacités hors ligne et sont largement prises en charge dans les navigateurs actuels.

La compréhension de ces différences vous aidera à migrer efficacement votre application auprès des travailleurs de service, assurant une transition en douceur et une fonctionnalité hors ligne améliorée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!