बाइट्स में फ़ाइल आकार को मानव-पठनीय स्ट्रिंग में परिवर्तित करना

Question

मैं इस फ़ंक्शन का उपयोग बाइट्स में फ़ाइल आकार को मानव-पठनीय फ़ाइल आकार में बदलने के लिए कर रहा हूं:

function getReadableFileSizeString(fileSizeInBytes) {
    var i = -1;
    var byteUnits = [' kB', ' MB', ' GB', ' TB', 'PB', 'EB', 'ZB', 'YB'];
    do {
        fileSizeInBytes = fileSizeInBytes / 1024;
        i++;
    } while (fileSizeInBytes > 1024);

    return Math.max(fileSizeInBytes, 0.1).toFixed(1) + byteUnits[i];
};

हालाँकि, ऐसा लगता है कि यह 100% सही नहीं है। उदाहरण के लिए:

getReadableFileSizeString(1551859712); // output is "1.4 GB"

यह नहीं होना चाहिए "1.5 GB"? ऐसा लगता है कि 1024 तक विभाजन सटीक खो रहा है। क्या मैं पूरी तरह से कुछ गलत समझ रहा हूं या ऐसा करने का एक बेहतर तरीका है?

Comments

getReadableFileSizeString (0); रिटर्न 0.1kb; पी

— डैनियल मैग्नसन

यह 1.5 क्यों होना चाहिए? यह 1.445281982421875सही ढंग से 1.4 से नीचे गोल है।

— एमपीन

1551859712 / (1024 ^ 3) = 1.445281982421875 जो सही है!

— एचएम

मुझे अच्छा लगा कि आपने जोड़ा YB। संदिग्ध किसी को भी उसके DB के लिए 1 YB मिलेगा। इसकी कीमत होगी 100 ट्रिलियन डॉलर !

— मसराद

@guyarad - 50 साल पहले की 5MB की हार्ड ड्राइव की एक प्रसिद्ध तस्वीर है (एक कमरे के आकार की थी और इसका वजन लगभग एक टन था)। मुझे यकीन है कि वापस तो वे भी जीबी और टीबी के बारे में सपने नहीं देखते थे, और आज हम कहाँ हैं ... कभी नहीं कहते हैं ;-)

— TheCuBeMan

Answer 1

यह निर्भर करता है कि आप बाइनरी या दशमलव सम्मेलन का उपयोग करना चाहते हैं।

उदाहरण के लिए, रैम को हमेशा बाइनरी में मापा जाता है, इसलिए 1551859712 को ~ 1.4GiB के रूप में व्यक्त करना सही होगा।

दूसरी ओर, हार्ड डिस्क निर्माता दशमलव का उपयोग करना पसंद करते हैं, इसलिए वे इसे ~ 1.6GB कहेंगे।

और बस भ्रमित होने के लिए, फ्लॉपी डिस्क दो प्रणालियों के मिश्रण का उपयोग करती है - उनका 1MB वास्तव में 1024000 बाइट्स है।

Comments

supper funny ;-) "बस भ्रमित होने के लिए, फ्लॉपी डिस्क दो प्रणालियों के मिश्रण का उपयोग करती है - उनका 1MB वास्तव में 1024000 बाइट्स है।"

— फ्रैंचो

सच है, रैम आकार IEC इकाइयों, मीट्रिक का उपयोग करके डिस्क आकार का उपयोग करके मापा जाता है .. दोनों को परिवर्तित करने के लिए एक आइसोमॉर्फिक एनपीएम मॉड्यूल है: बाइट-आकार

— लॉयड

Answer 2

यहाँ एक मैंने लिखा है:

function humanFileSize(bytes, si=false, dp=1) {
  const thresh = si ? 1000 : 1024;

  if (Math.abs(bytes) < thresh) {
    return bytes + ' B';
  }

  const units = si 
    ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'] 
    : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
  let u = -1;
  const r = 10**dp;

  do {
    bytes /= thresh;
    ++u;
  } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);


  return bytes.toFixed(dp) + ' ' + units[u];
}


console.log(humanFileSize(5000, true))  // 5.0 kB
console.log(humanFileSize(5000, false))  // 4.9 KiB
console.log(humanFileSize(-10000000000000000000000000000))  // -8271.8 YiB
console.log(humanFileSize(999949, true))  // 999.9 kB
console.log(humanFileSize(999950, true))  // 1.0 MB
console.log(humanFileSize(999950, true, 2))  // 999.95 kB
console.log(humanFileSize(999500, true, 0))  // 1 MB

