zone de travail-prémise en cache

L'une des fonctionnalités des service workers est la possibilité d'enregistrer un ensemble de fichiers dans le cache lors de l'installation du service worker. Cette pratique est souvent appelée "pré-mise en cache", car vous mettez en cache le contenu avant l'utilisation du service worker.

Cela permet principalement aux développeurs de contrôler le cache, ce qui signifie qu'ils peuvent déterminer quand et pendant combien de temps un fichier est mis en cache, et le diffuser dans le navigateur sans passer par le réseau, ce qui signifie qu'il peut être utilisé pour créer des applications Web qui fonctionnent hors connexion.

Workbox simplifie considérablement la mise en cache en simplifiant l'API et en veillant à ce que les éléments soient téléchargés efficacement.

Fonctionnement de la pré-mise en cache de la boîte de travail

Lors du premier chargement d'une application Web, workbox-precaching examine tous les éléments que vous souhaitez télécharger, supprime les doublons et connecte les événements de service worker pertinents pour télécharger et stocker les éléments. Les URL qui comprennent déjà des informations de gestion des versions (comme un hachage de contenu) sont utilisées en tant que clés de cache sans aucune autre modification. La clé de cache des URL qui n'incluent pas d'informations de gestion des versions comporte un paramètre de requête supplémentaire. Celui-ci représente un hachage de leur contenu généré par Workbox au moment de la compilation.

workbox-precaching effectue toutes ces opérations lors de l'événement install du service worker.

Lorsqu'un utilisateur revient ultérieurement dans votre application Web et que vous avez un nouveau service worker avec différents éléments en pré-cache, workbox-precaching examine la nouvelle liste et détermine les éléments complètement nouveaux et ceux qui doivent être mis à jour, en fonction de leur révision. Tous les nouveaux éléments, ou les révisions mises à jour, sont ajoutés au cache lors de l'événement install du nouveau service worker.

Ce nouveau service worker ne sera pas utilisé pour répondre aux requêtes tant que son événement activate n'aura pas été déclenché. C'est dans l'événement activate que workbox-precaching recherche les éléments mis en cache qui ne figurent plus dans la liste des URL actuelles et les supprime du cache.

workbox-precaching effectue ces étapes chaque fois que votre service worker est installé et activé, afin de s'assurer que l'utilisateur dispose des derniers éléments et de ne télécharger que les fichiers qui ont été modifiés.

Diffuser des réponses mises en cache

L'appel de precacheAndRoute() ou addRoute() crée une route qui correspond aux requêtes d'URL en pré-cache.

La stratégie de réponse utilisée dans cette route est de type cache-first : la réponse en pré-cache sera utilisée, sauf si cette réponse mise en cache n'est pas présente (en raison d'une erreur inattendue), auquel cas une réponse du réseau sera utilisée à la place.

L'ordre dans lequel vous appelez precacheAndRoute() ou addRoute() est important. Vous devriez normalement l'appeler au début de votre fichier de service worker, avant d'enregistrer des routes supplémentaires avec registerRoute(). Si vous avez d'abord appelé registerRoute() et que cette route correspond à une requête entrante, la stratégie que vous avez définie dans cette route supplémentaire sera utilisée pour répondre, à la place de la stratégie de priorité au cache utilisée par workbox-precaching.

Explication de la liste de pré-cache

workbox-precaching attend un tableau d'objets avec les propriétés url et revision. Ce tableau est parfois appelé fichier manifeste de pré-cache:

import {precacheAndRoute} from 'workbox-precaching';

precacheAndRoute([
  {url: '/index.html', revision: '383676'},
  {url: '/styles/app.0c9a31.css', revision: null},
  {url: '/scripts/app.0d5770.js', revision: null},
  // ... other entries ...
]);

Cette liste fait référence à un ensemble d'URL, chacune avec ses propres informations de "révision".

Pour les deuxième et troisième objets de l'exemple ci-dessus, la propriété revision est définie sur null. En effet, les informations de révision se trouvent dans l'URL elle-même, ce qui est généralement une bonne pratique pour les éléments statiques.

