स्थानीयस्टोरेज का आकार कैसे पता करें


117

मैं वर्तमान में एक साइट विकसित कर रहा हूं जो HTML5 के लोकलस्टोरेज का उपयोग करेगी। मैंने विभिन्न ब्राउज़रों के लिए आकार की सीमाओं के बारे में पढ़ा है। हालाँकि, मैंने कुछ नहीं देखा है कि किस तरह से किसी लोकलस्टोरेज उदाहरण के वर्तमान आकार का पता लगाया जाए। यह प्रश्न इंगित करता है कि जावास्क्रिप्ट के पास किसी दिए गए चर के आकार को दिखाने के तरीके में अंतर्निहित नहीं है। क्या लोकलस्टोरेज में मेमोरी साइज प्रॉपर्टी है जो मैंने नहीं देखी है? क्या ऐसा करने का एक आसान तरीका है जो मुझे याद आ रहा है?

मेरी साइट उपयोगकर्ताओं को 'ऑफ़लाइन' मोड में जानकारी दर्ज करने की अनुमति देने के लिए है, इसलिए भंडारण लगभग पूर्ण होने पर उन्हें चेतावनी देने में सक्षम होना बहुत महत्वपूर्ण है।


जवाबों:


219

जावास्क्रिप्ट कंसोल (एक लाइन संस्करण) में इस स्निपेट को निष्पादित करें:

var _lsTotal=0,_xLen,_x;for(_x in localStorage){ if(!localStorage.hasOwnProperty(_x)){continue;} _xLen= ((localStorage[_x].length + _x.length)* 2);_lsTotal+=_xLen; console.log(_x.substr(0,50)+" = "+ (_xLen/1024).toFixed(2)+" KB")};console.log("Total = " + (_lsTotal / 1024).toFixed(2) + " KB");

पढ़ने के लिए कई लाइनों में एक ही कोड

var _lsTotal = 0,
    _xLen, _x;
for (_x in localStorage) {
    if (!localStorage.hasOwnProperty(_x)) {
        continue;
    }
    _xLen = ((localStorage[_x].length + _x.length) * 2);
    _lsTotal += _xLen;
    console.log(_x.substr(0, 50) + " = " + (_xLen / 1024).toFixed(2) + " KB")
};
console.log("Total = " + (_lsTotal / 1024).toFixed(2) + " KB");

या सुविधाजनक उपयोग के लिए बुकमार्क के फ़ील्ड 'स्थान' में इस पाठ को जोड़ें

javascript: var x, xLen, log=[],total=0;for (x in localStorage){if(!localStorage.hasOwnProperty(x)){continue;} xLen =  ((localStorage[x].length * 2 + x.length * 2)/1024); log.push(x.substr(0,30) + " = " +  xLen.toFixed(2) + " KB"); total+= xLen}; if (total > 1024){log.unshift("Total = " + (total/1024).toFixed(2)+ " MB");}else{log.unshift("Total = " + total.toFixed(2)+ " KB");}; alert(log.join("\n")); 

पीएस स्निपेट्स टिप्पणी में अनुरोध के अनुसार अपडेट किए जाते हैं। अब गणना में कुंजी की लंबाई शामिल है। प्रत्येक लंबाई को 2 से गुणा किया जाता है क्योंकि जावास्क्रिप्ट स्टोर में UTF-16 (2 बाइट्स पर कब्जा) के रूप में चार

PPS को Chrome और Firefox दोनों में काम करना चाहिए।


