Mengubah ukuran file dalam byte menjadi string yang dapat dibaca manusia

239

Saya menggunakan fungsi ini untuk mengonversi ukuran file dalam byte ke ukuran file yang dapat dibaca manusia:

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

Namun, sepertinya ini tidak 100% akurat. Sebagai contoh:

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

Bukankah ini seharusnya "1.5 GB"? Sepertinya pembagian pada tahun 1024 kehilangan presisi. Apakah saya benar-benar salah memahami sesuatu atau ada cara yang lebih baik untuk melakukan ini?

Hristo
sumber
3
getReadableFileSizeString (0); mengembalikan 0,1 kb; p
Daniel Magnusson
2
Mengapa harus 1,5? Itu 1.445281982421875yang dibulatkan dengan benar ke 1.4.
buka
1
1551859712 / (1024 ^ 3) = 1.445281982421875 yang benar!
HM
2
Saya suka bahwa Anda menambahkan YB. Siapa pun yang ragu akan mendapatkan 1 YB untuk DB-nya. Itu akan menelan biaya 100 triliun dolar !
guyarad
4
@guyarad - ada gambar terkenal hard drive 5MB dari 50 tahun yang lalu (seukuran kamar dan beratnya sekitar satu ton). Saya yakin saat itu mereka bahkan tidak bermimpi tentang GB dan TB, dan melihat di mana kita hari ini ... tidak pernah mengatakan tidak pernah ;-)
TheCuBeMan

Jawaban:

45

Itu tergantung pada apakah Anda ingin menggunakan konvensi biner atau desimal.

RAM, misalnya, selalu diukur dalam biner, sehingga untuk mengekspresikan 1551859712 sebagai ~ 1.4GiB akan benar.

Di sisi lain, produsen hard disk suka menggunakan desimal, sehingga mereka menyebutnya ~ 1,6GB.

Dan hanya untuk membingungkan, floppy disk menggunakan campuran kedua sistem - 1MB mereka sebenarnya 1024000 byte.

Neil
sumber
3
makan malam lucu ;-) "hanya membingungkan, floppy disk menggunakan campuran kedua sistem - 1MB mereka sebenarnya 1024000 byte."
FranXho
benar, ukuran RAM diukur menggunakan unit IEC, ukuran disk menggunakan metrik .. ada modul npm isomorfik untuk mengkonversi keduanya: ukuran byte
Lloyd
351

Inilah yang saya tulis:

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

Mpen
sumber
1
Saya sedang membuat satu penyesuaian: Saat mengevaluasi ambang, ambil nilai absolut. Dengan cara ini fungsi akan mendukung nilai negatif. Fungsi yang bagus! Terima kasih karena tidak menggunakan pernyataan switch !!
Aaron Blenkush
20
@ AaronBlenkush: Kapan Anda akan memiliki ukuran file negatif?
mpen
14
Saya baru saja menyalin fungsi Anda ke Google Sheet yang saya gunakan untuk menampilkan ukuran delta setelah operasi "pembersihan". Sebelum, Setelah, dan Diff. Operasi pembersihan menghasilkan pertumbuhan beberapa tabel database, dan pengurangan yang lain. Misalnya, Tabel A memiliki perbedaan -1,95 MB, sedangkan Tabel B memiliki perbedaan 500 kB. Karena itu: positif dan negatif :-)
Aaron Blenkush
Ini adalah versi terkompresi dari skrip: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
1
@ RAnders00: Terima kasih untuk versi yang diperkecil. Bisakah Anda ceritakan, meskipun, mengapa Anda memasukkan dua karakter Unicode tak terlihat U + 200C (ZERO WIDTH NON-JOINER) dan U + 200B (ZERO WIDTH SPACE) setelah E sering EIB ? Apakah ini dimaksudkan sebagai tanda air, sehingga Anda dapat melacak siapa yang menggunakan kode ini? Jika demikian, saya pikir Anda harus membuatnya transparan dalam posting Anda.
Leviathan
81