Le premier objet (/index.html) définit explicitement une propriété de révision, qui est un hachage généré automatiquement du contenu du fichier. Contrairement aux ressources JavaScript et CSS, les fichiers HTML ne peuvent généralement pas inclure d'informations de révision dans leurs URL, sinon les liens vers ces fichiers sur le Web seraient rompus à chaque modification du contenu de la page.

En transmettant une propriété de révision à precacheAndRoute(), Workbox peut savoir quand le fichier a été modifié et le mettre à jour en conséquence.

Workbox est fourni avec des outils permettant de générer cette liste:

  • workbox-build: package de nœud qui peut être utilisé dans une tâche gulp ou en tant que script d'exécution npm.
  • workbox-webpack-plugin: les utilisateurs de webpack peuvent utiliser ce plug-in.
  • workbox-cli: notre CLI peut également être utilisée pour générer la liste des éléments et les ajouter à votre service worker.

Requêtes entrantes pour les fichiers en pré-cache

Une action prête à l'emploi de workbox-precaching consiste à manipuler les requêtes réseau entrantes pour essayer de faire correspondre les fichiers en pré-cache. Cela s'adapte aux pratiques courantes sur le Web.

Par exemple, une requête pour / peut généralement être satisfaite par le fichier dans /index.html.

Vous trouverez ci-dessous la liste des manipulations effectuées par défaut par workbox-precaching, ainsi que la manière dont vous pouvez modifier ce comportement.

Ignorer les paramètres d'URL

Les requêtes avec des paramètres de recherche peuvent être modifiées pour supprimer des valeurs spécifiques ou toutes les valeurs.

Par défaut, les paramètres de recherche qui commencent par utm_ ou correspondent exactement à fbclid sont supprimés, ce qui signifie qu'une requête pour /about.html?utm_campaign=abcd sera traitée avec une entrée en pré-cache pour /about.html.

Vous pouvez ignorer un autre ensemble de paramètres de recherche en utilisant ignoreURLParametersMatching:

import {precacheAndRoute} from 'workbox-precaching';

precacheAndRoute(
  [
    {url: '/index.html', revision: '383676'},
    {url: '/styles/app.0c9a31.css', revision: null},
    {url: '/scripts/app.0d5770.js', revision: null},
  ],
  {
    // Ignore all URL parameters.
    ignoreURLParametersMatching: [/.*/],
  }
);

Index de répertoire

Par défaut, les requêtes se terminant par / sont mises en correspondance avec les entrées auxquelles un index.html se termine. Cela signifie qu'une requête entrante pour / peut être automatiquement traitée avec l'entrée en pré-cache /index.html.

Vous pouvez modifier ce paramètre ou le désactiver complètement en définissant directoryIndex:

import {precacheAndRoute} from 'workbox-precaching';

precacheAndRoute(
  [
    {url: '/index.html', revision: '383676'},
    {url: '/styles/app.0c9a31.css', revision: null},
    {url: '/scripts/app.0d5770.js', revision: null},
  ],
  {
    directoryIndex: null,
  }
);

URL propres