8
कुल देखने के लिए इसे कंसोल में चिपकाएँ: var t = 0; for (var x स्थानीय स्तर पर) {t + = (((localStorage [x] .length * 2)); } कंसोल.लॉग (टी / 1024 + "केबी");
हेनरी

5
@ मीका जावास्क्रिप्ट यूटीएफ 16 का आंतरिक रूप से उपयोग करता है, इसलिए क्योंकि प्रत्येक वर्ण को दो बाइट्स के रूप में संग्रहीत किया जाता है, आपको वास्तविक स्थान का उपयोग करने के लिए वर्णों की संख्या दो से गुणा करने की आवश्यकता होती है। (आप शायद पहले से ही यह पता लगा चुके हैं, लेकिन मुझे लगा कि यहां किसी और के लिए भी यही सवाल है।)
रेबेका

2
@ सर्ज, इस जवाब को सबसे अधिक वोट दिया गया है इसलिए यहां पोस्टिंग var t = 0; for(var x in localStorage) { t += (x.length + localStorage[x].length) * 2; } console.log(t/1024+ " KB");
मिहिर

17
यहाँ एक संशोधित संस्करण है जो NaN के लिए भी है:var _lsTotal = 0, _xLen, _x; for (_x in localStorage) { _xLen = (((localStorage[_x].length || 0) + (_x.length || 0)) * 2); _lsTotal += _xLen; console.log(_x.substr(0, 50) + " = " + (_xLen / 1024).toFixed(2) + " KB") }; console.log("Total = " + (_lsTotal / 1024).toFixed(2) + " KB");
मारियो सनम

1
बुकमार्क में एक बग है। आप मुख्य कोड और अंडरमार्क में सामान्य नामों में अंडरस्क्राइब चर का उपयोग कर रहे हैं। एकल अंडरस्कोर _xने इसे तोड़ दिया। बस अंडरस्कोर हटा दें।
सोल रिएर

46

@ सौरव ने जो कहा, उसके ऊपर जाते हुए, मैंने एक छोटा सा फंक्शन लिखा, जिसमें आपकी सभी localStorageकुंजियों (वर्तमान डोमेन के लिए) को सही ढंग से पकड़ना चाहिए और संयुक्त आकार की गणना करनी चाहिए ताकि आपको पता चले कि आपकी localStorageवस्तु द्वारा कितनी मेमोरी ली गई है:

var localStorageSpace = function(){
        var allStrings = '';
        for(var key in window.localStorage){
            if(window.localStorage.hasOwnProperty(key)){
                allStrings += window.localStorage[key];
            }
        }
        return allStrings ? 3 + ((allStrings.length*16)/(8*1024)) + ' KB' : 'Empty (0 KB)';
    };

मेरा लौटा: "30.896484375 KB"


1
साभार @tennisgent मेरा आईई 11, एफएफ> 26 और क्रोम के लिए भी काम किया।
अक्की 922234

18

IE में संग्रहण ऑब्जेक्ट की शेष संपत्ति है। अन्य ब्राउज़रों का इस समय कोई संतुलन नहीं है।

मेरा मानना ​​है कि अंतरिक्ष की डिफ़ॉल्ट राशि 5 एमबी है, हालांकि मैंने व्यक्तिगत रूप से इसका परीक्षण नहीं किया है।


1
यह
जस-

प्रति साइट या कुल मिलाकर सभी साइटों के लिए 5 एमबी सीमा है?
दिव्येंदुज

प्रति साइट @divyenduz, मुझे लगता है
एडम

2
ध्यान दें कि स्टोरेज ऑब्जेक्ट के लिए अनुमत UTSt-16 वर्णों की शेष संख्या को LocalStorage.remainingSpace रिटर्न देता है। बाइट्स में शेष आकार नहीं। संदर्भ
मिहिर

14

यह कैसे करना है और हर ब्राउज़र के साथ काम करना चाहिए इसका एक सरल उदाहरण है

alert(1024 * 1024 * 5 - unescape(encodeURIComponent(JSON.stringify(localStorage))).length);

क्या आपको कहीं * 8 की ज़रूरत नहीं है?
जॉर्ज माउर

1
वर्ण सेट पर निर्भर करता है (यानी utf8, आदि) जो कि खाते में नहीं आता है
jas-

क्या यह बाइट्स में आकार देता है, या बिट्स में?
जेम्सइवेरड्यूड

6
यह उदाहरण गलत तरीके से मानता है कि प्रत्येक ब्राउज़र में लोकलस्टोरेज की 5MB (5 * 1024 * 1024) में एक ही तय सीमा है।
विक्टर

यह w3c द्वारा लगाए गए युक्ति के अनुसार है।

13

आशा है कि यह किसी की मदद करेंगे।

क्योंकि जैस- jsfiddle पर उदाहरण मेरे लिए काम नहीं करता है मैं इस समाधान के साथ आया हूं। (नीचे दिए गए कोड में इस्तेमाल किए गए अपने बिट्स के लिए सर्ज सेलेटस्की और शौरव के लिए धन्यवाद)

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

यह थोड़ा क्रूर बल है, लेकिन यह फ़ायरफ़ॉक्स के अलावा लगभग हर ब्राउज़र में काम करता है। अच्छी तरह से डेस्कटॉप एफएफ में इसे पूरा करने में उम्र (4-5 मिनट) लगती है, और एंड्रॉइड पर यह बस दुर्घटनाग्रस्त हो जाता है।

फ़ंक्शन के नीचे, परीक्षणों का एक छोटा सारांश है जो मैंने विभिन्न प्लेटफार्मों पर विभिन्न ब्राउज़रों में किया है। का आनंद लें!

function testLocalStorage() {
    var timeStart = Date.now();
    var timeEnd, countKey, countValue, amountLeft, itemLength;
    var occupied = leftCount = 3; //Shurav's comment on initial overhead
//create localStorage entries until localStorage is totally filled and browser issues a warning.
    var i = 0;
    while (!error) {
        try {
//length of the 'value' was picked to be a compromise between speed and accuracy, 
// the longer the 'value' the quicker script and result less accurate. This one is around 2Kb 
            localStorage.setItem('testKey' + i, '11111111112222222222333333333344444444445555555555666661111111111222222222233333333334444444444555555555566666');
        } catch (e) {
            var error = e;
        }
        i++;
    }
//if the warning was issued - localStorage is full.
    if (error) {
//iterate through all keys and values to count their length
        for (var i = 0; i < localStorage.length; i++) {
            countKey = localStorage.key(i);
            countValue = localStorage.getItem(localStorage.key(i));
            itemLength = countKey.length + countValue.length;
//if the key is one of our 'test' keys count it separately
            if (countKey.indexOf("testKey") !== -1) {
                leftCount = leftCount + itemLength;
            }
//count all keys and their values
            occupied = occupied + itemLength;
        }
        ;
//all keys + values lenght recalculated to Mb
        occupied = (((occupied * 16) / (8 * 1024)) / 1024).toFixed(2);
//if there are any other keys then our 'testKeys' it will show how much localStorage is left
        amountLeft = occupied - (((leftCount * 16) / (8 * 1024)) / 1024).toFixed(2);
//iterate through all localStorage keys and remove 'testKeys'
        Object.keys(localStorage).forEach(function(key) {
            if (key.indexOf("testKey") !== -1) {
                localStorage.removeItem(key);
            }
        });

    }
//calculate execution time
    var timeEnd = Date.now();
    var time = timeEnd - timeStart;
//create message
    var message = 'Finished in: ' + time + 'ms \n total localStorage: ' + occupied + 'Mb \n localStorage left: ' + amountLeft + "Mb";
//put the message on the screen
    document.getElementById('scene').innerText = message; //this works with Chrome,Safari, Opera, IE
//document.getElementById('scene').textContent = message;  //Required for Firefox to show messages
}

और जैसा कि विभिन्न ब्राउज़रों में कुछ परीक्षण के ऊपर वादा किया गया है:

गैलेक्सीटब 10.1

  • मैक्सथन पैड 1.7 ~ 1130ms 5Mb
  • फ़ायरफ़ॉक्स 20.0 (बीटा 20.0) दोनों दुर्घटनाग्रस्त हो गया
  • Chrome 25.0.1364.169 ~ 22250ms / 5Mb
  • मूल निवासी (सफारी 4.0 / Webkit534.30 के रूप में पहचान) ~ 995ms / 5Mb

iPhone 4 जी iOS 6.1.3

  • सफारी ~ 520ms / 5Mb
  • होमएप के रूप में ~ 525ms / 5Mb
  • iCab ~ 710ms / 5mb

मैकबुक प्रो OSX 1.8.3 (कोर 2 डुओ 2.66 8 जीबी मेमोरी)

  • सफारी 6.0.3 ~ 105ms / 5Mb
  • Chrome 26.0.1410.43 ~ 3400ms / 5Mb
  • फ़ायरफ़ॉक्स 20.0 300150ms (!) / 10Mb (लंबे समय तक चलने वाली स्क्रिप्ट के बारे में शिकायत के बाद)

iPad 3 iOS 6.1.3

  • सफारी ~ 430ms / 5Mb
  • iCab ~ 595ms / 5mb

विंडोज 7 -64 बी (कोर 2 डुओ 2.93 6 जीबी मेमोरी)

  • सफारी 5.1.7 ~ 80ms / 5Mb
  • Chrome 26.0.1410.43 ~ 1220ms / 5Mb
  • फ़ायरफ़ॉक्स 20.0 228500ms (!) / 10Mb (लंबे समय तक चलने वाली स्क्रिप्ट के बारे में शिकायत के बाद)
  • IE9 ~ 17900ms / 9.54Mb (यदि कोई कंसोल.लॉग कोड में काम नहीं करते हैं, जब तक कि DevTools दिखाई नहीं देते हैं)
  • ओपेरा 12.15 ~ 4212ms / 3.55Mb (यह तब होता है जब 5Mb का चयन किया जाता है, लेकिन ओपेरा अच्छी तरह से पूछता है कि क्या हम lS की मात्रा बढ़ाना चाहते हैं, दुर्भाग्य से यह क्रैश हो जाता है यदि परीक्षण लगातार एक पंक्ति में कुछ बार आयोजित किया जाता है)

जीत 8 (समानताएं 8 के तहत)

  • IE10 ~ 7850ms / 9.54Mb

महान प्रयोग। हालाँकि मुझे array.forEach()आपके कोड में पता चला है, क्योंकि मुझे पता है कि यह IE में मौजूद नहीं है, क्या आप अपने आप को लागू करते हैं? आप समग्र विलंबता में इसके योगदान को कैसे मापते हैं?
इवि सांग

धन्यवाद, मैं प्रारंभिक परीक्षणों से कुछ समय बीतने के बाद उन्हें फिर से कर सकता हूं। के लिए के रूप में forEach()। नहीं, मैंने इसे स्वयं लागू नहीं किया है, मैंने स्टॉक का उपयोग किया है Array.prototype.forEach()। IE9 से मोज़िला डेवलपर नेटवर्क उर्फ ​​एमडीएन के अनुसार इसमें मूल समर्थन है।
जैकब गडकोव्स्की

धन्यवाद। मेरे ज्ञान को ताज़ा करने की आवश्यकता है। बाद में मैं Array.prototype.forEach()जितना संभव हो उतना उपयोग करूँगा अगर मेरी परियोजना जल्दी IE संस्करणों का समर्थन नहीं करेगी।
इवी सॉन्ग

कोड काफी तेजी से बनाया जा सकता है (फ़ायरफ़ॉक्स में ~ 2500ms, क्रोम में ~ 700ms): whileदो भागों में विभाजित लूप, पहले एक में stackoverflow.com/a/3027249/1235394 जो स्थानीय स्तर पर तेजी से बढ़ते विखंडू के साथ स्थानीयता भरता है, फिर दूसरा भाग भंडारण को पूरी तरह से भरने के लिए निश्चित आकार के छोटे टुकड़े। टेस्ट पेज: jsfiddle.net/pqpps3tk/1
विक्टर

IE10 रॉक्स .. फिर भी, क्रोम डाउनलोड करने के लिए सबसे तेज़ ब्राउज़र :)
रुस्लान अबुजेंट

