javascript - utilizan - tipos de datos en es6

¿Cuál es el tamaño máximo de los valores de almacenamiento local?

Question

Dado que localStorage (actualmente) solo admite cadenas como valores, y para hacer eso, los objetos deben estar formados por cadenas (almacenados como cadena JSON) antes de que puedan almacenarse, ¿existe una limitación definida con respecto a la longitud de los valores?

¿Alguien sabe si hay una definición que se aplica a todos los navegadores?

Answer 1

Encuentre la longitud máxima de una sola cadena que se puede almacenar en localStorage

Este fragmento encontrará la longitud máxima de una cadena que se puede almacenar en el almacenamiento localStorage por dominio.

//Clear localStorage
for (var item in localStorage) delete localStorage[item];

window.result = window.result || document.getElementById(''result'');

result.textContent = ''Test running…'';

//Start test
//Defer running so DOM can be updated with "test running" message
setTimeout(function () {

    //Variables
    var low = 0,
        high = 2e9,
        half;

    //Two billion may be a little low as a starting point, so increase if necessary
    while (canStore(high)) high *= 2;


    //Keep refining until low and high are equal
    while (low !== high) {
        half = Math.floor((high - low) / 2 + low);

        //Check if we can''t scale down any further
        if (low === half || high === half) {
            console.info(low, high, half);
            //Set low to the maximum possible amount that can be stored 
            low = canStore(high) ? high : low;
            high = low;
            break;
        }


        //Check if the maximum storage is no higher than half
        if (storageMaxBetween(low, half)) {
            high = half;
            //The only other possibility is that it''s higher than half but not higher than "high"
        } else {
            low = half + 1;
        }

    }

    //Show the result we found!
    result.innerHTML = ''The maximum length of a string that can be stored in localStorage is <strong>'' + low + ''</strong> characters.'';

    //Functions
    function canStore(strLen) {
        try {
            delete localStorage.foo;
            localStorage.foo = Array(strLen + 1).join(''A'');
            return true;
        } catch (ex) {
            return false;
        }
    }


    function storageMaxBetween(low, high) {
        return canStore(low) && !canStore(high);
    }

}, 0);

<h1>LocalStorage single value max length test</h1>

<div id=''result''>Please enable JavaScript</div>

Tenga en cuenta que la longitud de una cadena está limitada en JavaScript; Si desea ver la cantidad máxima de datos que se pueden almacenar en localStorage cuando no está limitado a una sola cadena, puede usar el código en esta respuesta .

Edición: los fragmentos de pila no admiten localStorage , por lo que aquí hay un enlace a JSFiddle .

Resultados

Chrome (45.0.2454.101): 5242878 caracteres
Firefox (40.0.1): 5242883 caracteres
Internet Explorer (11.0.9600.18036) : 16386 122066 122070 caracteres

Obtengo diferentes resultados en cada ejecución en Internet Explorer.

Answer 2

Los navegadores móviles:

Browser    | Chrome    | Android Browser    | Firefox     | iOS Safari
Version    | 40        | 4.3                | 34          | 6-8
Available  | 10MB      | 2MB                | 10MB        | 5MB

Navegadores de escritorio:

Browser    | Chrome   | Opera    | Firefox    | Safari      | IE
Version    | 40       | 27       | 34         | 6-8         | 9-11
Available  | 10MB     | 10MB     | 10MB       | 5MB         | 10MB

Answer 3

Aquí hay un script sencillo para averiguar el límite:

if (localStorage && !localStorage.getItem(''size'')) {
    var i = 0;
    try {
        // Test up to 10 MB
        for (i = 250; i <= 10000; i += 250) {
            localStorage.setItem(''test'', new Array((i * 1024) + 1).join(''a''));
        }
    } catch (e) {
        localStorage.removeItem(''test'');
        localStorage.setItem(''size'', i - 250);            
    }
}

Aquí está la esencia , JSFiddle y blog post .

La secuencia de comandos probará la configuración de cadenas de texto cada vez más grandes hasta que el navegador arroje una excepción. En ese momento, borrará los datos de prueba y establecerá una clave de tamaño en localStorage que almacena el tamaño en kilobytes.

Answer 4

Citando el artículo de Wikipedia sobre almacenamiento web :