Comments

मैं एक समायोजन कर रहा हूं: दहलीज का मूल्यांकन करते समय, निरपेक्ष मान लें। इस तरह फ़ंक्शन नकारात्मक मानों का समर्थन करेगा। अच्छा समारोह! स्विच स्टेटमेंट का उपयोग न करने के लिए धन्यवाद !!

— एरोन ब्लेंकुष

@AaronBlenkush: आपके पास एक नकारात्मक फ़ाइल आकार कब होगा?

— एमपीएन

मैंने आपके फ़ंक्शन को एक Google शीट में कॉपी किया है जिसका उपयोग मैं "क्लीनअप" ऑपरेशन के बाद आकार डेल्टा दिखाने के लिए कर रहा हूं। इससे पहले, आफ्टर, और डिफ। क्लीनअप ऑपरेशन के परिणामस्वरूप कुछ डेटाबेस तालिकाओं की वृद्धि हुई, और अन्य में कमी हुई। उदाहरण के लिए, टेबल ए में -1.95 एमबी का अंतर है, जबकि टेबल बी में 500 केबी का अंतर है। इसलिए: सकारात्मक और नकारात्मक :-)

— हारून ब्लेंकश

यहाँ स्क्रिप्ट का संकुचित संस्करण है:function humanFileSize(B,i){var e=i?1e3:1024;if(Math.abs(B)<e)return B+" B";var a=i?["kB","MB","GB","TB","PB","EB","ZB","YB"]:["KiB","MiB","GiB","TiB","PiB","EiB","ZiB","YiB"],t=-1;do B/=e,++t;while(Math.abs(B)>=e&&t<a.length-1);return B.toFixed(1)+" "+a[t]}

— RAnders00

@ RAnders00: कीमा बनाया हुआ संस्करण के लिए धन्यवाद। तुम मुझे बता सकते हैं, हालांकि, तुम क्यों के बाद दो अदृश्य यूनिकोड वर्ण यू 200 सी (शून्य चौड़ाई गैर-योजक) और U + 200B (शून्य चौड़ाई स्पेस) डाला ई बहुधा ईआईबी ? क्या इसका उद्देश्य वॉटरमार्क होना है, ताकि आप यह पता लगा सकें कि इस कोड का उपयोग किसने किया? यदि हां, तो मुझे लगता है कि आपको अपनी पोस्ट में पारदर्शी होना चाहिए।

— लेविथान

Answer 3

गणना का एक और अवतार

function humanFileSize(size) {
    var i = Math.floor( Math.log(size) / Math.log(1024) );
    return ( size / Math.pow(1024, i) ).toFixed(2) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][i];
};

Comments

लगता है 0 नहीं संभालती

— ऑफ्मो

यह 0 को हैंडल करता है या नहीं करता है? आखिरकार, यह एक अगर (आकार == 0) {} और {} के साथ अभी भी अधिक सुरुचिपूर्ण है जो मैंने देखा है।

— रॉड्रिगो

पहली पंक्ति को बदलने के लिए var i = size == 0 ? 0 : Math.floor( Math.log(size) / Math.log(1024) );लगता है कि अगर यह 0. है तो यह "0 बी" लौटाएगा।

— गैविन