11

आप ब्लॉब फ़ंक्शन का उपयोग करके स्थानीय संग्रहण डेटा का वर्तमान आकार प्राप्त कर सकते हैं यह पुराने ब्राउज़रों में काम नहीं कर सकता है, new Blobऔर Object.values()caniuse के लिए समर्थन की जांच कर सकता है।

उदाहरण:

return new Blob(Object.values(localStorage)).size;

Object.values ​​() लोकलस्टोरेज ऑब्जेक्ट को एक अरै में बदल देता है। बूँद सरणी को कच्चे डेटा में बदल देती है।


3
मुझे लगता Blobहै कि यह यूटीएफ -16 के लिए स्ट्रिंग एन्कोडिंग को प्रतिबंधित नहीं करता है, इसलिए यह वास्तव में सबसे विश्वसनीय तरीका हो सकता है। new Blob(['X']).size;= 1 जबकि new Blob(['☃']).size(U + 2603 / स्नोमैन चरित्र) ==> 3. समाधान String.prototype.lengthइस पर ध्यान नहीं देते हैं ("वर्ण" के साथ सौदा) जबकि भंडारण कोटा / सीमा संभावना (बाइट्स के साथ सौदा), और मैं कल्पना कर सकता था उदाहरण के लिए, यह गैर-अंग्रेजी / ASCII वर्णों को संग्रहीत करते समय, आश्चर्य की ओर ले जाता है।
IX3

