DISABILITARE ADBLOCK

ADBlock sta bloccando alcuni contenuti del sito

ADBlock errore

Quando gli impegni in memoria locale HTML5 scadono?

StackOverflow https://stackoverflow.com/questions/2326943

DOMANDA

Per quanto tempo i dati memorizzati in localStorage (come parte del DOM bagagli in HTML5) a disposizione? Posso impostare un tempo di scadenza per i dati che ho messo in localStorage?

SOLUZIONE

Non è possibile specificare la scadenza. E 'completamente a carico dell'utente.

https://developer.mozilla.org/en- USA / docs / Web / API / finestra / localStorage

Naturalmente, è possibile che qualcosa che il tuo negozi di applicazioni sul client potrebbero non esserci più tardi. L'utente può in modo esplicito sbarazzarsi di storage locale, oppure il browser potrebbe incorrere in considerazioni di spazio. E 'bene programmare difensiva. In generale però le cose rimangono "per sempre" sulla base di alcuni definizione pratica di quella parola.

modifica - ovviamente, la propria applicazione può rimuovere attivamente roba se si decide che è troppo vecchio. Cioè, è possibile includere esplicitamente una sorta di data e ora in quello che hai salvato, e quindi utilizzare che più tardi per decidere o meno di dati deve essere lavata.

ALTRI SUGGERIMENTI

Vorrei suggerire al negozio timestamp nel oggetto si memorizzare nella localStorage

var object = {value: "value", timestamp: new Date().getTime()}
localStorage.setItem("key", JSON.stringify(object));

È possibile analizzare l'oggetto, ottenere il timestamp e confrontare con la data corrente, e, se necessario, aggiornare il valore dell'oggetto.

var object = JSON.parse(localStorage.getItem("key")),
    dateString = object.timestamp,
    now = new Date().getTime().toString();

compareTime(dateString, now); //to implement

È possibile utilizzare lscache . Gestisce automaticamente per voi, compresi i casi in cui la dimensione della memoria supera il limite. Se ciò accade, inizia elementi potatura che sono più vicino alla loro scadenza specificata.

Dal readme:

lscache.set

Stores the value in localStorage. Expires after specified number of minutes.

Arguments
key (string)
value (Object|string)
time (number: optional)

Questa è l'unica vera differenza tra i metodi di stoccaggio normali. Ottenere, rimuovere, ecc funzionano allo stesso.

Se non avete bisogno di molto la funzionalità, si può semplicemente memorizzare un timestamp con il valore (tramite JSON) e controllare la presenza di scadenza.

Da notare, c'è una buona ragione per cui la memorizzazione locale è lasciata all'utente. Ma, le cose come lscache fanno venire utile quando è necessario memorizzare i dati estremamente temporanei.

Brynner Ferreira, ha portato un buon punto: la memorizzazione di una chiave di pari livello in cui informazioni di scadenza risiede. In questo modo, se si dispone di una grande quantità di chiavi, o se i valori sono grandi oggetti JSON , non è necessario analizzare loro di accedere al timestamp.

qui di seguito una versione migliorata:

 /*  removeStorage: removes a key from localStorage and its sibling expiracy key
    params:
        key <string>     : localStorage key to remove
    returns:
        <boolean> : telling if operation succeeded
 */
 function removeStorage(name) {
    try {
        localStorage.removeItem(name);
        localStorage.removeItem(name + '_expiresIn');
    } catch(e) {
        console.log('removeStorage: Error removing key ['+ key + '] from localStorage: ' + JSON.stringify(e) );
        return false;
    }
    return true;
}
/*  getStorage: retrieves a key from localStorage previously set with setStorage().
    params:
        key <string> : localStorage key
    returns:
        <string> : value of localStorage key
        null : in case of expired key or failure
 */
function getStorage(key) {

    var now = Date.now();  //epoch time, lets deal only with integer
    // set expiration for storage
    var expiresIn = localStorage.getItem(key+'_expiresIn');
    if (expiresIn===undefined || expiresIn===null) { expiresIn = 0; }

    if (expiresIn < now) {// Expired
        removeStorage(key);
        return null;
    } else {
        try {
            var value = localStorage.getItem(key);
            return value;
        } catch(e) {
            console.log('getStorage: Error reading key ['+ key + '] from localStorage: ' + JSON.stringify(e) );
            return null;
        }
    }
}
/*  setStorage: writes a key into localStorage setting a expire time
    params:
        key <string>     : localStorage key
        value <string>   : localStorage value
        expires <number> : number of seconds from now to expire the key
    returns:
        <boolean> : telling if operation succeeded
 */
