Un grand merci à tous ceux qui ont travaillé sur le code pour cela!
Je voulais juste ajouter que je cherchais exactement la même chose, mais dans mon cas, c'est pour gérer un cache d'objets traités pour éviter d'avoir à ré-analyser et traiter des objets d'appels ajax qui peuvent ou non avoir été mis en cache par le navigateur. Ceci est particulièrement utile pour les objets qui nécessitent beaucoup de traitement, généralement tout ce qui n'est pas au format JSON, mais il peut être très coûteux de garder ces choses en cache dans un grand projet ou une application / extension qui reste en cours d'exécution pendant une longue période. temps.
Quoi qu'il en soit, je l'utilise pour quelque chose comme:
var myCache = {
cache: {},
order: [],
size: 0,
maxSize: 2 * 1024 * 1024, // 2mb
add: function(key, object) {
// Otherwise add new object
var size = this.getObjectSize(object);
if (size > this.maxSize) return; // Can't store this object
var total = this.size + size;
// Check for existing entry, as replacing it will free up space
if (typeof(this.cache[key]) !== 'undefined') {
for (var i = 0; i < this.order.length; ++i) {
var entry = this.order[i];
if (entry.key === key) {
total -= entry.size;
this.order.splice(i, 1);
break;
}
}
}
while (total > this.maxSize) {
var entry = this.order.shift();
delete this.cache[entry.key];
total -= entry.size;
}
this.cache[key] = object;
this.order.push({ size: size, key: key });
this.size = total;
},
get: function(key) {
var value = this.cache[key];
if (typeof(value) !== 'undefined') { // Return this key for longer
for (var i = 0; i < this.order.length; ++i) {
var entry = this.order[i];
if (entry.key === key) {
this.order.splice(i, 1);
this.order.push(entry);
break;
}
}
}
return value;
},
getObjectSize: function(object) {
// Code from above estimating functions
},
};
C'est un exemple simpliste et peut contenir des erreurs, mais il donne l'idée, car vous pouvez l'utiliser pour conserver des objets statiques (le contenu ne changera pas) avec un certain degré d'intelligence. Cela peut réduire considérablement les exigences de traitement coûteuses que l'objet devait être produit en premier lieu.