मैंने जेड के उत्तर का उपयोग किया, जो क्रोम और एफएफ में ब्लॉब समाधान का परीक्षण करने के लिए स्ट्रिंग्स की लंबाई के साथ स्थानीयस्टोरेज आकार की गणना करता है। पहले परीक्षण में, मैंने साइन '1' के साथ लोकलस्टोरेज भरा। दूसरे परीक्षण में, मैंने '' '' 'चिन्ह के साथ लोकलस्टोरेज को भरा, जिसका ब्लॉब ऑब्जेक्ट में बड़ा आकार है। दोनों ही मामलों में मुझे एक ही अधिकतम लोकलस्टोरीज की लंबाई मिली। तो पात्रों का ब्लूब आकार स्थानीय स्तर की सीमा को प्रभावित नहीं करता है। इसीलिए इस उद्देश्य के लिए बूँद का उपयोग नहीं किया जाना चाहिए।
विंसेंट

6

आप निम्नलिखित तरीकों से अपने स्थानीय भंडार की गणना कर सकते हैं:

function sizeofAllStorage(){  // provide the size in bytes of the data currently stored
  var size = 0;
  for (i=0; i<=localStorage.length-1; i++)  
  {  
  key = localStorage.key(i);  
  size += lengthInUtf8Bytes(localStorage.getItem(key));
  }  
  return size;
}