Si une requête ne correspond pas au précache, nous ajoutons .html à la fin pour prendre en charge les URL "propres" (c'est-à-dire les URL "jolies"). Cela signifie qu'une requête telle que /about sera traitée par l'entrée en pré-cache pour /about.html.

Vous pouvez désactiver ce comportement en définissant cleanUrls:

import {precacheAndRoute} from 'workbox-precaching';

precacheAndRoute([{url: '/about.html', revision: 'b79cd4'}], {
  cleanUrls: false,
});

Manipulations personnalisées

Si vous souhaitez définir des correspondances personnalisées à partir des requêtes entrantes vers des éléments en pré-cache, vous pouvez le faire avec l'option urlManipulation. Il doit s'agir d'un rappel qui renvoie un tableau des correspondances possibles.

import {precacheAndRoute} from 'workbox-precaching';

precacheAndRoute(
  [
    {url: '/index.html', revision: '383676'},
    {url: '/styles/app.0c9a31.css', revision: null},
    {url: '/scripts/app.0d5770.js', revision: null},
  ],
  {
    urlManipulation: ({url}) => {
      // Your logic goes here...
      return [alteredUrlOption1, alteredUrlOption2];
    },
  }
);

Utilisation avancée

Utiliser directement PrecacheController

Par défaut, workbox-precaching configure les écouteurs install et activate pour vous. Pour les développeurs familiarisés avec les service workers, cette approche n'est peut-être pas souhaitable s'ils ont besoin de plus de contrôle.

Au lieu d'utiliser l'exportation par défaut, vous pouvez utiliser directement PrecacheController pour ajouter des éléments au précache, déterminer quand ces éléments sont installés et quand le nettoyage doit être effectué.

import {PrecacheController} from 'workbox-precaching';

const precacheController = new PrecacheController();
precacheController.addToCacheList([
  {url: '/styles/example-1.abcd.css', revision: null},
  {url: '/styles/example-2.1234.css', revision: null},
  {url: '/scripts/example-1.abcd.js', revision: null},
  {url: '/scripts/example-2.1234.js', revision: null},
]);

precacheController.addToCacheList([{
  url: '/index.html',
  revision: 'abcd',
}, {
  url: '/about.html',
  revision: '1234',
}]);

self.addEventListener('install', (event) => {
  // Passing in event is required in Workbox v6+
  event.waitUntil(precacheController.install(event));
});

self.addEventListener('activate', (event) => {
  // Passing in event is required in Workbox v6+
  event.waitUntil(precacheController.activate(event));
});

self.addEventListener('fetch', (event) => {
  const cacheKey = precacheController.getCacheKeyForURL(event.request.url);
  event.respondWith(caches.match(cacheKey).then(...));
});

Lire directement les éléments mis en cache

Il peut arriver que vous deviez lire directement un élément en pré-cache, en dehors du contexte du routage que workbox-precaching peut effectuer automatiquement. Par exemple, vous pouvez mettre en pré-cache des modèles HTML partiels qui doivent ensuite être récupérés et utilisés lors de la construction d'une réponse complète.

En général, vous pouvez utiliser l'API Cache Storage pour obtenir les objets Response mis en pré-cache, mais il y a une difficulté: la clé de cache d'URL à utiliser lors de l'appel de cache.match() peut contenir un paramètre de gestion des versions que workbox-precaching crée et gère automatiquement.

Pour obtenir la clé de cache appropriée, vous pouvez appeler getCacheKeyForURL() en transmettant l'URL d'origine, puis utiliser le résultat pour effectuer une cache.match() sur le cache approprié.

import {cacheNames} from 'workbox-core';
import {getCacheKeyForURL} from 'workbox-precaching';

const cache = await caches.open(cacheNames.precache);
const response = await cache.match(getCacheKeyForURL('/precached-file.html'));

Si vous n'avez besoin que de l'objet Response en pré-cache, vous pouvez appeler matchPrecache(), qui utilisera automatiquement la clé de cache appropriée et effectuera une recherche dans le cache approprié:

import {matchPrecache} from 'workbox-precaching';

const response = await matchPrecache('/precached-file.html');

Nettoyer les anciens précaches

La plupart des versions de Workbox conservent le même format pour le stockage des données en pré-cache. Les précaches créés par les anciennes versions de Workbox peuvent normalement être utilisés tels quels par les versions plus récentes. Cependant, il y a rarement une modification destructive du stockage de mise en cache préalable qui oblige les utilisateurs existants à tout télécharger à nouveau, ce qui rend les données précédemment mises en cache obsolètes. (Un tel changement s'est produit entre les versions de Workbox v3 et v4.)

Ces données obsolètes ne devraient pas interférer avec les opérations normales, mais elles contribuent à l'utilisation globale de votre quota de stockage et il peut être plus facile pour vos utilisateurs de les supprimer explicitement. Pour ce faire, ajoutez cleanupOutdatedCaches() à votre service worker ou définissez cleanupOutdatedCaches: true si vous utilisez l'un des outils de compilation de Workbox pour générer votre service worker.

Utiliser l'intégrité des sous-ressources

Certains développeurs peuvent souhaiter bénéficier des garanties supplémentaires offertes par l'application de l'intégrité des sous-ressources lors de la récupération d'URL en pré-cache sur le réseau.

Une propriété facultative supplémentaire appelée integrity peut être ajoutée à n'importe quelle entrée du fichier manifeste de pré-cache. Si elle est fournie, elle sera utilisée comme valeur integrity lors de la construction de la Request utilisée pour remplir le cache. En cas d'incohérence, le processus de mise en cache préalable échouera.

Déterminer quelles entrées de fichier manifeste en pré-cache doit avoir des propriétés integrity et déterminer les valeurs appropriées à utiliser n'entrent pas dans le cadre des outils de compilation de Workbox. Les développeurs qui souhaitent activer cette fonctionnalité doivent modifier le fichier manifeste de pré-cache généré par Workbox pour ajouter eux-mêmes les informations appropriées. L'option manifestTransform dans la configuration des outils de compilation de Workbox peut aider à:

const ssri = require('ssri');

const integrityManifestTransform = (originalManifest, compilation) => {
  const warnings = [];
  const manifest = originalManifest.map(entry => {
    // If some criteria match:
    if (entry.url.startsWith('...')) {
      // This has to be a synchronous function call, for example:
      // compilation will be set when using workbox-webpack-plugin.
      // When using workbox-build directly, you can read the file's
      // contents from disk using, e.g., the fs module.
      const asset = compilation.getAsset(entry.url);
      entry.integrity = ssri.fromData(asset.source.source()).toString();

      // Push a message to warnings if needed.
    }
    return entry;
  });

  return {warnings, manifest};
};

// Then add manifestTransform: [integrityManifestTransform]
// to your Workbox build configuration.

Types

CleanupResult

Propriétés

  • deletedCacheRequests

    chaîne[]

InstallResult

Propriétés

  • notUpdatedURLs

    chaîne[]

  • updatedURLs

    chaîne[]

PrecacheController

Effectue une mise en cache efficace des éléments.

Propriétés

  • constructor

    void

    Créez un PrecacheController.

    La fonction constructor se présente comme suit :

    (options?: PrecacheControllerOptions) => {...}

    • options

      PrecacheControllerOptions facultatif

  • de stratégie

    Stratégie

  • activer

    void

    Supprime les éléments qui ne figurent plus dans le fichier manifeste de prémise en cache actuel. Appelez-la à partir de l'événement d'activation du service worker.

    Remarque: Cette méthode appelle event.waitUntil() pour vous. Vous n'avez donc pas besoin de l'appeler vous-même dans vos gestionnaires d'événements.

    La fonction activate se présente comme suit :

    (event: ExtendableEvent) => {...}

    • event

      ExtendableEvent

  • addToCacheList

    void

    Cette méthode ajoute des éléments à la liste de pré-cache, supprime les doublons et garantit la validité des informations.

    La fonction addToCacheList se présente comme suit :

    (entries: (string | PrecacheEntry)[]) => {...}

    • entries

      (chaîne | PrecacheEntry)[]

      Tableau d'entrées à mettre en pré-cache

  • createHandlerBoundToURL

    void

    Renvoie une fonction qui recherche url dans le précache (en tenant compte des informations de révision) et qui renvoie le Response correspondant.

    La fonction createHandlerBoundToURL se présente comme suit :

    (url: string) => {...}

    • url

      chaîne

      URL en pré-cache qui sera utilisée pour rechercher le Response.

  • getCacheKeyForURL

    void

    Renvoie la clé de cache utilisée pour stocker une URL donnée. Si cette URL ne possède pas de version, par exemple "/index.html", la clé de cache correspondra à l'URL d'origine, suivie d'un paramètre de recherche.

    La fonction getCacheKeyForURL se présente comme suit :

    (url: string) => {...}

    • url

      chaîne

      Une URL dont vous souhaitez rechercher la clé de cache.

    • retours

      chaîne

      URL avec gestion des versions qui correspond à une clé de cache pour l'URL d'origine, ou non définie si cette URL n'est pas mise en pré-cache.

  • getCachedURLs

    void

    Renvoie la liste de toutes les URL mises en pré-cache par le service worker actuel.

    La fonction getCachedURLs se présente comme suit :

    () => {...}

    • retours

      chaîne[]

      URL en pré-cache

  • getIntegrityForCacheKey

    void

    La fonction getIntegrityForCacheKey se présente comme suit :

    (cacheKey: string) => {...}

    • cacheKey

      chaîne

    • retours

      chaîne

      Intégrité de la sous-ressource associée à la clé de cache, ou non définie si elle n'est pas définie.

  • getURLsToCacheKeys

    void

    Renvoie le mappage d'une URL en pré-cache avec la clé de cache correspondante, en tenant compte des informations de révision de l'URL.

    La fonction getURLsToCacheKeys se présente comme suit :

    () => {...}

    • retours

      Map<string>

      URL permettant de mettre en cache le mappage de clés.

  • installer

    void

    Mise en cache des éléments nouveaux et mis à jour Appelez cette méthode à partir de l'événement d'installation du service worker.

    Remarque: Cette méthode appelle event.waitUntil() pour vous. Vous n'avez donc pas besoin de l'appeler vous-même dans vos gestionnaires d'événements.

    La fonction install se présente comme suit :

    (event: ExtendableEvent) => {...}

    • event

      ExtendableEvent

  • matchPrecache

    void

    Elle se substitue à cache.match(), avec les différences suivantes:

    • Il connaît le nom du précache et vérifie uniquement ce cache.
    • Elle vous permet de transmettre une URL "d'origine" sans paramètres de gestion des versions. Elle recherche automatiquement la clé de cache appropriée pour la révision actuellement active de cette URL.

    Exemple : matchPrecache('index.html') trouvera la réponse mise en pré-cache correcte pour le service worker actuellement actif, même si la clé de cache réelle est '/index.html?__WB_REVISION__=1234abcd'.

    La fonction matchPrecache se présente comme suit :

    (request: string | Request) => {...}

    • request

      chaîne | Demande

      Clé (sans paramètres de révision) à rechercher dans le précache.

    • retours

      Promesse<Réponse>

  • pré-cache

    void

    Ajoute des éléments à la liste de pré-cache, supprime les doublons et stocke les fichiers dans le cache lors de l'installation du nœud de calcul.

    Cette méthode peut être appelée plusieurs fois.

    La fonction precache se présente comme suit :

    (entries: (string | PrecacheEntry)[]) => {...}

PrecacheEntry

Propriétés

  • intégrité

    string facultatif

  • Révision

    string facultatif

  • url

    chaîne

PrecacheFallbackPlugin

PrecacheFallbackPlugin vous permet de spécifier une réponse de remplacement hors connexion à utiliser lorsqu'une stratégie donnée ne peut pas générer de réponse.

Pour ce faire, il intercepte le rappel du plug-in handlerDidError et renvoie une réponse mise en pré-cache, en tenant automatiquement compte du paramètre de révision attendu.

Sauf si vous transmettez explicitement une instance PrecacheController au constructeur, l'instance par défaut sera utilisée. De manière générale, la plupart des développeurs utilisent la valeur par défaut.

Propriétés

  • constructor

    void

    Construit un nouveau PrecachePrePlugin avec l'URL de remplacement associée.

    La fonction constructor se présente comme suit :

    (config: object) => {...}

    • config

      objet

      • fallbackURL

        chaîne

        URL en pré-cache à utiliser comme solution de remplacement si la stratégie associée ne peut pas générer de réponse.

      • precacheController

        PrecacheController facultatif

PrecacheRoute

Sous-classe de workbox-routing.Route qui accepte une instance workbox-precaching.PrecacheController et l'utilise pour mettre en correspondance les requêtes entrantes et gérer la récupération des réponses à partir du précache.

Propriétés

PrecacheRouteOptions

Propriétés

  • cleanURLs

    Booléen facultatif

  • directoryIndex

    string facultatif

  • ignoreURLParametersMatching

    RegExp[] facultatif

  • urlManipulation

    urlManipulation facultatif

PrecacheStrategy

Une implémentation de workbox-strategies.Strategy spécialement conçue pour fonctionner avec workbox-precaching.PrecacheController afin de mettre en cache et de récupérer les éléments en pré-cache.

Remarque: Une instance de cette classe est créée automatiquement lors de la création d'un PrecacheController. Il n'est généralement pas nécessaire de le créer vous-même.

Propriétés

  • constructor

    void

    La fonction constructor se présente comme suit :

    (options?: PrecacheStrategyOptions) => {...}

    • options

      PrecacheStrategyOptions facultatif

  • cacheName

    chaîne

  • fetchOptions

    RequestInit facultatif

  • matchOptions

    CacheQueryOptions facultatif

  • plugins
  • copyRedirectedCacheableResponsesPlugin
  • defaultPrecacheCacheabilityPlugin
  • _awaitComplete

    void

    La fonction _awaitComplete se présente comme suit :

    (responseDone: Promise<Response>, handler: StrategyHandler, request: Request, event: ExtendableEvent) => {...}

    • responseDone

      Promesse<Réponse>

    • handler
    • request

      Requête

    • event

      ExtendableEvent

    • retours

      Promise<void>

  • Réponse

    void

    La fonction _getResponse se présente comme suit :

    (handler: StrategyHandler, request: Request, event: ExtendableEvent) => {...}

    • retours

      Promesse<Réponse>

  • _poignéeRécupérer

    void

    La fonction _handleFetch se présente comme suit :

    (request: Request, handler: StrategyHandler) => {...}

    • retours

      Promesse<Réponse>

  • _handleInstall

    void

    La fonction _handleInstall se présente comme suit :

    (request: Request, handler: StrategyHandler) => {...}

    • retours

      Promesse<Réponse>

  • handle

    void

    Exécutez une stratégie de requête et renvoie un Promise qui se résout avec un Response, en appelant tous les rappels de plug-in pertinents.

    Lorsqu'une instance de stratégie est enregistrée avec une boîte de travail workbox-routing.Route, cette méthode est automatiquement appelée lorsque la route correspond.

    Vous pouvez également utiliser cette méthode dans un écouteur FetchEvent autonome en la transmettant à event.respondWith().

    La fonction handle se présente comme suit :

    (options: FetchEvent | HandlerCallbackOptions) => {...}

    • options

      FetchEvent | HandlerCallbackOptions

      Un FetchEvent ou un objet possédant les propriétés répertoriées ci-dessous.

    • retours

      Promesse<Réponse>

  • handleAll

    void

    Semblable à workbox-strategies.Strategy~handle, mais au lieu de simplement renvoyer un Promise qui se résout en Response, il renvoie un tuple de promesses [response, done], où le premier (response) est équivalent à ce que handle() renvoie, et le second est une promesse qui se résout une fois que toutes les promesses ajoutées à event.waitUntil() dans le cadre de l'exécution de la stratégie sont terminées.

    Vous pouvez attendre la promesse done pour vous assurer que tout travail supplémentaire effectué par la stratégie (généralement la mise en cache des réponses) aboutit.

    La fonction handleAll se présente comme suit :

    (options: FetchEvent | HandlerCallbackOptions) => {...}

    • options

      FetchEvent | HandlerCallbackOptions

      Un FetchEvent ou un objet possédant les propriétés répertoriées ci-dessous.

    • retours

      [Promise<Response>, Promise<void>]

      Un tuple de [réponse, terminé] promet qui peut être utilisé pour déterminer le moment où la réponse est résolue, ainsi que le moment où le gestionnaire a terminé tout son travail.

urlManipulation()

workbox-precaching.urlManipulation(
  { url }: object,
)

Type

function

Paramètres

  • { URL }

    objet

    • url

      URL

Renvoie

  • URL[]

Méthodes

addPlugins()

workbox-precaching.addPlugins(
  plugins: WorkboxPlugin[],
)

Ajoute des plug-ins à la stratégie de mise en cache préalable.

Paramètres

addRoute()

workbox-precaching.addRoute(
  options?: PrecacheRouteOptions,
)

Ajoutez un écouteur fetch au service worker qui répondra aux [requêtes réseau]https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests avec des éléments en pré-cache.

Les requêtes pour des éléments qui ne sont pas en pré-cache, FetchEvent ne sont pas traitées, ce qui permet à l'événement de basculer vers d'autres écouteurs d'événements fetch.

Paramètres

cleanupOutdatedCaches()

workbox-precaching.cleanupOutdatedCaches()

Ajout d'un écouteur d'événements activate qui nettoie les précaches incompatibles créés par les anciennes versions de Workbox.

createHandlerBoundToURL()

workbox-precaching.createHandlerBoundToURL(
  url: string,
)

Fonction d'assistance qui appelle PrecacheController#createHandlerBoundToURL sur l'instance PrecacheController par défaut.

Si vous créez votre propre PrecacheController, appelez PrecacheController#createHandlerBoundToURL sur cette instance au lieu d'utiliser cette fonction.

Paramètres

  • url

    chaîne

    URL en pré-cache qui sera utilisée pour rechercher le Response.

getCacheKeyForURL()

workbox-precaching.getCacheKeyForURL(
  url: string,
)

Prend une URL et renvoie l'URL correspondante qui pourrait être utilisée pour rechercher l'entrée dans la mise en cache préalable.

Si une URL relative est fournie, l'emplacement du fichier de service worker est utilisé comme base.

Pour les entrées en pré-cache sans informations de révision, la clé de cache sera identique à l'URL d'origine.

Pour les entrées en pré-cache avec des informations de révision, la clé de cache sera l'URL d'origine, avec l'ajout d'un paramètre de requête utilisé pour suivre les informations de révision.

Paramètres

  • url

    chaîne

    URL dont la clé de cache doit être consultée.

Renvoie

  • chaîne | non définie

    Clé de cache correspondant à cette URL.

matchPrecache()

workbox-precaching.matchPrecache(
  request: string | Request,
)

Fonction d'assistance qui appelle PrecacheController#matchPrecache sur l'instance PrecacheController par défaut.

Si vous créez votre propre PrecacheController, appelez PrecacheController#matchPrecache sur cette instance au lieu d'utiliser cette fonction.

Paramètres

  • request

    chaîne | Demande

    Clé (sans paramètres de révision) à rechercher dans le précache.

Renvoie

  • Promise<Response | undefined>

precache()

workbox-precaching.precache(
  entries: (string | PrecacheEntry)[],
)

Ajoute des éléments à la liste de pré-cache, supprime les doublons et stocke les fichiers dans le cache lors de l'installation du nœud de calcul.

Cette méthode peut être appelée plusieurs fois.

Remarque: Cette méthode ne diffuse pas les fichiers mis en cache pour vous. Il ne fait que mettre en cache les fichiers. Pour répondre à une requête réseau, appelez workbox-precaching.addRoute.

Si vous avez un seul tableau de fichiers à mettre en pré-cache, vous pouvez simplement appeler workbox-precaching.precacheAndRoute.

Paramètres

precacheAndRoute()

workbox-precaching.precacheAndRoute(
  entries: (string | PrecacheEntry)[],
  options?: PrecacheRouteOptions,
)

Cette méthode permet d'ajouter des entrées à la liste de pré-cache et d'ajouter une route permettant de répondre aux événements de récupération.

Il s'agit d'une méthode pratique qui appelle workbox-precaching.precache et workbox-precaching.addRoute dans un seul appel.

Paramètres