सिर्फ आपकी जानकारी के लिए; मुझे पता है कि इसका जवाब सादा जावास्क्रिप्ट है, लेकिन अगर कोई इसे टाइपस्क्रिप्ट में उपयोग नहीं करना चाहता है, तो यह काम नहीं करता है (सही तरीके से टाइप नहीं किया गया है, जैसा कि आप कर रहे हैं toFixedऔर फिर एक स्ट्रिंग के साथ गणित कर रहे हैं । क्या होता * 1है?

— फ्रीक्सुज

*1संख्या के लिए स्ट्रिंग से डेटा प्रकार बदल जाता है, तो मूल्य के लिए 1024आपको मिल 1 kBके बजाय 1.00 kB। आप Number((size / Math.pow(1024, i)).toFixed(2))एक ही चीज़ को पूरा करने के लिए टाइपस्क्रिप्ट को खुश कर सकते हैं ।

— एड्रियन टी

Answer 4

नए अंतरराष्ट्रीय मानकों का सम्मान करते हुए एक संख्या को एक पठनीय स्ट्रिंग में बदलने का एक प्रोटोटाइप है।

बड़ी संख्याओं का प्रतिनिधित्व करने के दो तरीके हैं: आप या तो उन्हें 1000 = 10 3 (बेस 10) या 1024 = 2 10 (बेस 2) के गुणकों में प्रदर्शित कर सकते हैं। यदि आप 1000 से विभाजित करते हैं, तो आप शायद SI उपसर्ग नामों का उपयोग करते हैं, यदि आप 1024 से विभाजित करते हैं, तो आप शायद IEC उपसर्ग नामों का उपयोग करते हैं। समस्या 1024 से विभाजित होने के साथ शुरू होती है। कई अनुप्रयोग इसके लिए SI उपसर्ग नामों का उपयोग करते हैं और कुछ IEC उपसर्ग नामों का उपयोग करते हैं। मौजूदा स्थिति गड़बड़ है। यदि आप SI उपसर्ग नाम देखते हैं, तो आप नहीं जानते कि संख्या 1000 या 1024 से विभाजित है या नहीं

https://wiki.ubuntu.com/UnitsPolicy

http://en.wikipedia.org/wiki/Template:Quantities_of_bytes

Object.defineProperty(Number.prototype,'fileSize',{value:function(a,b,c,d){
 return (a=a?[1e3,'k','B']:[1024,'K','iB'],b=Math,c=b.log,
 d=c(this)/c(a[0])|0,this/b.pow(a[0],d)).toFixed(2)
 +' '+(d?(a[1]+'MGTPEZY')[--d]+a[2]:'Bytes');
},writable:false,enumerable:false});

इस फ़ंक्शन में कोई भी नहीं है loop, और इसलिए यह संभवतः कुछ अन्य कार्यों की तुलना में तेज़ है।

उपयोग:

आईईसी उपसर्ग

console.log((186457865).fileSize()); // default IEC (power 1024)
//177.82 MiB
//KiB,MiB,GiB,TiB,PiB,EiB,ZiB,YiB

एसआई उपसर्ग

console.log((186457865).fileSize(1)); //1,true for SI (power 1000)
//186.46 MB 
//kB,MB,GB,TB,PB,EB,ZB,YB

मैंने IEC को डिफ़ॉल्ट के रूप में सेट किया क्योंकि मैंने हमेशा बाइनरी मोड का उपयोग किया था ... 1024 की शक्ति का उपयोग करके किसी फ़ाइल के आकार की गणना करने के लिए

---

यदि आप बस एक छोटे oneliner समारोह में उनमें से एक चाहते हैं:

एसआई

function fileSizeSI(a,b,c,d,e){
 return (b=Math,c=b.log,d=1e3,e=c(a)/c(d)|0,a/b.pow(d,e)).toFixed(2)
 +' '+(e?'kMGTPEZY'[--e]+'B':'Bytes')
}
//kB,MB,GB,TB,PB,EB,ZB,YB

आईईसी

function fileSizeIEC(a,b,c,d,e){
 return (b=Math,c=b.log,d=1024,e=c(a)/c(d)|0,a/b.pow(d,e)).toFixed(2)
 +' '+(e?'KMGTPEZY'[--e]+'iB':'Bytes')
}
//KiB,MiB,GiB,TiB,PiB,EiB,ZiB,YiB

उपयोग:

console.log(fileSizeIEC(7412834521));

यदि आपके पास केवल पूछे जाने वाले कार्यों के बारे में कुछ प्रश्न हैं

Comments

बहुत अच्छा कॉम्पैक्ट कोड, मैं व्यक्तिगत रूप से दशमलव स्थानों के नियंत्रण के लिए अतिरिक्त आकर्षण के एक जोड़े को जोड़ूंगा।

— ऑरवेलोफाइल 4

नमस्ते! वास्तव में कोड यह है कि मैंने इसे पहली बार jsfiddle में कैसे लिखा। पिछले वर्षों में मैंने शॉर्टहैंड और बिटवाइज़ का उपयोग करना सीखा। धीमा मोबाइल उपकरण, धीमा इंटरनेट, ज्यादा जगह नहीं ... ऐसा करने से मैंने बहुत समय बचाया। लेकिन यह सब नहीं है, हर ब्राउज़र में समग्र पूर्णता में वृद्धि हुई है और पूरे कोड में बहुत तेजी से लोड होता है ... मैं jquery का उपयोग नहीं करता हूं इसलिए मुझे 100kb हर बार लोड करने की आवश्यकता नहीं है। मुझे यह भी कहने की ज़रूरत है कि मैं जावास्क्रिप्ट को माइक्रोकंट्रोलर, स्मार्ट टीवी, गेम कंसोल में भी लिखता हूं। उन लोगों के पास सीमित स्थान (MCU), प्रदर्शन (SmartTV) और स्वाभाविक रूप से कभी-कभी धीमी गति से (मोबाइल)

— cocco

कहा कि मुझे आशा है कि आप मेरी पसंद को समझेंगे। मैं केवल यह समझा सकता हूं कि आप जो नहीं समझते हैं या दूसरी तरफ मैं हमेशा नई चीजें सीखने के लिए खुश हूं। अगर मेरे कोड में ऐसा कुछ है जो प्रदर्शन को बढ़ा सकता है या अंतरिक्ष को बचा सकता है तो मुझे यह सुनकर खुशी होगी।

— कोको डे

न्यूनतम आपकी निर्माण प्रक्रिया का हिस्सा होना चाहिए, न कि आपकी कोडिंग शैली। कोई भी गंभीर डेवलपर इस कोड का उपयोग नहीं करेगा क्योंकि इसकी शुद्धता को पढ़ने और सत्यापित करने में बहुत लंबा समय लगता है।

— huysentruitw

जो लोग "15.00 बाइट्स" देखने के लिए नफरत करते हैं, आप इस हिस्से को थोड़ा संशोधित कर सकते हैं:.toFixed(e ? 2 : 0)

— लुकमान

Answer 5

sizeOf = function (bytes) {
  if (bytes == 0) { return "0.00 B"; }
  var e = Math.floor(Math.log(bytes) / Math.log(1024));
  return (bytes/Math.pow(1024, e)).toFixed(2)+' '+' KMGTP'.charAt(e)+'B';
}

sizeof (2054110009);
// => "1.91 जीबी"

sizeof (7054110);
// => "6.73 एमबी"

sizeOf ((3 * 1024 * 1024));
// => "3.00 एमबी"

Comments

आप बाइट्स के लिए अतिरिक्त जगह से छुटकारा पाने के लिए चाहते थे, तो आप शून्य चौड़ाई अंतरिक्ष इस्तेमाल कर सकते हैं \u200b: '\u200bKMGTP'।

— cdmckay

Answer 6

ReactJS घटक के रूप में समाधान

Bytes = React.createClass({
    formatBytes() {
        var i = Math.floor(Math.log(this.props.bytes) / Math.log(1024));
        return !this.props.bytes && '0 Bytes' || (this.props.bytes / Math.pow(1024, i)).toFixed(2) + " " + ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'][i]
    },
    render () {
        return (
            <span>{ this.formatBytes() }</span>
        );
    }
});

अद्यतन यहाँ es6 का उपयोग करने वालों के लिए इसी घटक का एक सांकेतिक संस्करण है

const sufixes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
const getBytes = (bytes) => {
  const i = Math.floor(Math.log(bytes) / Math.log(1024));
  return !bytes && '0 Bytes' || (bytes / Math.pow(1024, i)).toFixed(2) + " " + sufixes[i];
};

const Bytes = ({ bytes }) => (<span>{ getBytes(bytes) }</span>);

Bytes.propTypes = {
  bytes: React.PropTypes.number,
};

Comments

बहुत धन्यवाद। आप बस "बाइट्स" के अंदर Math.log () getBytes फ़ंक्शन की पहली पंक्ति में भूल गए

— BaptWaels

बहुत अच्छा। विघटन के लिए, और ES6 संकेतन के साथ, आप इसका उपयोग कर सकते हैं: वापसी (और बाइट्स && '0 बाइट्स)) ${(bytes / (1024 ** i)).toFixed(2)} ${suffixes[i]};

— छोटे मस्तिष्क

Answer 7

कोको के विचार के आधार पर , यहाँ एक कम कॉम्पैक्ट-लेकिन उम्मीद है कि अधिक व्यापक उदाहरण हैं।

<!DOCTYPE html>
<html>
<head>
<title>File info</title>

<script>
<!--
function fileSize(bytes) {
    var exp = Math.log(bytes) / Math.log(1024) | 0;
    var result = (bytes / Math.pow(1024, exp)).toFixed(2);

    return result + ' ' + (exp == 0 ? 'bytes': 'KMGTPEZY'[exp - 1] + 'B');
}

function info(input) {
    input.nextElementSibling.textContent = fileSize(input.files[0].size);
} 
-->
</script>
</head>

<body>
<label for="upload-file"> File: </label>
<input id="upload-file" type="file" onchange="info(this)">
<div></div>
</body>
</html> 

Answer 8

मैं "फ़ाइल प्रबंधक" व्यवहार (जैसे, विंडोज एक्सप्लोरर) चाहता था जहां दशमलव स्थानों की संख्या संख्या आकार के लिए आनुपातिक हो। अन्य उत्तर में से कोई भी ऐसा नहीं करता है।

function humanFileSize(size) {
    if (size < 1024) return size + ' B'
    let i = Math.floor(Math.log(size) / Math.log(1024))
    let num = (size / Math.pow(1024, i))
    let round = Math.round(num)
    num = round < 10 ? num.toFixed(2) : round < 100 ? num.toFixed(1) : round
    return `${num} ${'KMGTPEZY'[i-1]}B`
}

यहाँ कुछ उदाहरण हैं:

humanFileSize(0)          // "0 B"
humanFileSize(1023)       // "1023 B"
humanFileSize(1024)       // "1.00 KB"
humanFileSize(10240)      // "10.0 KB"
humanFileSize(102400)     // "100 KB"
humanFileSize(1024000)    // "1000 KB"
humanFileSize(12345678)   // "11.8 MB"
humanFileSize(1234567890) // "1.15 GB"

Comments

toFixed का उपयोग करने से यह एक स्ट्रिंग में परिवर्तित हो जाता है, इसलिए आपका राउंड या तो एक स्ट्रिंग है या एक संख्या है। यह बुरा अभ्यास है, आप इसे आसानी से एक संख्या में बदल सकते हैं:+num.tofixed(2)

— विंसेंट डुपरेज़

.toPrecision(3)इन सभी मामलों को कवर नहीं करता है ? ओह .. मुझे लगता है कि यह 1000 और 1023 के बीच कवर नहीं करता है। बुमेर।

— दोपहर

Answer 9

एक और उदाहरण यहाँ उन लोगों के समान है

function fileSize(b) {
    var u = 0, s=1024;
    while (b >= s || -b >= s) {
        b /= s;
        u++;
    }
    return (u ? b.toFixed(1) + ' ' : b) + ' KMGTPEZY'[u] + 'B';
}

यह समान विशेषताओं वाले दूसरों की तुलना में लापरवाही से बेहतर प्रदर्शन करता है।

Comments

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

— निर्भय

Answer 10

यहाँ मेरा है - बहुत बड़ी फ़ाइलों के लिए भी काम करता है -_-

function formatFileSize(size)
{
    var sizes = [' Bytes', ' KB', ' MB', ' GB', ' TB', ' PB', ' EB', ' ZB', ' YB'];
    for (var i = 1; i < sizes.length; i++)
    {
        if (size < Math.pow(1024, i)) return (Math.round((size/Math.pow(1024, i-1))*100)/100) + sizes[i-1];
    }
    return size;
}

Comments

यह लूपिंग के प्रदर्शन हिट और एक्सपेंशन के उपयोग दोनों को जोड़ती है, जबकि पढ़ने के लिए बहुत कठिन है। मैं वास्तव में बात नहीं देखता।

— स्पेक्टर्स

तब इसका उपयोग न करें। यह सिर्फ क्लाइंटसाइड सीपीयू है, जो परवाह करता है;)

— फिफ्फी

@ अच्छी तरह से, ग्राहक सीपीयू कीमती है, खासकर मोबाइल पर और जटिल अनुप्रयोगों के साथ। :)

