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

Ursprünglich habe ich @Aliceljm's Antwort für ein Datei-Upload-Projekt verwendet, an dem ich gearbeitet habe, aber kürzlich bin auf ein Problem gestoßen, bei dem eine Datei mit 0,98kb als 1,02mb gelesen wurde. Hier ist der aktualisierte Code, den ich jetzt verwende.

function formatBytes(bytes){
  var kb = 1024;
  var ndx = Math.floor( Math.log(bytes) / Math.log(kb) );
  var fileSizeTypes = ["bytes", "kb", "mb", "gb", "tb", "pb", "eb", "zb", "yb"];

  return {
    size: +(bytes / kb / kb).toFixed(2),
    type: fileSizeTypes[ndx]
  };
}

Der obige Code würde dann aufgerufen werden, nachdem eine Datei hinzugefügt wurde, wie folgt

// In diesem Fall ist `file.size` gleich `26060275` 
formatBytes(file.size);
// gibt `{ size: 24,85, type: "mb" }` zurück

Zwar liest Windows die Datei als 24,8mb, aber ich bin mit der zusätzlichen Präzision zufrieden.

Answer 2

Ich wollte einfach meine Meinung teilen. Ich hatte dieses Problem, daher ist meine Lösung diese. Dies wird niedrigere Einheiten in höhere Einheiten und umgekehrt konvertieren, geben Sie einfach das Argument toUnit und fromUnit an

export function fileSizeConverter(size: number, fromUnit: string, toUnit: string ): number | string {
  const units: string[] = ['B', 'KB', 'MB', 'GB', 'TB'];
  const from = units.indexOf(fromUnit.toUpperCase());
  const to = units.indexOf(toUnit.toUpperCase());
  const BASE_SIZE = 1024;
  let result: number | string = 0;

  if (from < 0 || to < 0 ) { return result = 'Fehler: Falsche Einheiten'; }

  result = from < to ? size / (BASE_SIZE ** to) : size * (BASE_SIZE ** from);

  return result.toFixed(2);
}

Ich habe die Idee von hier bekommen

Answer 3

Dies geht nicht darum, Bytes in andere Einheiten umzuwandeln, sondern es hilft dabei, die Zahl und die Einheit für die aktuelle Lokalisierung korrekt anzuzeigen:

bytes.toLocaleString(undefined, {
  style: 'unit',
  unit: 'gigabyte',
})

Weitere Optionen und Details finden Sie hier: https://v8.dev/features/intl-numberformat#units

Answer 4

Flexibler und betrachtet max pow in Größenliste (verbesserte l2aelba Antwort)

function formatBytes(bytes, decimals = 2, isBinary = false) {
      const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB']; // oder ['B', 'KB', 'MB', 'GB', 'TB']

      if (!+bytes) {
        return `0 ${sizes[0]}`;
      }

      const inByte = isBinary ? 1024 : 1000;
      const dm = decimals < 0 ? 0 : decimals;

      const pow = Math.floor(Math.log(bytes) / Math.log(inByte));
      const maxPow = Math.min(pow, sizes.length - 1);

      return `${parseFloat((bytes / Math.pow(inByte, maxPow)).toFixed(dm))} ${
        sizes[maxPow]
      }`;
    }

Answer 5

Ich verwende Rekursion und weise der richtigen Einheit eine Level-Variable zu.

function getReadableByte(count, decimal=0, level=0) {
    let unitList = ["Bytes", "KB", "MB", "GB", "TB", "PT"];

    if (count >= 1024.0 && (level+1 < unitList.length)) {
        return getReadableByte(count/1024, decimal, ++level)
    }
    return `${decimal ? (count).toFixed(decimal) : Math.round(count)}${unitList[level]}`
}

console.log(getReadableByte(120, 2))