लोकलस्टोरेज मानों का अधिकतम आकार क्या है?

Question

चूंकि localStorage(वर्तमान में) केवल स्ट्रिंग को मूल्यों के रूप में समर्थन करता है, और ऐसा करने के लिए कि वस्तुओं को संग्रहीत किए जाने से पहले उन्हें कड़ाई से संग्रहीत (JSON-string के रूप में संग्रहीत) करने की आवश्यकता होती है, क्या मूल्यों की लंबाई के बारे में एक परिभाषित सीमा है।

क्या किसी को पता है कि क्या कोई परिभाषा है जो सभी ब्राउज़रों पर लागू होती है?

Comments

मुझे लगता है कि किसी ने वास्तव में "मूल्य प्रति अधिकतम लंबाई" सवाल का जवाब नहीं दिया।

— पीट एल्विन

@PeteAlvin मैंने सिर्फ सवाल का जवाब दिया ।

— user2428118 18

सभी ब्राउज़र: html5rocks.com/en/tutorials/offline/quota-research

— MCCCS

@PeteAlvin ने 2015 में इसका उत्तर दिया था। अन्य उत्तर कुल आकार पर सीमा को संबोधित करते हैं, लेकिन प्रति मूल्य आकार पर सीमा नहीं ।

— अली

Answer 1

वेब संग्रहण पर विकिपीडिया लेख से उद्धरण :