— रायटो

Answer 11

कोको के उत्तर के आधार पर, लेकिन थोड़ा निराश्रित (ईमानदारी से, जिनके साथ मैं सहज था / जोड़ा गया है) और अनुगामी शून्य नहीं दिखाता है, लेकिन फिर भी 0 का समर्थन करता है, दूसरों के लिए उपयोगी होने की उम्मीद:

function fileSizeSI(size) {
    var e = (Math.log(size) / Math.log(1e3)) | 0;
    return +(size / Math.pow(1e3, e)).toFixed(2) + ' ' + ('kMGTPEZY'[e - 1] || '') + 'B';
}


// test:
document.write([0, 23, 4322, 324232132, 22e9, 64.22e12, 76.22e15, 64.66e18, 77.11e21, 22e24].map(fileSizeSI).join('<br>'));

Answer 12

1551859712 / 1024 = 1515488
1515488 / 1024 = 1479.96875
1479.96875 / 1024 = 1.44528198242188

आपका समाधान सही है। एहसास करने के लिए महत्वपूर्ण बात यह है कि से प्राप्त 1551859712करने के लिए 1.5, आपको 1000 से विभाजन करना होगा, लेकिन बाइट्स को 1024 के बाइनरी-टू-दशमलव चंक्स में गिना जाता है, इसलिए क्यों गीगाबाइट का मूल्य कम है।

