Richtiger Weg, um die Größe in Bytes in KB, MB, GB in JavaScript umzuwandeln

Question

Ich habe diesen Code erhalten, um die Größe in Bytes über PHP umzurechnen.

Jetzt möchte ich diese Größen in benutzerfreundliche Größen mit JavaScript umrechnen. Ich habe versucht, diesen Code in JavaScript umzuwandeln, der so aussieht:

function formatSizeUnits(bytes){
  if      (bytes >= 1073741824) { bytes = (bytes / 1073741824).toFixed(2) + " GB"; }
  else if (bytes >= 1048576)    { bytes = (bytes / 1048576).toFixed(2) + " MB"; }
  else if (bytes >= 1024)       { bytes = (bytes / 1024).toFixed(2) + " KB"; }
  else if (bytes > 1)           { bytes = bytes + " bytes"; }
  else if (bytes == 1)          { bytes = bytes + " byte"; }
  else                          { bytes = "0 bytes"; }
  return bytes;
}

Ist das der richtige Weg, dies zu tun? Gibt es einen einfacheren Weg?

Answer 1

Von hier aus: (Quelle)

---

Unminified und ES6'ed: (von der Community)

function formatBytes(bytes, decimals = 2) {
    if (!+bytes) return '0 Bytes'

    const k = 1024
    const dm = decimals < 0 ? 0 : decimals
    const sizes = ['Bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']

    const i = Math.floor(Math.log(bytes) / Math.log(k))

    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`
}

// Democode
document.body.innerHTML += `1000 Bytes`

Minimized Version (von der StackOverflow-Community, minimiert von JSCompress)

function formatBytes(a,b=2){if(!+a)return"0 Bytes";const c=0>b?0:b,d=Math.floor(Math.log(a)/Math.log(1024));return`${parseFloat((a/Math.pow(1024,d)).toFixed(c))} ${["Bytes","KiB","MiB","GiB","TiB","PiB","EiB","ZiB","YiB"][d]}`}

Verwendung:

// formatBytes(bytes, decimals)

formatBytes(1024)       // 1 KiB
formatBytes('1024')     // 1 KiB
formatBytes(1234)       // 1.21 KiB
formatBytes(1234, 3)    // 1.205 KiB
formatBytes(0)          // 0 Bytes
formatBytes('0')        // 0 Bytes

PS : Ändern Sie k = 1000 oder sizes = ["..."] wie Sie möchten (Bits oder Bytes)

Answer 2

Diese Lösung enthält einen Dezimalpunkt und eine Zehntel-Stelle, wenn weniger als zehn KB oder größere Einheiten präsentiert werden

const units = ['Bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];

function niceBytes(x){

  let l = 0, n = parseInt(x, 10) || 0;

  while(n >= 1024 && ++l){
      n = n/1024;
  }

  return(n.toFixed(n < 10 && l > 0 ? 1 : 0) + ' ' + units[l]);
}

Ergebnisse:

niceBytes(7)                   // 7 Bytes
niceBytes(435)                 // 435 Bytes
niceBytes(3398)                // 3,3 KiB
niceBytes(490398)              // 479 KiB
niceBytes(6544528)             // 6,2 MiB
niceBytes(23483023)            // 22 MiB
niceBytes(3984578493)          // 3,7 GiB
niceBytes(30498505889)         // 28 GiB
niceBytes(9485039485039445)    // 8,4 PiB

Hinweis: Verwenden Sie die Abkürzungen "Kib" usw. bei Verwendung der Basis 1024, da "KB" usw. tatsächlich auf Basis 1000 beziehen. Wenn Sie den Wert auf Basis 1000 berechnen möchten, ersetzen Sie einfach 1024 durch 1000 in dieser Funktion und verwenden Sie die entsprechenden Einheiten (kB, MB, usw.)

Answer 3

function formatBytes(bytes) {
    var marker = 1024; // Bei Bedarf auf 1000 ändern
    var decimal = 3; // Bei Bedarf ändern
    var kiloBytes = marker; // Ein Kilobyte sind 1024 Bytes
    var megaBytes = marker * marker; // Ein MB sind 1024 KB
    var gigaBytes = marker * marker * marker; // Ein GB sind 1024 MB
    var teraBytes = marker * marker * marker * marker; // Ein TB sind 1024 GB

    // Bytes zurückgeben, wenn weniger als ein KB
    if(bytes < kiloBytes) return bytes + " Bytes";
    // KB zurückgeben, wenn weniger als ein MB
    else if(bytes < megaBytes) return(bytes / kiloBytes).toFixed(decimal) + " KB";
    // MB zurückgeben, wenn weniger als ein GB
    else if(bytes < gigaBytes) return(bytes / megaBytes).toFixed(decimal) + " MB";
    // GB zurückgeben, wenn weniger als ein TB
    else return(bytes / gigaBytes).toFixed(decimal) + " GB";
}

Answer 4

Hier ist ein Einzeiler:

val => ['Bytes','Kb','Mb','Gb','Tb'][Math.floor(Math.log2(val)/10)]

Oder sogar:

v => 'BKMGT'[~~(Math.log2(v)/10)]

Mit Anzahl:

function shortenBytes(n) {
    const k = n > 0 ? Math.floor((Math.log2(n)/10)) : 0;
    const rank = (k > 0 ? 'KMGT'[k - 1] : '') + 'b';
    const count = Math.floor(n / Math.pow(1024, k));
    return count + rank;
}

Answer 5

Sie können die filesizejs Bibliothek verwenden.