function setStorage(key, value, expires) {

    if (expires===undefined || expires===null) {
        expires = (24*60*60);  // default: seconds for 1 day
    } else {
        expires = Math.abs(expires); //make sure it's positive
    }

    var now = Date.now();  //millisecs since epoch time, lets deal only with integer
    var schedule = now + expires*1000; 
    try {
        localStorage.setItem(key, value);
        localStorage.setItem(key + '_expiresIn', schedule);
    } catch(e) {
        console.log('setStorage: Error setting key ['+ key + '] in localStorage: ' + JSON.stringify(e) );
        return false;
    }
    return true;
}

Mentre storage locale non fornisce un meccanismo di scadenza, i cookie fanno. Semplicemente l'associazione una chiave di memorizzazione locale con un cookie fornisce un modo semplice per garantire che memoria locale può essere aggiornato con gli stessi parametri di scadenza come un biscotto.

Esempio in jQuery:

if (!$.cookie('your_key') || !localStorage.getItem('your_key')) {
    //get your_data from server, then...
    localStorage.setItem('your_key', 'your_data' );
    $.cookie('your_key', 1);
} else {
    var your_data = localStorage.getItem('your_key');
}
// do stuff with your_data

In questo esempio imposta un cookie con il parametro di default per scadere quando il browser viene chiuso. Così, quando il browser viene chiuso e riaperto, l'archivio dati locale your_data viene rinfrescato da una chiamata sul lato server.

Si noti che questo non è esattamente lo stesso di rimozione l'archivio dati locale, è invece aggiornando l'archivio dati locale ogni volta che scade il cookie. Tuttavia, se il vostro obiettivo principale è quello di essere in grado di memorizzare più di 4K sul lato client (il limite per la dimensione del cookie), questo abbinamento di biscotto e storage locale vi aiuterà a realizzare un formato di memorizzazione più grande utilizzando gli stessi parametri di scadenza come un biscotto .

  

Qui consiglia vivamente di utilizzare sessionStorage

  • è uguale a localStorage , ma distrugge quando sessione distrutto / navigatore vicino
  • sessionStorage è utile anche per ridurre il traffico di rete contro biscotto
  

per il set uso valore

sessionStorage.setItem("key","my value");
  

per l'utilizzo del valore get

var value = sessionStorage.getItem("key");

clicca qui per la vista api

  

tutti i modi per il set sono

  sessionStorage.key = "my val";
  sessionStorage["key"] = "my val";
  sessionStorage.setItem("key","my value");
  

tutti i modi per ottenere sono

  var value = sessionStorage.key;
  var value = sessionStorage["key"];
  var value = sessionStorage.getItem("key");

Il ciclo di vita è controllata mediante l'applicazione / utente.

serie :

  

Gli interpreti dovrebbero scadere i dati dalle aree di stoccaggio locali soltanto per motivi di sicurezza o quando richiesto di farlo da parte dell'utente. I programmi utente dovrebbero sempre evitare la cancellazione dei dati, mentre uno script in grado di accedere ai dati sia in esecuzione.

Dal progetto del W3C:

  

Gli interpreti dovrebbero scadere i dati dalle aree di stoccaggio locali soltanto per motivi di sicurezza o quando richiesto di farlo da parte dell'utente. I programmi utente dovrebbero sempre evitare la cancellazione dei dati, mentre uno script in grado di accedere ai dati sia in esecuzione.

Ti consigliamo di fare gli aggiornamenti sul vostro programma utilizzando setItem (chiave, valore); che o aggiungere o aggiornare la chiave data con i nuovi dati.

// Functions
function removeHtmlStorage(name) {
    localStorage.removeItem(name);
    localStorage.removeItem(name+'_time');
}

function setHtmlStorage(name, value, expires) {

    if (expires==undefined || expires=='null') { var expires = 3600; } // default: 1h

    var date = new Date();
    var schedule = Math.round((date.setSeconds(date.getSeconds()+expires))/1000);

    localStorage.setItem(name, value);
    localStorage.setItem(name+'_time', schedule);
}