El almacenamiento web se puede ver de manera simplista como una mejora en las cookies, proporcionando una capacidad de almacenamiento mucho mayor ( 10 MB por origen en Google Chrome ( https://plus.google.com/u/0/+FrancoisBeaufort/posts/S5Q9HqDB8bh ), Mozilla Firefox y Opera; 10 MB por área de almacenamiento en Internet Explorer ) y mejores interfaces programáticas.

Y también citando un artículo de John Resig [publicado en enero de 2007]:

Espacio de almacenamiento

Es implícito que, con Almacenamiento DOM, tiene mucho más espacio de almacenamiento que las limitaciones típicas de los agentes de usuario impuestas a las Cookies. Sin embargo, la cantidad que se proporciona no está definida en la especificación, ni es transmitida de manera significativa por el agente del usuario.

Si nos fijamos en el código fuente de Mozilla, podemos ver que 5120 KB es el tamaño de almacenamiento predeterminado para un dominio completo. Esto le da mucho más espacio para trabajar que una cookie típica de 2KB.

Sin embargo, el usuario puede personalizar el tamaño de esta área de almacenamiento (por lo tanto, no se garantiza un área de almacenamiento de 5MB, ni está implícito) y el agente de usuario (Opera, por ejemplo, puede proporcionar solo 3MB, pero solo el tiempo lo dirá). )

Answer 5

En realidad Opera no tiene límite de 5MB. Ofrece aumentar el límite a medida que las aplicaciones requieran más. El usuario puede incluso elegir "Almacenamiento ilimitado" para un dominio.

Puede probar fácilmente los límites / cuotas de almacenamiento local usted mismo.

Answer 6

Estoy haciendo lo siguiente:

getLocalStorageSizeLimit = function () {

    var maxLength = Math.pow(2,24);
    var preLength = 0;
    var hugeString = "0";
    var testString;
    var keyName = "testingLengthKey";

    //2^24 = 16777216 should be enough to all browsers
    testString = (new Array(Math.pow(2, 24))).join("X");

    while (maxLength !== preLength) {
        try  {
            localStorage.setItem(keyName, testString);

            preLength = testString.length;
            maxLength = Math.ceil(preLength + ((hugeString.length - preLength) / 2));

            testString = hugeString.substr(0, maxLength);
        } catch (e) {
            hugeString = testString;

            maxLength = Math.floor(testString.length - (testString.length - preLength) / 2);
            testString = hugeString.substr(0, maxLength);
        }
    }

    localStorage.removeItem(keyName);

    maxLength = JSON.stringify(this.storageObject).length + maxLength + keyName.length - 2;

    return maxLength;
};

Answer 7

No asuma que 5MB están disponibles: la capacidad de almacenamiento local varía según el navegador, con 2.5MB, 5MB y los valores más comunes son los ilimitados. Fuente: http://dev-test.nemikor.com/web-storage/support-test/

Answer 8

No desea alinear objetos grandes en una sola entrada de localStorage. Eso sería muy ineficiente: todo el asunto tendría que ser analizado y recodificado cada vez que algunos pequeños cambios de detalles. Además, JSON no puede manejar múltiples referencias cruzadas dentro de una estructura de objeto y elimina muchos detalles, por ejemplo, el constructor, las propiedades no numéricas de los arreglos, lo que está en una entrada dispersa, etc.

En su lugar, puede utilizar http://rhaboo.org . Almacena objetos grandes utilizando muchas entradas de almacenamiento local para que pueda hacer pequeños cambios rápidamente. Los objetos restaurados son copias mucho más precisas de los guardados y la API es increíblemente simple. P.ej:

var store = Rhaboo.persistent(''Some name'');
store.write(''count'', store.count ? store.count+1 : 1);
store.write(''somethingfancy'', {
  one: [''man'', ''went''],
  2: ''mow'',
  went: [  2, { mow: [''a'', ''meadow'' ] }, {}  ]
});
store.somethingfancy.went[1].mow.write(1, ''lawn'');

Por cierto, lo escribí.

Answer 9

Puede usar el siguiente código en los navegadores modernos para verificar de manera eficiente la cuota de almacenamiento (total y utilizada) en tiempo real:

if (''storage'' in navigator && ''estimate'' in navigator.storage) {
        navigator.storage.estimate()
            .then(estimate => {
                console.log("Usage (in Bytes): ", estimate.usage,
                            ",  Total Quota (in Bytes): ", estimate.quota);
            });
}

Answer 10

Realmente me gusta la respuesta de cdmckay , pero realmente no parece bueno comprobar el tamaño en tiempo real: es demasiado lento (2 segundos para mí). Esta es la versión mejorada, que es mucho más rápida y exacta, también con una opción para elegir qué tan grande puede ser el error (por defecto, 250,000 , mientras más pequeño sea el error, más largo será el cálculo):

function getLocalStorageMaxSize(error) {
  if (localStorage) {
    var max = 10 * 1024 * 1024,
        i = 64,
        string1024 = '''',
        string = '''',
        // generate a random key
        testKey = ''size-test-'' + Math.random().toString(),
        minimalFound = 0,
        error = error || 25e4;

    // fill a string with 1024 symbols / bytes    
    while (i--) string1024 += 1e16;

    i = max / 1024;

    // fill a string with ''max'' amount of symbols / bytes    
    while (i--) string += string1024;

    i = max;

    // binary search implementation
    while (i > 1) {
      try {
        localStorage.setItem(testKey, string.substr(0, i));
        localStorage.removeItem(testKey);

        if (minimalFound < i - error) {
          minimalFound = i;
          i = i * 1.5;
        }
        else break;
      } catch (e) {
        localStorage.removeItem(testKey);
        i = minimalFound + (i - minimalFound) / 2;
      }
    }

    return minimalFound;
  }
}

Probar:

console.log(getLocalStorageMaxSize()); // takes .3s
console.log(getLocalStorageMaxSize(.1)); // takes 2s, but way more exact

Esto funciona dramáticamente más rápido para el error estándar; También puede ser mucho más exacto cuando sea necesario.