Perwujudan lain dari perhitungan

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];
};
Andrew V.
sumber
8
tampaknya tidak menangani 0
Offirmo
4
Itu menangani atau tidak menangani 0? Lagi pula, ini dengan if (size == 0) {} else {} masih lebih elegan dari yang pernah saya lihat.
Rodrigo
13
Mengubah baris pertama var i = size == 0 ? 0 : Math.floor( Math.log(size) / Math.log(1024) );tampaknya melakukan trik jika 0. Ini akan mengembalikan "0 B".
Gavin
Hanya FYI; Saya tahu jawabannya adalah JavaScript biasa, tetapi jika seseorang tidak mau menggunakannya dalam TypeScript, itu tidak berfungsi (tidak diketik dengan benar, seperti yang Anda lakukan toFixeddan kemudian melakukan matematika dengan string. Apa fungsinya * 1?
Frexuz
1
The *1mengubah tipe data dari string ke nomor, jadi untuk nilai 1024yang Anda dapatkan 1 kBbukan 1.00 kB. Anda dapat membuat TypeScript bahagia dengan melakukan Number((size / Math.pow(1024, i)).toFixed(2))untuk mencapai hal yang sama.
Adrian T
38

Berikut adalah prototipe untuk mengonversi angka menjadi string yang dapat dibaca sehubungan dengan standar internasional baru.

Ada dua cara untuk merepresentasikan angka besar: Anda bisa menampilkannya dalam kelipatan 1000 = 10 3 (basis 10) atau 1024 = 2 10 (basis 2). Jika Anda membagi dengan 1000, Anda mungkin menggunakan nama awalan SI, jika Anda membagi dengan 1024, Anda mungkin menggunakan nama awalan IEC. Masalahnya dimulai dengan membaginya dengan 1024. Banyak aplikasi menggunakan nama awalan SI untuk itu dan beberapa menggunakan nama awalan IEC. Situasi saat ini berantakan. Jika Anda melihat nama awalan SI, Anda tidak tahu apakah jumlahnya dibagi 1000 atau 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});

Fungsi ini mengandung no loop , jadi mungkin lebih cepat dari beberapa fungsi lainnya.

Pemakaian:

Awalan IEC

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

Awalan SI

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

Saya menetapkan IEC sebagai default karena saya selalu menggunakan mode biner untuk menghitung ukuran file ... menggunakan kekuatan 1024


Jika Anda hanya ingin salah satu dari mereka dalam fungsi oneliner pendek:

SI

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

IEC

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

Pemakaian:

console.log(fileSizeIEC(7412834521));

jika Anda memiliki beberapa pertanyaan tentang fungsi, tanyakan saja

cocco
sumber
kode ringkas yang sangat bagus, saya pribadi akan menambahkan beberapa karakter ekstra untuk mengontrol tempat desimal.
Orwellophile
Hai! Sebenarnya kodenya adalah bagaimana saya menulisnya pertama kali di jsfiddle. Pada tahun-tahun terakhir saya belajar sendiri untuk menggunakan steno dan bitwise. Perangkat seluler lambat, internet lambat, tidak banyak ruang ... melakukan itu saya menghemat banyak waktu. Tapi itu tidak semua, kinerja keseluruhan meningkat di setiap browser secara drastis dan seluruh kode memuat lebih cepat ... saya tidak menggunakan jquery jadi saya tidak perlu memuat 100kb setiap kali. Saya juga perlu mengatakan bahwa saya menulis javascript juga di mikrokontroler, Smart TV, konsol game. yang memiliki ruang terbatas (MCU), kinerja (SmartTV), dan biasanya koneksi lambat (Ponsel)
cocco
Mengatakan bahwa saya harap Anda mengerti pilihan saya. Yang bisa saya lakukan adalah menjelaskan apa yang tidak Anda mengerti atau di sisi lain saya selalu senang mempelajari hal-hal baru. Jika ada sesuatu dalam kode saya yang dapat meningkatkan kinerja atau menghemat ruang, saya senang mendengarnya.
cocco
18
Minifikasi harus menjadi bagian dari proses pembuatan Anda, bukan gaya pengkodean Anda. Tidak ada pengembang serius yang akan menggunakan kode ini karena itu karena terlalu lama untuk membaca dan memverifikasi kebenaran.
huysentruitw
1
Bagi mereka yang benci melihat "15.00 Bytes", Anda dapat memodifikasi bagian ini sedikit:.toFixed(e ? 2 : 0)
Lukman
20
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 GB"

sizeOf (7054110);
// => "6,73 MB"

sizeOf ((3 * 1024 * 1024));
// => "3,00 MB"

Joshaven Potter
sumber
2
Jika Anda ingin menyingkirkan ruang ekstra untuk byte, Anda bisa menggunakan ruang lebar nol \u200b: '\u200bKMGTP'.
cdmckay
15

Solusi sebagai Komponen 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>
        );
    }
});