function statusHtmlStorage(name) {

    var date = new Date();
    var current = Math.round(+date/1000);

    // Get Schedule
    var stored_time = localStorage.getItem(name+'_time');
    if (stored_time==undefined || stored_time=='null') { var stored_time = 0; }

    // Expired
    if (stored_time < current) {

        // Remove
        removeHtmlStorage(name);

        return 0;

    } else {

        return 1;
    }
}

// Status
var cache_status = statusHtmlStorage('cache_name');

// Has Data
if (cache_status == 1) {

    // Get Cache
    var data = localStorage.getItem('cache_name');
    alert(data);

// Expired or Empty Cache
} else {

    // Get Data
    var data = 'Pay in cash :)';
    alert(data);

    // Set Cache (30 seconds)
    if (cache) { setHtmlStorage('cache_name', data, 30); }

}

Se qualcuno utilizza jStorage plugin di jQuery il che può essere aggiungere scadenza con la funzione setTTL se jStorage plug-in

$.jStorage.set('myLocalVar', "some value");
$.jStorage.setTTL("myLocalVar", 24*60*60*1000); // 24 Hr.

Se qualcuno ancora alla ricerca di una soluzione rapida e non vogliono le dipendenze come jQuery ecc ho scritto un mini lib che aggiungono scadenza di stoccaggio / sessioni / costume locale, lo si può trovare con la fonte qui:

https://github.com/RonenNess/ExpiredStorage

Per risolvere il problema utilizzando localforage angolare e:

angular.module('app').service('cacheService', function() {

  return {
    set: function(key, value, expireTimeInSeconds) {
      return localforage.setItem(key, {
        data: value,
        timestamp: new Date().getTime(),
        expireTimeInMilliseconds: expireTimeInSeconds * 1000
      })
    },
    get: function(key) {
      return localforage.getItem(key).then(function(item) {
        if(!item || new Date().getTime() > (item.timestamp + item.expireTimeInMilliseconds)) {
          return null
        } else {
          return item.data
        }
      })
    }
  }

})

@ di sebarmeli approccio è il migliore a mio parere, ma se desideri solo i dati a persistere per tutta la durata di una sessione allora sessionStorage è probabilmente una scelta migliore:

  

Questo è un oggetto globale (sessionStorage) che mantiene una zona di stoccaggio   che è disponibile per tutta la durata della sessione di pagina. Una sessione Pagina   dura fino a quando il browser è aperto e sopravvive più di pagina   ricariche e ripristini. Apertura di una pagina in una nuova scheda o finestra causerà   una nuova sessione per essere iniziato.

MDN: sessionStorage

A beneficio dei ricercatori:

Come Fernando, non volevo aggiungere un carico di JSON, quando i valori memorizzati erano semplici. Avevo solo bisogno di tenere traccia di qualche interazione interfaccia utente e conservare i dati rilevanti (ad esempio, come un utente ha utilizzato un sito e-commerce prima della verificazione).

Questo non soddisfa tutti quanti criteri, ma si spera essere una copia rapida + incolla antipasto per qualcuno e salvare aggiunta di un altro lib.

Nota: Questo non sarebbe bene se avete bisogno di recuperare gli elementi singolarmente

.
// Addition
if(window.localStorage){
    localStorage.setItem('myapp-' + new Date().getTime(), 'my value');
}

// Removal of all expired items
if(window.localStorage){

    // two mins - (1000 * 60 * 20) would be 20 mins
    var expiryTime = new Date().getTime() - (1000 * 60 * 2);

    var deleteRows = [];
    for(var i=0; i < localStorage.length; i++){
        var key = localStorage.key(i);
        var partsArray = key.split('-');
        // The last value will be a timestamp
        var lastRow = partsArray[partsArray.length - 1];

        if(lastRow && parseInt(lastRow) < expiryTime){
            deleteRows.push(key);
        }
    }
    // delete old data
    for(var j=0; j < deleteRows.length; j++){
        localStorage.removeItem(deleteRows[j]);
    }
}

È possibile provare questo.

var hours = 24; // Reset when storage is more than 24hours
var now = new Date().getTime();
var setupTime = localStorage.getItem('setupTime');
if (setupTime == null) {
     localStorage.setItem('setupTime', now)
} else {
    if(now-setupTime > hours*60*60*1000) {
         localStorage.clear()
         localStorage.setItem('setupTime', now);
    }
}

Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow