DISABLE ADBLOCK

ADBlock está bloqueando parte del contenido en el sitio

ADBlock errore

¿Cuándo los artículos en almacenamiento local de HTML5 caducan?

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

Pregunta

¿Por cuánto tiempo se almacenan los datos en el almacenamiento local (como parte del almacenamiento DOM en HTML5) disponibles? ¿Puedo establecer una fecha de caducidad para los datos de los que he puesto en localStorage?

Solución

No es posible especificar de caducidad. Es completamente en manos del usuario.

https://developer.mozilla.org/en- EEUU / docs / web / API / ventana / localStorage

Por supuesto, es posible que algo que sus tiendas de aplicaciones en el cliente pueden no estar allí más tarde. El usuario de forma explícita puede deshacerse de almacenamiento local, o el navegador puede ejecutar en consideraciones de espacio. Es bueno el programa defensiva. Sin embargo, generalmente las cosas permanecen "para siempre", basada en una definición práctica de esa palabra.

editar -, obviamente, su propia aplicación puede eliminar activamente cosas si se decide que es demasiado viejo. Es decir, puede incluir de manera explícita algún tipo de marca de tiempo en lo que tiene guardado, y luego usar esa tarde para decidir si la información se debe lavar.

OTROS CONSEJOS

Yo sugeriría a la tienda de marca de tiempo en el objetos se almacenan en el almacenamiento local

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

Se puede analizar el objeto, obtener la marca de tiempo y comparar con la actual fecha, y si es necesario, actualizar el valor del objeto.

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

compareTime(dateString, now); //to implement

Se puede usar lscache . Se maneja esto automáticamente, incluyendo los casos en que el tamaño de almacenamiento supera el límite. Si eso ocurre, se inicia la poda de los elementos que son el más cercano a su expiración especificada.

Desde el readme:

lscache.set

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

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

Esta es la única diferencia real entre los métodos de almacenamiento normales. Obtener, quitar, etc funcionar de la misma.

Si no es necesario que gran funcionalidad, simplemente se puede almacenar una marca de tiempo con el valor (a través de JSON) y compruebe si está caducidad.

Digno de mención, hay una razón buena por qué el almacenamiento local se deja en manos del usuario. Sin embargo, las cosas como lscache muy prácticos cuando se necesita para almacenar datos extremadamente temporales.

Brynner Ferreira, ha traído un buen punto: almacenar una clave de hermanos, donde reside la información de caducidad. De esta manera, si usted tiene una gran cantidad de teclas, o si sus valores son grandes objetos JSON , no es necesario analizarlos para acceder a la marca de tiempo.

A continuación sigue una versión mejorada:

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

Mientras que el almacenamiento local no proporciona un mecanismo de caducidad, las cookies. Simplemente el emparejamiento de una llave de almacenamiento local con una cookie proporciona una manera fácil de asegurarse de que el almacenamiento local puede ser actualizado con los mismos parámetros de caducidad como una galleta.

Ejemplo en 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

En este ejemplo se establece una cookie con el parámetro por defecto para expirar cuando se cierra el navegador. Por lo tanto, cuando el navegador está cerrado y abierto de nuevo, el almacén de datos local para your_data se refresca con una llamada del lado del servidor.

Tenga en cuenta que esto no es exactamente lo mismo que eliminar del almacén de datos local, en su lugar se actualiza el almacén de datos local cada vez que expira la cookie. Sin embargo, si su principal objetivo es ser capaz de almacenar más de 4K del lado del cliente (la limitación de tamaño de las cookies), este emparejamiento de galleta y almacenamiento local le ayudará a lograr una mayor capacidad de almacenamiento utilizando los mismos parámetros de caducidad como una cookie .

  

A continuación, muy recomendable para el uso sessionStorage

  • es igual a localStorage , pero destruye cuando destruyó sesión / cierre del navegador
  • sessionStorage también es útil para reducir el tráfico de red en contra de la galleta
  

para uso valor de ajuste

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

para su uso valor get

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

clic aquí para ver api

  

todas las formas de juego son

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

todas las maneras para conseguir son

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

El ciclo de vida es controlada por la aplicación / usuario.

Desde el estándar:

  

Los agentes de usuario deben expirar datos de las áreas de almacenamiento local sólo por razones de seguridad o cuando así lo solicite el usuario. Los agentes de usuario deben siempre evitar la eliminación de los datos, mientras que un guión que podría acceder a esos datos se está ejecutando.

Desde el proyecto W3C:

  

Los agentes de usuario deben expirar datos de las áreas de almacenamiento local sólo por razones de seguridad o cuando así lo solicite el usuario. Los agentes de usuario deben siempre evitar la eliminación de los datos, mientras que un guión que podría acceder a esos datos se está ejecutando.

Usted querrá hacer sus cambios en su horario usando setItem (clave, valor); que, o bien va a añadir o actualizar la clave dada con los nuevos datos.

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

}

Si alguien usando jStorage Plugin de jQuery la caducidad puede ser adicionado con función de si setTTL jStorage plug-in

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

Si alguien todavía en busca de una solución rápida y no quiero dependencias como jQuery, etc yo escribimos un mini lib que añadir a la expiración de almacenamiento sesión / / costumbre local, se puede encontrar con la fuente aquí:

https://github.com/RonenNess/ExpiredStorage

Solución usando angular y 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
        }
      })
    }
  }

})

enfoque

@ de sebarmeli es el mejor en mi opinión, pero si sólo se desea que los datos que persisten durante la vida de una sesión a continuación sessionStorage es probablemente una mejor opción:

  

Este es un objeto global (sessionStorage) que mantiene un área de almacenamiento   que está disponible para la duración de la sesión de la página. Una sesión de la página   dura todo el tiempo que el navegador está abierto y sobrevive más de la página   recargas y restauraciones. La apertura de una página en una nueva pestaña o ventana causará   una nueva sesión que se inicie.

MDN: sessionStorage

Para el beneficio de los buscadores:

Al igual que Fernando, yo no quería añadir una carga de JSON cuando los valores almacenados eran simples. Sólo tenía que realizar un seguimiento de algún tipo de interacción interfaz de usuario y mantener los datos relevantes (por ejemplo, cómo un usuario utiliza un sitio de comercio electrónico antes de la salida).

Esto no cumple con los criterios everyones, pero se espera que sea una copia rápida + pasta de arranque para alguien y guardar la adición de otro lib.

NOTA:. Esto no sería bueno si necesita recuperar los elementos de forma individual

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

Puede probar esto.

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