वेब स्टोरेज को कुकीज़ पर सुधार के रूप में सरलता से देखा जा सकता है, बहुत अधिक भंडारण क्षमता प्रदान करता है ( Google Chrome में मूल प्रति 10 एमबी ( https://plus.google.com/u/0/+FrancoisBeaufort/posts/S5Q9HqDBbhh ), मोज़िला फ़ायरफ़ॉक्स और ओपेरा, इंटरनेट एक्सप्लोरर में 10 एमबी प्रति भंडारण क्षेत्र ) और बेहतर प्रोग्रामेटिक इंटरफेस।

और जॉन रेसिग लेख से उद्धृत [जनवरी 2007 को पोस्ट किया गया]:

स्टोरेज की जगह

यह निहित है कि, DOM स्टोरेज के साथ, आपके पास कुकीज़ पर लगाए गए विशिष्ट उपयोगकर्ता एजेंट सीमाओं की तुलना में काफी अधिक संग्रहण स्थान है। हालांकि, जो राशि प्रदान की गई है, वह विनिर्देश में परिभाषित नहीं है, और न ही इसे उपयोगकर्ता एजेंट द्वारा सार्थक रूप से प्रसारित किया जाता है।

यदि आप मोज़िला स्रोत कोड को देखते हैं तो हम देख सकते हैं कि 5120KB पूरे डोमेन के लिए डिफ़ॉल्ट भंडारण आकार है। यह आपको एक सामान्य 2KB कुकी की तुलना में काम करने के लिए अधिक स्थान देता है।

हालांकि, इस भंडारण क्षेत्र का आकार उपयोगकर्ता द्वारा अनुकूलित किया जा सकता है (इसलिए 5MB भंडारण क्षेत्र की गारंटी नहीं है, न ही यह निहित है) और उपयोगकर्ता एजेंट (ओपेरा, उदाहरण के लिए, केवल 3MB प्रदान कर सकता है - लेकिन केवल समय ही बताएगा। )

Comments

@Cupidvogel नहीं, इसका मतलब है कि प्रत्येक domain( origin) किसी भी व्यक्तिगत ग्राहक पर 5MB स्टोर कर सकता है। डेटा क्लाइंट मशीन पर संग्रहीत किया जाता है - किसी भी तरह से localStorageतंत्र ग्राहकों के बीच बातचीत नहीं करता है।

— डेनियल

नहीं, मैं सिर्फ यह सुनिश्चित करना चाहता था कि एक ही डोमेन के लिए एक ही डेटा कई पृष्ठों पर उपलब्ध हो। अक्सर मुझे लगता है कि वाक्यांश डोमेन और पेज समानार्थी रूप से लिखे गए थे, इसलिए मैं निश्चित रूप से जानना चाहता था!

— सेक्सीबीस्ट

लेकिन वहाँ एक पर एक सीमा है,, एक मूल्य? (अगर मेरे पास स्टोर करने के लिए बहुत सारे झंडे हैं, तो इसे एक संपत्ति में JSON के रूप में संग्रहीत करना कितना सुरक्षित है?)

— phtrivier

मुझे 10 एमबी पर 5 एमबी और क्रोम 39 पर सफारी मिली है (यह सुनिश्चित नहीं है कि जब इसे 5 एमबी से बढ़ाया गया था) इस लेख को देखें html5rocks.com/hi/tutorials/offline/quota-research

— सहयोगी

@Cupidvogel: नहीं, यह डोमेन द्वारा नहीं है, यह मूल रूप से है, क्योंकि शब्द का उपयोग समान उत्पत्ति नीति के विज़न और जैसे: योजना + होस्ट + पोर्ट के रूप में किया जाता है। http://example.comऔर https://example.comएक ही मूल (विभिन्न योजनाएं) नहीं हैं। http://example.comऔर http://www.example.comएक ही मूल (अलग मेजबान) नहीं हैं। http://example.comऔर http://example.com:8080एक ही मूल (विभिन्न बंदरगाह) नहीं हैं। HTH। :-)

— टीजे क्राउडर

Answer 2

वास्तव में ओपेरा में 5 एमबी की सीमा नहीं है। यह सीमा बढ़ाने की पेशकश करता है क्योंकि अनुप्रयोगों के लिए अधिक आवश्यकता होती है। उपयोगकर्ता एक डोमेन के लिए "असीमित भंडारण" भी चुन सकता है।

आप आसानी से स्थानीय स्तर की सीमाओं / कोटा का परीक्षण स्वयं कर सकते हैं ।

Comments

क्रोम को अब क्रैश नहीं करता है ... दिलचस्प बिंदु: 5MB क्रोम पर 2.5 मिलियन चार्ट के बराबर है। तो जाहिरा तौर पर, UFT16 का उपयोग लोकलस्टोर के लिए किया जाता है।

— फेलिक्स अलकाला

@FelixAlcala दुर्भाग्य से, यह मैक ओएस एक्स पर क्रोम 15.0.874.54 बीटा को क्रैश करता है। मेरे पास 1.500.000 चार्ट पर एक दुर्घटना थी।

— इवान वूइका

इसने मेरे डिवाइस पर क्रोम को क्रैश कर दिया, यह भी bckground को रीसेट करता है, आश्चर्यचकित नहीं है, हालांकि, मेरे फोन में इतनी कम रैम है, यह क्रोम फ्लेशलाइट एपीपी को संभाल नहीं सकता है जबकि क्रोम खुला है।

— जैक

@FelixAlcala - वास्तव में, जावास्क्रिप्ट उजागर करता है UCS-2। जबकि यह समान है UFT16कि कुछ बहुत महत्वपूर्ण अंतर हैं ... ज्यादातर इस तथ्य के इर्द-गिर्द घूमते हैं कि UCS-2 UFT से पूर्ववर्ती है।

— जेरेमी जे स्टारचर

@FelixAlcala क्या आपको लगता है कि कितने अक्षर और साथ ही साथ इसका डिस्क आकार समतुल्य है (उदाहरण 2,700K अक्षर ~ = 5,274 KB) एक अच्छा विचार है?

— एजे

Answer 3

यहाँ सीमा का पता लगाने के लिए एक सरल स्क्रिप्ट है:

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 और ब्लॉग पोस्ट ।

जब तक ब्राउज़र थ्रो और अपवाद नहीं हो जाता, तब तक स्क्रिप्ट पाठ की तेज़ी से बड़ी स्ट्रिंग्स का परीक्षण करेगी। उस समय यह परीक्षण डेटा को साफ़ कर देगा और किलोबाइट्स में आकार को संग्रहीत करते हुए स्थानीयस्टोरेज में एक आकार कुंजी सेट करेगा।

Comments

शांत समाधान। मुझे यह एक लाइनर मिला , आपको क्या लगता है?

— ब्रासोफिलो

@brasofilo मुझे लगता है कि एक लाइनर मानता है कि आपके पास 5MB है और फिर उपयोग की जा रही राशि को घटा देता है।

— cdmckay

Ooook, निश्चित रूप से गोली मार दी। जो समस्या मैं आपके कोड के साथ आ रहा हूं , वह जावास्क्रिप्ट में बाइट्स को KB, MB, GB में आकार बदलने के लिए सही तरीके से सही परिणाम प्राप्त करने में सक्षम नहीं हो रही है ... मैं इसे कल संशोधित करूंगा लेकिन यदि आप एक नज़र ले सकते हैं की सराहना की।

— ब्रासोफिलो

प्रदर्शन और इस जवाब की गुणवत्ता में सुधार यहाँ

— smnbbrv

यह 2020 है और यह उत्तर Win10 पर वेनिला क्रोम और फ़ायरफ़ॉक्स दोनों पर पूरी तरह से ठीक काम करता है, आकार = 5000 दे रहा है।

— ए। चियासा

Answer 4

किसी एकल स्ट्रिंग की अधिकतम लंबाई ज्ञात करें जिसे अंदर संग्रहीत किया जा सकता है 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>

ध्यान दें कि स्ट्रिंग की लंबाई जावास्क्रिप्ट में सीमित है; यदि आप अधिकतम डेटा को देखना चाहते हैं localStorage, जो एक स्ट्रिंग तक सीमित नहीं है, तो आप इस उत्तर में कोड का उपयोग कर सकते हैं ।

संपादित करें: स्टैक स्निपेट्स समर्थन नहीं करते हैं localStorage, इसलिए यहां JSFiddle का लिंक है ।

परिणाम

Chrome (45.0.2454.101): 5242878 वर्ण
फ़ायरफ़ॉक्स (40.0.1): 5242883 वर्ण
इंटरनेट एक्सप्लोरर (11.0.9600.18036) :16,386 122,066 122070 अक्षर

मुझे Internet Explorer में प्रत्येक रन पर अलग-अलग परिणाम मिलते हैं।

Comments

मजेदार, लेकिन ~ 1 मिनट चलने के बाद एज ब्राउजर (विन 10 पर) में परीक्षण करने पर आपका सरल परीक्षण मेरे सुंदर शक्तिशाली सिस्टम को रोक देता है। इसलिए मैं आपके परिणामों में नया डेटा संलग्न नहीं कर सकता))

