ADBLOCK DEAKTIVIEREN

ADBlock blockiert einige Inhalte auf der Website

ADBlock errore

Wenn Sie Elemente in HTML5 lokalen Speicher ab?

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

Frage

Wie lange werden die Daten in localstorage gespeichert (als Teil des DOM Speicher in HTML5) zur Verfügung? Kann ich für die Daten eine Ablaufzeit, die ich in localstorage setzen?

Lösung

Es ist nicht möglich Ablauf zu spezifizieren. Es ist völlig bis zu dem Benutzer.

https://developer.mozilla.org/en- US / docs / Web / API / Fenster / local

Natürlich ist es möglich, dass etwas, das Ihre Anwendung speichert auf dem Client nicht, dass es später sein kann. Der Anwender kann explizit lokalen Speicher loszuwerden, oder der Browser in den Raum Überlegungen laufen kann. Es ist gut zu Programm abwehrend. Im Allgemeinen jedoch Dinge bleiben „für immer“, basierend auf einige praktische Definition des Wortes.

Bearbeiten - offensichtlich, Ihre eigene Anwendung kann aktiv Sachen entfernen, wenn sie es ist zu alt entscheidet. Das heißt, können Sie explizit eine Art Zeitstempel sind in dem, was Sie gespeichert haben können, und das dann später verwenden, um zu entscheiden, ob Informationen gespült werden sollen.

ANDERE TIPPS

würde ich zum Speichern von Zeitstempeln vorschlägt im Objekt Sie speichern in der localstorage

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

Sie können das Objekt analysieren, erhalten den Zeitstempel und vergleichen Sie mit dem aktuellen Datum und, falls erforderlich, aktualisieren Sie den Wert des Objekts.

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

compareTime(dateString, now); //to implement

Sie können mit lscache . Er verarbeitet diese automatisch für Sie, einschließlich Fällen, in denen die Speichergröße den Grenzwert überschreitet. Wenn das passiert, beginnt es Artikel Beschneidung, die am nächsten zu ihrem angegebenen Verfall sind.

Von den readme:

lscache.set

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

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

Dies ist der einzige wirkliche Unterschied zwischen den regulären Speichermethoden. , Entfernen, etc. die gleiche Arbeit.

Wenn Sie nicht brauchen, dass viel Funktionalität, geben Sie einfach einen Zeitstempel mit dem Wert (über JSON) speichern kann, und überprüfen Sie es für Ablauf.

Bemerkenswert, gibt es einen guten Grund, warum die lokale Speicherung wird dem Benutzer überlassen. Aber Dinge wie lscache in handliches kommen, wenn Sie extrem temporäre Daten speichern müssen.

Brynner Ferreira, hat einen guten Punkt gebracht: Speichern eines Geschwister Schlüssel wo wohnt Ablauf info. Auf diese Weise, , wenn Sie eine große Menge an Tasten haben, oder wenn Sie Ihre Werte sind große JSON-Objekte , die Sie nicht brauchen, sie zu analysieren, um die Zeitstempel zuzugreifen.