function lengthInUtf8Bytes(str) {
  // Matches only the 10.. bytes that are non-initial characters in a multi-byte sequence.
  var m = encodeURIComponent(str).match(/%[89ABab]/g);
  return str.length + (m ? m.length : 0);
}

console.log(sizeofAllStorage());

अंत में बाइट्स का आकार ब्राउज़र में लॉग इन किया जाएगा।


4

मैं @tennisgen के कोड का उपयोग करूंगा, जो सभी को प्राप्त करता है और सामग्री की गणना करता है, लेकिन मैं कुंजी स्वयं गिनता हूं:

var localStorageSpace = function(){
        var allStrings = '';
        for(var key in window.localStorage){
            allStrings += key;
            if(window.localStorage.hasOwnProperty(key)){
                allStrings += window.localStorage[key];
            }
        }
        return allStrings ? 3 + ((allStrings.length*16)/(8*1024)) + ' KB' : 'Empty (0 KB)';
    };

3

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

function getUsedSpaceOfLocalStorageInBytes() {
    // Returns the total number of used space (in Bytes) of the Local Storage
    var b = 0;
    for (var key in window.localStorage) {
        if (window.localStorage.hasOwnProperty(key)) {
            b += key.length + localStorage.getItem(key).length;
        }
    }
    return b;
}

function getUnusedSpaceOfLocalStorageInBytes() {
    var maxByteSize = 10485760; // 10MB
    var minByteSize = 0;
    var tryByteSize = 0;
    var testQuotaKey = 'testQuota';
    var timeout = 20000;
    var startTime = new Date().getTime();
    var unusedSpace = 0;
    do {
        runtime = new Date().getTime() - startTime;
        try {
            tryByteSize = Math.floor((maxByteSize + minByteSize) / 2);
            localStorage.setItem(testQuotaKey, new Array(tryByteSize).join('1'));
            minByteSize = tryByteSize;
        } catch (e) {
            maxByteSize = tryByteSize - 1;
        }
    } while ((maxByteSize - minByteSize > 1) && runtime < timeout);

    localStorage.removeItem(testQuotaKey);

    if (runtime >= timeout) {
        console.log("Unused space calculation may be off due to timeout.");
    }

    // Compensate for the byte size of the key that was used, then subtract 1 byte because the last value of the tryByteSize threw the exception
    unusedSpace = tryByteSize + testQuotaKey.length - 1;
    return unusedSpace;
}

function getLocalStorageQuotaInBytes() {
    // Returns the total Bytes of Local Storage Space that the browser supports
    var unused = getUnusedSpaceOfLocalStorageInBytes();
    var used = getUsedSpaceOfLocalStorageInBytes();
    var quota = unused + used;
    return quota;
}

Array.join एक प्रदर्शन हत्यारा है, बेहतर उपयोग String.repeat जहाँ उपलब्ध है (अर्थात IE को छोड़कर हर जगह इसका मतलब है)
pkExec

2

