以降localStorage（現在）のみの値として文字列をサポートし、オブジェクトは、それらが格納される前に文字列化（JSONストリングとして格納）する必要があることを行うために、値の長さについて定義された限界があります。

すべてのブラウザに適用される定義があるかどうか誰かが知っていますか？

ウェブストレージに関するウィキペディアの記事からの引用：

Webストレージは、Cookieの改善として単純に見ることができ、はるかに大きなストレージ容量（Google Chrome（https://plus.google.com/u/0/+FrancoisBeaufort/posts/S5Q9HqDB8bhのオリジンあたり10 MB ）、Mozilla Firefoxを提供します、Opera、Internet Explorerのストレージ領域あたり10 MB）、より優れたプログラムインターフェイス。

また、John Resigの記事 [2007年1月投稿] からの引用：

収納スペース

DOMストレージでは、Cookieに課される一般的なユーザーエージェントの制限よりもかなり多くのストレージスペースがあることを意味しています。ただし、提供される量は仕様で定義されておらず、ユーザーエージェントによって意味のあるブロードキャストも行われません。

Mozillaのソースコードを見ると、5120KBがドメイン全体のデフォルトのストレージサイズであることがわかります。これにより、通常の2KBのCookieよりもかなり多くのスペースを扱うことができます。

ただし、このストレージ領域のサイズは、ユーザーがカスタマイズできるため（5MBのストレージ領域は保証されておらず、暗黙でもありません）、ユーザーエージェント（たとえば、Operaは3MBしか提供しない場合がありますが、時間だけがわかります。 ）

実際、Operaには5MBの制限はありません。アプリケーションがより多くを必要とする場合、制限を増やすことを提案します。ユーザーはドメインに対して「無制限のストレージ」を選択することもできます。

localStorageの制限/割り当てを自分で簡単にテストできます。

制限を見つけるための簡単なスクリプトを次に示します。

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

これが要旨、JSFiddle、ブログ投稿です。

スクリプトは、ブラウザが例外をスローするまで、テキスト文字列の設定をテストします。その時点で、テストデータが消去され、サイズがキロバイト単位で格納されているlocalStorageにサイズキーが設定されます。

に格納できる単一の文字列の最大長を見つける localStorage

このスニペットは、localStorageドメインごとに保存できる文字列の最大長を見つけます。

//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>

JavaScriptでは文字列の長さが制限されていることに注意してください。localStorage単一の文字列に限定されない場合に格納できるデータの最大量を表示する場合は、この回答のコードを使用できます。

編集：スタックスニペットはをサポートしていないためlocalStorage、ここにJSFiddleへのリンクがあります。

結果

Chrome（45.0.2454.101）： 5242878文字
Firefox（40.0.1）： 5242883文字
Internet Explorer（11.0.9600.18036）：16386 122066 122070文字

Internet Explorerで実行するたびに異なる結果が得られます。

モバイルブラウザ：

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

デスクトップブラウザ：

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

参照リンク

5MBが利用可能であると想定しないでください-localStorageの容量はブラウザーによって異なりますが、2.5MB、5MB、無制限が最も一般的な値です。出典：http : //dev-test.nemikor.com/web-storage/support-test/

大きなオブジェクトを単一のlocalStorageエントリに文字列化したくない場合。それは非常に非効率的です-わずかな詳細が変更されるたびに、全体を解析して再エンコードする必要があります。また、JSONはオブジェクト構造内の複数の相互参照を処理できず、コンストラクター、配列の非数値プロパティ、スパースエントリの内容など、多くの詳細を消去します。

代わりに、Rhabooを使用できます。多数のlocalStorageエントリを使用して大きなオブジェクトを格納するため、小さな変更をすばやく行うことができます。復元されたオブジェクトは、保存されたオブジェクトのはるかに正確なコピーであり、APIは非常にシンプルです。例えば：

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');

ところで、私はそれを書いた。

私は次のことをしています：

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

