Bonjour,

Dans le jeu de mots que je développe, Chainle, plusieurs traitements côté navigateur peuvent demander le même fichier de données avant la fin de son chargement.

J’utilise une Map contenant les promesses de chargement, avec une clé composée de l’empreinte SHA-256 attendue et de l’URL. Un appel retrouve ainsi une opération déjà lancée au lieu de démarrer son propre chargement. Je conserve aussi les promesses résolues pour réutiliser les données.

Le point important concerne les rejets : garder une promesse rejetée ferait échouer les appels suivants sans nouvelle tentative. Mon gestionnaire retire donc l’entrée puis relance l’erreur, afin que les appelants actuels reçoivent l’échec et qu’un appel ultérieur puisse réessayer.

Voici le principe simplifié. La fonction chargerEtVerifier représente la lecture IndexedDB, le téléchargement et la vérification d’intégrité ; ces opérations, les tentatives réseau et la limite du cache sont omises ici.

Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
const chargements = new Map();
function charger(ref) {
  const cle = ref.sha256 + ":" + ref.url;
  const existant = chargements.get(cle);
  if (existant) return existant;
  const tache = (async () => {
    return await chargerEtVerifier(ref);
  })().catch(erreur => {
    chargements.delete(cle);
    throw erreur;
  });
  chargements.set(cle, tache);
  return tache;
}

Ce cache reste local à l’instance du module : il ne mutualise pas les chargements entre onglets. Dans mon implémentation, il est limité à 24 entrées, supprimées par ordre d’insertion, sans distinguer les opérations terminées de celles encore en cours. Évincer une promesse ne l’annule pas : une nouvelle demande peut alors lancer un second chargement du même fichier. Cette limite borne donc le nombre d’entrées conservées, pas les opérations simultanées.

Séparer les opérations en cours du cache des résultats serait une évolution possible ; ce n’est pas encore le fonctionnement actuel.