PEMBARUAN Bagi mereka yang menggunakan es6 di sini adalah versi stateless dari komponen yang sama ini

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,
};
Patrick Mencias-lewis
sumber
1
Terima kasih banyak. Anda baru saja lupa "byte" di dalam Math.log () di baris pertama fungsi
getBytes
Sangat bagus. Untuk disambiguasi, dan dengan notasi ES6, Anda dapat menggunakan ini: return (! Bytes && '0 Bytes') || ${(bytes / (1024 ** i)).toFixed(2)} ${suffixes[i]};
Little Brain
12

Berdasarkan ide cocco , ini contoh yang kurang kompak - tapi semoga lebih komprehensif - contoh.

<!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> 
Kit Kat
sumber
8

Saya ingin perilaku "manajer file" (misalnya, Windows Explorer) di mana jumlah tempat desimal sebanding dengan ukuran angka. Tampaknya tidak ada jawaban lain yang melakukan ini.

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

Inilah beberapa contoh:

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"
Camilo Martin
sumber
menggunakan toFixed mengubahnya menjadi string, jadi ronde Anda bisa berupa string atau angka. ini adalah praktik buruk, Anda dapat dengan mudah mengubahnya kembali ke nomor:+num.tofixed(2)
Vincent Duprez
Tidak .toPrecision(3)mencakup semua kasus ini? Oh .. Saya kira itu tidak mencakup antara 1000 dan 1023. Nyebelin.
mpen
7

Contoh lain mirip dengan yang ada di sini

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

Ini mengukur kinerja yang jauh lebih baik daripada yang lain dengan fitur serupa.

Nick Kuznia
sumber
Ini memang memberikan kinerja yang lebih baik daripada beberapa jawaban lain. Saya menggunakan ini. Beberapa yang lain membuat tab Chrome saya hang dan menggunakan CPU 99,9% saat saya melakukan perhitungan berkala.
Nir Lanka
5

Ini milik saya - berfungsi untuk file yang sangat besar juga -_-

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;
}
cerewet
sumber
Ini menggabungkan hit kinerja baik perulangan dan penggunaan eksponensial, sementara cukup sulit untuk dibaca. Saya tidak begitu mengerti intinya.
spektra
2
Jangan gunakan itu. Hanya cpu clientide yang digunakan jadi siapa yang peduli;)
fiffy
2
@Fiffy Yah, CPU klien juga sangat berharga, terutama pada ponsel dan dengan aplikasi yang kompleks. :)
Raito
5

Berdasarkan jawaban cocco tetapi sedikit desugerified (jujur, yang saya merasa nyaman tetap ada / ditambahkan) dan tidak menunjukkan angka nol tetapi masih mendukung 0, berharap bermanfaat bagi orang lain:

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

Ebrahim Byagowi
sumber
4
1551859712 / 1024 = 1515488
1515488 / 1024 = 1479.96875
1479.96875 / 1024 = 1.44528198242188

Solusi Anda benar. Hal penting yang harus disadari adalah bahwa untuk beralih dari 1551859712ke 1.5, Anda harus melakukan pembagian dengan 1000, tetapi byte dihitung dalam potongan biner-ke-desimal 1024, maka mengapa nilai Gigabyte lebih kecil.

Eli
sumber
@Eli ... ya, sepertinya begitu. Saya kira saya mengharapkan "1,5" sejak 1551859712, tetapi itu berarti saya dalam desimal bukan biner.
Hristo
3

Saya menemukan jawaban @ cocco menarik, tetapi memiliki masalah berikut ini:

  1. Jangan modifikasi tipe asli atau tipe yang tidak Anda miliki
  2. Tulis kode yang bersih dan mudah dibaca untuk manusia, biarkan minifiers mengoptimalkan kode untuk mesin
  3. (Bonus untuk pengguna TypeScript) Tidak bermain dengan baik dengan TypeScript

TypeScript:

 /**
 * 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')
});
moribvndvs
sumber
1

Ini adalah peningkatan ukuran jawaban mpen

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

Kamil Kiełczewski
sumber
0

Bagi yang menggunakan Angular , ada paket bernama angular-pipesyang memiliki pipa untuk ini:

Mengajukan

import { BytesPipe } from 'angular-pipes';

Pemakaian

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

Tautan ke dokumen .

Sinandro
sumber
0

Jawaban saya mungkin terlambat, tapi saya kira itu akan membantu seseorang.

Awalan metrik:

/**
 * 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]}`;
};

Awalan biner:

/**
 * 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]}`;
};

Contoh:

// 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
Kerkouch
sumber
-1

biarkan byte = 1024 * 10 * 10 * 10;

console.log (getReadableFileSizeString (bytes))

akan mengembalikan 1000.0Кб sebagai ganti 1MB

webolizzer
sumber