私はcdmckayの答えが本当に好きですが、リアルタイムでサイズを確認するのはあまり見栄えがよくありません。速度が遅すぎる（私にとっては2秒）。これは改善されたバージョンであり、より高速かつ正確であり、エラーの大きさを選択するオプションもあります（デフォルト250,000、エラーが小さいほど、計算が長くなります）。

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

テストする：

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

これは、標準エラーに対して劇的に速く機能します。また、必要に応じてより正確にすることもできます。

私は使用するこの関数にバイナリテストを圧縮しました：

function getStorageTotalSize(upperLimit/*in bytes*/) {
    var store = localStorage, testkey = "$_test"; // (NOTE: Test key is part of the storage!!! It should also be an even number of characters)
    var test = function (_size) { try { store.removeItem(testkey); store.setItem(testkey, new Array(_size + 1).join('0')); } catch (_ex) { return false; } return true; }
    var backup = {};
    for (var i = 0, n = store.length; i < n; ++i) backup[store.key(i)] = store.getItem(store.key(i));
    store.clear(); // (you could iterate over the items and backup first then restore later)
    var low = 0, high = 1, _upperLimit = (upperLimit || 1024 * 1024 * 1024) / 2, upperTest = true;
    while ((upperTest = test(high)) && high < _upperLimit) { low = high; high *= 2; }
    if (!upperTest) {
        var half = ~~((high - low + 1) / 2); // (~~ is a faster Math.floor())
        high -= half;
        while (half > 0) high += (half = ~~(half / 2)) * (test(high) ? 1 : -1);
        high = testkey.length + high;
    }
    if (high > _upperLimit) high = _upperLimit;
    store.removeItem(testkey);
    for (var p in backup) store.setItem(p, backup[p]);
    return high * 2; // (*2 because of Unicode storage)
}

また、テスト前にコンテンツをバックアップしてから、復元します。

仕組み：制限に達するか、テストが失敗するまで、サイズが2倍になります。次に、低と高の間の距離の半分を保存し、毎回半分の半分を減算/加算します（失敗した場合は減算し、成功した場合は加算します）。適切な値にホーニング。

upperLimitデフォルトは1GBであり、バイナリ検索を開始する前に指数的にスキャンする範囲を制限します。これを変更する必要があるかどうかは疑問ですが、常に先を考えています。;）

Chromeの場合：

> getStorageTotalSize();
> 10485762
> 10485762/2
> 5242881
> localStorage.setItem("a", new Array(5242880).join("0")) // works
> localStorage.setItem("a", new Array(5242881).join("0")) // fails ('a' takes one spot [2 bytes])

IE11、Edge、FireFoxも同じ最大サイズ（10485762バイト）を報告します。

最新のブラウザーで次のコードを使用すると、リアルタイムでストレージ割り当て（合計および使用済み）を効率的に確認できます。

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

このため、Chrome（デスクトップブラウザ）拡張機能を開発し、ローカルストレージの実際の最大サイズをテストしました。

私の結果：

Ubuntu 18.04.1 LTS (64-bit)
Chrome 71.0.3578.98 (Official Build) (64-bit)
Local Storage content size 10240 KB (10 MB)

10240 KB使用法以上に私にエラーが返されました：

キャッチされないDOMException：「ストレージ」で「setItem」を実行できませんでした：「ノート」の値の設定が割り当てを超えました。

localStorageのサイズをバイト単位でテストするこの簡単なコードを書きました。

https://github.com/gkucmierz/Test-of-localStorage-limits-quota

const check = bytes => {
  try {
    localStorage.clear();
    localStorage.setItem('a', '0'.repeat(bytes));
    localStorage.clear();
    return true;
  } catch(e) {
    localStorage.clear();
    return false;
  }
};

Githubページ：

https://gkucmierz.github.io/Test-of-localStorage-limits-quota/

デスクトップクロム、オペラ、Firefox、勇敢なモバイルクロムで同じ結果が得られます。

そして半分より小さい結果はサファリで2Mバイトになります