Comments

@ ऐली ... हाँ, ऐसा लगता है। मुझे लगता है कि मैं 1551859712 के बाद से "1.5" की उम्मीद कर रहा था, लेकिन इसका मतलब होगा कि मैं दशमलव में बाइनरी नहीं हूं।

— हिस्टो

Answer 13

मुझे @ कोको का उत्तर दिलचस्प लगा, लेकिन इसके साथ निम्नलिखित मुद्दे थे:

1. देशी प्रकार या उन प्रकारों को संशोधित न करें जिनके आप स्वामी नहीं हैं
2. मनुष्यों के लिए स्वच्छ, पठनीय कोड लिखें, मिनिफायर्स मशीनों के लिए कोड का अनुकूलन करें
3. (टाइपस्क्रिप्ट उपयोगकर्ताओं के लिए बोनस) टाइपस्क्रिप्ट के साथ अच्छा नहीं खेलता है

टाइपप्रति:

 /**
 * Describes manner by which a quantity of bytes will be formatted.
 */
enum ByteFormat {
  /**
   * Use Base 10 (1 kB = 1000 bytes). Recommended for sizes of files on disk, disk sizes, bandwidth.
   */
  SI = 0,
  /**
   * Use Base 2 (1 KiB = 1024 bytes). Recommended for RAM size, size of files on disk.
   */
  IEC = 1
}