— vatavale

Answer 5

मोबाइल ब्राउज़र:

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

संदर्भ लिंक

Comments

कहां से आ रहे हैं नंबर?

— MrD

@BehnamMohammadi क्या आप इस संदर्भ को जोड़ सकते हैं कि पूर्णता के लिए आपको यह कहां से मिला

— क्रिस लैंग

और इसमें कोई संदर्भ कभी नहीं भरा गया था। लेकिन बाद की स्थिति के लिए, ये संख्या थोड़ी बदल जाती है। हमें इसे और अधिक ब्राउज़र और वर्तमान जानकारी को अपडेट करना चाहिए।

— मालवोस

@ क्रिसलंग ने लिंक जोड़ा

— मोहम्मदी

@ मालवोस ने लिंक जोड़ा

— मोहम्मदी

Answer 6

मान लें कि 5 एमबी उपलब्ध नहीं है - ब्राउज़र द्वारा लोकलस्टोरेज क्षमता भिन्न होती है, जिसमें 2.5 एमबी, 5 एमबी और असीमित सबसे सामान्य मूल्य हैं। स्रोत: http://dev-test.nemikor.com/web-storage/support-test/

Answer 7

आप बड़ी वस्तुओं को एक ही स्थानीयस्टोरेज प्रविष्टि में जकड़ना नहीं चाहते। यह बहुत ही अयोग्य होगा - हर बार कुछ मामूली विस्तार से बदलाव करने पर पूरी चीज़ को पार्स और फिर से एनकोड करना होगा। इसके अलावा, JSON एक ऑब्जेक्ट संरचना के भीतर कई क्रॉस संदर्भों को संभाल नहीं सकता है और बहुत सारे विवरण मिटा देता है, जैसे कि कंस्ट्रक्टर, सरणियों के गैर-संख्यात्मक गुण, एक विरल प्रविष्टि में क्या है, आदि।

इसके बजाय, आप रूबो का उपयोग कर सकते हैं । यह बहुत सी स्थानीय वस्तुओं को संग्रहीत करता है जो बहुत सारे लोकलस्टेज प्रविष्टियों का उपयोग करता है ताकि आप जल्दी से छोटे बदलाव कर सकें। पुनर्निर्मित वस्तुएं सहेजे गए लोगों की अधिक सटीक प्रतियां हैं और एपीआई अविश्वसनीय रूप से सरल है। उदाहरण के लिए:

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

BTW, मैंने इसे लिखा था।

Comments