@ सर्ज के उत्तर के अलावा जो यहां सबसे अधिक मतदान किया गया है, कुंजी के आकार पर विचार करने की आवश्यकता है। नीचे दिए गए कोड में संग्रहीत कुंजी का आकार जोड़ा जाएगाlocalStorage

var t = 0; 
for (var x in localStorage) { 
    t += (x.length + localStorage[x].length) * 2; 
} 
console.log((t / 1024) + " KB");

मैंने पाया है कि फ़ायरफ़ॉक्स कुछ मामलों में undefinedआइटम के लिए लौटता है length, इसलिए मैंने इसके अलावा एक सशर्त जोड़ा है t += (x.length + (this.storage[x].length ? this.storage[x].length : 0)) * 2;:।
कैमिलाकोवेरिन

@camilokawerin, यह तब तक नहीं होना चाहिए जब तक कि भंडारण में एक अपरिभाषित मूल्य नहीं बचाया जाता है, क्योंकि स्ट्रिंग एकमात्र प्रकार है जो स्थानीयस्टोरेज के साथ समर्थित है और स्ट्रिंग में संपत्ति की लंबाई है। आप jsfiddle या कुछ इसी तरह पर कुछ उदाहरण पोस्ट कर सकते हैं?
मिहिर

1

जैसा कि कल्पना जाती है, एक स्ट्रिंग का प्रत्येक चरित्र 16 बिट है।

लेकिन क्रोम (सेटिंग्स> सामग्री सेटिंग्स> कुकीज़ और साइट डेटा) के साथ निरीक्षण करने से पता चलता है कि लोकलस्टोरेज शुरू करने में 3kB (ओवरहेड आकार) लगता है

और संग्रहीत डेटा का आकार इस संबंध (1kB के लिए सटीक)
3 + ((localStorage.x.length * 16) / (8 * 1024) निम्न प्रकार है kB

जहाँ localStorage.x आपकी स्टोरेज स्ट्रिंग है।


0

// कुंजी और मूल्य दोनों द्वारा मेमोरी पर कब्जा इसलिए अपडेटेड कोड।

var jsonarr=[];
var jobj=null;
for(x in sessionStorage) // Iterate through each session key
{
    jobj={}; 
    jobj[x]=sessionStorage.getItem(x); //because key will also occupy some memory
    jsonarr.push(jobj);
    jobj=null;
}
//https://developer.mozilla.org/en/docs/Web/JavaScript/Data_structures 
//JavaScript's String type is used to represent textual data. It is a set of "elements" of 16-bit unsigned integer values. 
var size=JSON.stringify(jsonarr).length*2; //16-bit that's why multiply by 2
var arr=["bytes","KB","MB","GB","TB"]; // Define Units
var sizeUnit=0;
while(size>1024){ // To get result in Proper Unit
    sizeUnit++;
    size/=1024;
}
alert(size.toFixed(2)+" "+arr[sizeUnit]);

0

हां, यह सवाल 10 साल पहले की तरह पूछा गया था। लेकिन उन लोगों के लिए (जैसे मैं खुद को ऑफ़लाइन पाठ संपादक बना रहा हूं जो स्थानीय भंडारण के साथ डेटा बचाता है) और प्रोग्रामिंग में चूसना, आप इस तरह से कुछ सरल उपयोग कर सकते हैं:

var warning = 1;
var limit = 2000000; //2 million characters, not really taking in account to bytes but for tested ammounts of characters stored
setInterval(function() {
    localStorage["text"] = document.getElementById("editor").innerHTML; //gets text and saves it in local storage under "text"
    if(localStorage["text"].length > limit && warning == 1){
            alert("Local Storage capacity has been filled"); 
            warning = 2; //prevent a stream of alerts
    }
}, 1000);
//setInterval function saves and checks local storage

भरे हुए भंडारण की मात्रा प्राप्त करने का सबसे अच्छा तरीका साइट सेटिंग्स को देखना है (कहते हैं, यदि आपने स्थानीय भंडारण में एक छवि संग्रहीत की है)। कम से कम क्रोम में, आप उपयोग किए जाने वाले बाइट्स की मात्रा (यानी: 1222 बाइट्स) देख सकते हैं। हालांकि, js के साथ भरे हुए स्थानीय भंडारण को देखने के सर्वोत्तम तरीके पहले ही ऊपर बताए गए हैं, इसलिए उनका उपयोग करें।


हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.