/**
 * Returns a human-readable representation of a quantity of bytes in the most reasonable unit of magnitude.
 * @example
 * formatBytes(0) // returns "0 bytes"
 * formatBytes(1) // returns "1 byte"
 * formatBytes(1024, ByteFormat.IEC) // returns "1 KiB"
 * formatBytes(1024, ByteFormat.SI) // returns "1.02 kB"
 * @param size The size in bytes.
 * @param format Format using SI (Base 10) or IEC (Base 2). Defaults to SI.
 * @returns A string describing the bytes in the most reasonable unit of magnitude.
 */
function formatBytes(
  value: number,
  format: ByteFormat = ByteFormat.SI
) {
  const [multiple, k, suffix] = (format === ByteFormat.SI
    ? [1000, 'k', 'B']
    : [1024, 'K', 'iB']) as [number, string, string]
  // tslint:disable-next-line: no-bitwise
  const exp = (Math.log(value) / Math.log(multiple)) | 0
  // or, if you'd prefer not to use bitwise expressions or disabling tslint rules, remove the line above and use the following:
  // const exp = value === 0 ? 0 : Math.floor(Math.log(value) / Math.log(multiple)) 
  const size = Number((value / Math.pow(multiple, exp)).toFixed(2))
  return (
    size +
    ' ' +
    (exp 
       ? (k + 'MGTPEZY')[exp - 1] + suffix 
       : 'byte' + (size !== 1 ? 's' : ''))
  )
}

// example
[0, 1, 1024, Math.pow(1024, 2), Math.floor(Math.pow(1024, 2) * 2.34), Math.pow(1024, 3), Math.floor(Math.pow(1024, 3) * 892.2)].forEach(size => {
  console.log('Bytes: ' + size)
  console.log('SI size: ' + formatBytes(size))
  console.log('IEC size: ' + formatBytes(size, 1) + '\n')
});

Answer 14

यह एमपीएन उत्तर का आकार सुधार है