धन्यवाद मार्टिन। आप मेरे 'एवोन' रेपो को भी देख सकते हैं। यह अभी केवल एक धारावाहिक है और स्याही बहुत गीली है, लेकिन यह रौबो से तेज है और समान रूप से बहुमुखी है। Rhaboo जल्द ही इसे आंतरिक रूप से उपयोग करने के लिए परिवर्तित किया जाएगा।

— एड्रियन मई

उपयोगी है, लेकिन मुझे नहीं लगता कि यह सवाल "स्थानीय स्तर का अधिकतम आकार क्या है?" जब यह लाइब्रेरी आकार सीमा से परे कुछ संग्रहीत करने का प्रयास करती है, और उस पर प्रतिक्रिया कैसे की जाती है, तो यह बताते हुए कि आपके उत्तर में सुधार किया जा सकता है।

— क्रिस मोशिनिकी

Answer 8

मैं निम्नलिखित कर रहा हूँ:

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

Comments

Maroun Maroun: पोस्ट को फिर से जांचें, लेखक ने प्रोग्राम को स्थानीय भंडारण के अधिकतम आकार की जांच करने के लिए कोड प्रदान किया है। यह एक मान्य उत्तर प्रतीत होता है, और दूसरा प्रश्न नहीं।

— Arend

इस कोड को निष्पादित करने से क्रोम में "अवैध रिटर्न स्टेटमेंट" त्रुटि, लिखने के समय के रूप में

— फेंकता है

Answer 9

मुझे वास्तव में 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

यह मानक त्रुटि के लिए नाटकीय रूप से तेज़ काम करता है; आवश्यकता पड़ने पर यह बहुत अधिक सटीक भी हो सकता है।

Answer 10

मैंने इस फ़ंक्शन में एक द्विआधारी परीक्षण की निंदा की है जिसका मैं उपयोग करता हूं:

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

यह भी परीक्षण से पहले सामग्री का समर्थन करता है, फिर उन्हें पुनर्स्थापित करता है।

यह कैसे काम करता है: यह आकार तक दोगुना हो जाता है जब तक कि सीमा पूरी नहीं हो जाती या परीक्षण विफल हो जाता है। यह तब कम और उच्च और घटाव के बीच की आधी दूरी को संग्रहीत करता है / हर बार आधे का आधा जोड़ता है (असफलता पर घटाना और सफलता में जोड़ना); उचित मूल्य में सम्मान।

upperLimitडिफ़ॉल्ट रूप से 1GB है, और बाइनरी खोज शुरू करने से पहले घातीय स्कैन करने के लिए सिर्फ ऊपर की तरफ कितनी सीमा है। मुझे संदेह है कि इसे बदलने की आवश्यकता होगी, लेकिन मैं हमेशा आगे की सोच रहा हूं। ;)

क्रोम पर:

> 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 बाइट्स) की रिपोर्ट करते हैं।

Comments

(और localStorage.Clear()अपने परीक्षण से पहले और बाद में मत भूलना

— simonmysun

Answer 11

आप वास्तविक समय में स्टोरेज कोटा (कुल और उपयोग) की कुशलता से जांच करने के लिए आधुनिक ब्राउज़रों में निम्न कोड का उपयोग कर सकते हैं:

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

Comments

Chrome के लिए अच्छा काम नहीं करता है। Usage (in Bytes): 647 , Total Quota (in Bytes): 32901464711 यह गलत है: कुल संभव आकार वास्तव में 10485762 है।

— जेम्स विल्किंस

Answer 12

एक बार जब मैंने क्रोम (डेस्कटॉप ब्राउज़र) का विकास किया और इस कारण से स्थानीय भंडारण वास्तविक अधिकतम आकार का परीक्षण किया ।

मेरे परिणाम:

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: 'StorageIt' पर 'setItem' को निष्पादित करने में विफल: 'नोट्स' का मान सेट करने से कोटा समाप्त हो गया।

Answer 13

मैंने यह सरल कोड लिखा था जो बाइट्स में लोकलस्टोरेज आकार का परीक्षण कर रहा है।

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

गिथब पृष्ठ:

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

मैं डेस्कटॉप क्रोम, ओपेरा, फ़ायरफ़ॉक्स, बहादुर और मोबाइल क्रोम पर एक ही परिणाम है जो ~ 5Mbytes है

और सफारी में आधा छोटा परिणाम ~ 2Mbytes