Hier folgt eine verbesserte Version:

 /*  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;
}

Während die lokale Speicherung kein Ablaufmechanismus nicht liefert, müssen Cookies. Einfach mit einem Cookie einen lokalen Speicherschlüssel Paarung kann als Cookie bietet eine einfache Möglichkeit, um sicherzustellen, dass die lokale Speicherung mit den gleichen Ablauf Parametern aktualisiert werden.

Beispiel 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 diesem Beispiel wird ein Cookie mit dem Standard-Parameter zu verfallen, wenn der Browser geschlossen wird. Somit wird, wenn der Browser geschlossen und wieder geöffnet ist, der lokale Datenspeicher für your_data von einem serverseitigen Aufruf aktualisiert wird.

Beachten Sie, dass dies nicht genau die gleiche wie Entfernen die lokalen Datenspeicher, es wird stattdessen die lokalen Datenspeicher zu aktualisieren, wenn das Cookie abläuft. Allerdings, wenn Ihr Hauptziel in der Lage ist, mehr als 4K Client-Seite zu speichern (die Begrenzung für Keksgröße), ist diese Paarung von Cookies und lokalen Speicher wird Ihnen helfen, eine größere Speichergröße mit den gleichen Ablaufparameter als Cookie zu erreichen .

  

Hier hoch Gebrauch empfohlen session

  • es ist die gleiche wie local , aber zerstören, wenn Sitzung zerstört / Browser schließen
  • session ist auch nützlich, den Netzwerkverkehr gegen Cookie zu verringern
  

für Sollwert Verwendung

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

für get Wert Verwendung

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

hier klicken, um Ansicht api

  

alle Möglichkeiten für Satz sind

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

alle Möglichkeiten für get sind

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

Der Lebenszyklus der Anwendung / der Benutzer gesteuert wird.

Aus dem Standard :

  

Benutzerprogramme sollten Daten aus den lokalen Speicherbereichen ablaufen nur aus Gründen der Sicherheit oder auf Anforderung durch den Benutzer zu tun. Benutzerprogramme sollten immer vermeiden Daten zu löschen, während ein Skript, das diese Daten zugreifen konnte ausgeführt wird.

Vom W3C Entwurf:

  

Benutzerprogramme sollten Daten aus den lokalen Speicherbereichen ablaufen nur aus Gründen der Sicherheit oder auf Anforderung durch den Benutzer zu tun. Benutzerprogramme sollten immer vermeiden Daten zu löschen, während ein Skript, das diese Daten zugreifen konnte ausgeführt wird.

Sie wollen Ihre Updates auf Ihren Zeitplan zu tun mit setItem (Schlüssel, Wert); das wird entweder hinzufügen oder den gegebenen Schlüssel mit den neuen Daten aktualisieren.

// 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); }

}

Wenn jemand mit jStorage Plugin von jQuery kann es Add Ablauf sein mit setTTL Funktion, wenn jStorage Plugin

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

Wenn jemand noch auf der Suche nach einer schnellen Lösung und wollen nicht, Abhängigkeiten wie jquery etc ich einen Mini-lib schrieb, dass Add Ablauf auf lokale / session / custom Lagerung, können Sie es mit der Quelle finden Sie hier:

https://github.com/RonenNess/ExpiredStorage

Behelfslösung mit Winkel- und localforage:

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
        }
      })
    }
  }

})

@ sebarmeli Ansatz ist die beste meiner Meinung nach, aber wenn Sie nur Daten wollen für das Leben einer Sitzung anhalten dann sessionStorage ist wahrscheinlich eine bessere Option:

  

Dies ist ein globales Objekt (session), die einen Speicherbereich unterhält   Das ist für die Dauer der Sitzung Seite zur Verfügung. Eine Seite Sitzung   so lange dauert wie der Browser geöffnet ist, und überlebt über Seite   Nachladen und Wiederherstellungen. eine Seite in einem neuen Tab oder Fenster öffnen, wird dazu führen,   eine neue Sitzung gestartet.

werden

MDN: session

Zum Nutzen der Forscher:

Wie Fernando, ich wollte nicht eine Last von json hinzuzufügen, wenn die gespeicherten Werte einfach waren. Ich brauche nur einig UI-Interaktion zu verfolgen und die Daten relevant hält (zum Beispiel, wie ein Benutzer vor dem Auschecken eine E-Commerce-Website verwendet).

Dies wird nicht jedermanns Kriterien erfüllen, wird aber hoffentlich ein schnelles Kopieren + sein Starter Paste für jemanden und speichern eine andere lib hinzugefügt wird.

. HINWEIS: Das wäre gut, nicht, wenn Sie die Elemente einzeln abrufen müssen

// 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]);
    }
}

Sie können versuchen diese.

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