function humanFileSize(bytes, si=false) {
  let u, b=bytes, t= si ? 1000 : 1024;     
  ['', si?'k':'K', ...'MGTPEZY'].find(x=> (u=x, b/=t, b**2<1));
  return `${u ? (t*b).toFixed(1) : bytes} ${u}${!si && u ? 'i':''}B`;    
}

function humanFileSize(bytes, si=false) {
  let u, b=bytes, t= si ? 1000 : 1024;     
  ['', si?'k':'K', ...'MGTPEZY'].find(x=> (u=x, b/=t, b**2<1));
  return `${u ? (t*b).toFixed(1) : bytes} ${u}${!si && u ? 'i':''}B`;    
}


// TEST
console.log(humanFileSize(5000));      // 4.9 KiB
console.log(humanFileSize(5000,true)); // 5.0 kB

Answer 15

जो लोग उपयोग करते हैं Angular, उनके लिए एक पैकेज है angular-pipesजिसमें इसके लिए एक पाइप है:

फ़ाइल

import { BytesPipe } from 'angular-pipes';

प्रयोग

{{ 150 | bytes }} <!-- 150 B -->
{{ 1024 | bytes }} <!-- 1 KB -->
{{ 1048576 | bytes }} <!-- 1 MB -->
{{ 1024 | bytes: 0 : 'KB' }} <!-- 1 MB -->
{{ 1073741824 | bytes }} <!-- 1 GB -->
{{ 1099511627776 | bytes }} <!-- 1 TB -->
{{ 1073741824 | bytes : 0 : 'B' : 'MB' }} <!-- 1024 MB -->

डॉक्स से लिंक करें ।

Answer 16

मेरा उत्तर देर हो सकता है, लेकिन मुझे लगता है कि यह किसी की मदद करेगा।

मीट्रिक उपसर्ग:

/**
 * Format file size in metric prefix
 * @param fileSize
 * @returns {string}
 */
const formatFileSizeMetric = (fileSize) => {
  let size = Math.abs(fileSize);

  if (Number.isNaN(size)) {
    return 'Invalid file size';
  }

  if (size === 0) {
    return '0 bytes';
  }

  const units = ['bytes', 'kB', 'MB', 'GB', 'TB'];
  let quotient = Math.floor(Math.log10(size) / 3);
  quotient = quotient < units.length ? quotient : units.length - 1;
  size /= (1000 ** quotient);

  return `${+size.toFixed(2)} ${units[quotient]}`;
};

द्विआधारी उपसर्ग:

/**
 * Format file size in binary prefix
 * @param fileSize
 * @returns {string}
 */
const formatFileSizeBinary = (fileSize) => {
  let size = Math.abs(fileSize);

  if (Number.isNaN(size)) {
    return 'Invalid file size';
  }

  if (size === 0) {
    return '0 bytes';
  }

  const units = ['bytes', 'kiB', 'MiB', 'GiB', 'TiB'];
  let quotient = Math.floor(Math.log2(size) / 10);
  quotient = quotient < units.length ? quotient : units.length - 1;
  size /= (1024 ** quotient);

  return `${+size.toFixed(2)} ${units[quotient]}`;
};

उदाहरण:

// Metrics prefix
formatFileSizeMetric(0)      // 0 bytes
formatFileSizeMetric(-1)     // 1 bytes
formatFileSizeMetric(100)    // 100 bytes
formatFileSizeMetric(1000)   // 1 kB
formatFileSizeMetric(10**5)  // 10 kB
formatFileSizeMetric(10**6)  // 1 MB
formatFileSizeMetric(10**9)  // 1GB
formatFileSizeMetric(10**12) // 1 TB
formatFileSizeMetric(10**15) // 1000 TB

// Binary prefix
formatFileSizeBinary(0)     // 0 bytes
formatFileSizeBinary(-1)    // 1 bytes
formatFileSizeBinary(1024)  // 1 kiB
formatFileSizeBinary(2048)  // 2 kiB
formatFileSizeBinary(2**20) // 1 MiB
formatFileSizeBinary(2**30) // 1 GiB
formatFileSizeBinary(2**40) // 1 TiB
formatFileSizeBinary(2**50) // 1024 TiB

Answer 17

लेट्स बाइट्स = 1024 * 10 * 10 * 10;

console.log (getReadableFileSizeString (बाइट))

1MB के बजाय 1000.0Кб लौटेगा