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

var SIZES = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];

function formatBytes(bytes, decimals) {
  for(var i = 0, r = bytes, b = 1024; r > b; i++) r /= b;
  return `${parseFloat(r.toFixed(decimals))} ${SIZES[i]}`;
}

Answer 2

Ich habe einen Algorithmus 7 mal schneller gemacht (funktioniert wie ein Ninja):

function rafaelFormatBytes(number){
  if(number == null || number === undefined || number <= 0) {
    return '0 Bytes';
  }
  var scaleCounter = 0;
  var scaleInitials = [' Bytes',' KB',' MB',' GB',' TB',' PB',' EB',' ZB',' YB'];
  while (number >= 1024 && scaleCounter < scaleInitials.length - 1){
    number /= 1024;
    scaleCounter++;
  }
  if(scaleCounter >= scaleInitials.length) scaleCounter = scaleInitials.length - 1;
  var compactNumber = number.toFixed(2)
                              .replace(/\.?0+$/,'')
                              .replace(/\B(?=(\d{3})+(?!\d))/g, ",");
  compactNumber += scaleInitials[scaleCounter];
  return compactNumber.trim();
}
var testNum = 0;

var startTime, endTime;

function start() {
  startTime = new Date();
};

function end() {
  endTime = new Date();
  var timeDiff = endTime - startTime; //in ms
  // strip the ms
  timeDiff /= 1000;

  // get seconds 
  var seconds = Math.round(timeDiff, 5);
  console.log(timeDiff + " seconds");
}

function formatBytes(a,b=2,k=1024){with(Math){let d=floor(log(a)/log(k));return 0==a?"0 Bytes":parseFloat((a/pow(k,d)).toFixed(max(0,b)))+" "+["Bytes","KB","MB","GB","TB","PB","EB","ZB","YB"][d]}}

console.log(formatBytes(1000000000000000000000000000));
console.log(rafaelFormatBytes(1000000000000000000000000000));

start();
for(i=0; i<100000; i++){
    formatBytes(1000000000000000);
}
end();
start();
for(i=0; i<100000; i++){
    rafaelFormatBytes(1000000000000000);
}
end();

... und die Ausgabe:

827.18 YB
827.18 YB
0.293 seconds
0.039 seconds

Jesus Christ!!!!

Answer 3

Ich aktualisiere hier die Antwort von @Aliceljm. Da der Dezimalpunkt für 1,2-stellige Zahlen wichtig ist, runde ich die erste Dezimalstelle ab und behalte die erste Dezimalstelle. Für 3-stellige Zahlen runde ich den Einerplatz ab und ignoriere alle Dezimalstellen.

getMultiplers : function(bytes){
    var unit = 1000 ;
    if (bytes < unit) return bytes ;
    var exp = Math.floor(Math.log(bytes) / Math.log(unit));
    var pre = "kMGTPE".charAt(exp-1);
    var result = bytes / Math.pow(unit, exp);
    if(result/100 < 1)
        return (Math.round( result * 10 ) / 10) +pre;
    else
        return Math.round(result) + pre;
}

Answer 4

Sie können die pretty-bytes Bibliothek verwenden.

Installation

npm install pretty-bytes

Verwendung

import prettyBytes from 'pretty-bytes';

prettyBytes(1337);
//=> '1,34 kB'

prettyBytes(100);
//=> '100 B'

// Anzeige mit Einheiten von Bits
prettyBytes(1337, {bits: true});
//=> '1,34 kbit'

// Anzeige von Dateigrößenunterschieden
prettyBytes(42, {signed: true});
//=> '+42 B'

// Lokalisierte Ausgabe mit deutscher Locale
prettyBytes(1337, {locale: 'de'});
//=> '1,34 kB'

Answer 5

Dies hat für mich mit React und TypeScript funktioniert.

export const FormatBytes = (bytes: number) => {
  const units = ['b', 'kb', 'mb', 'gb', 'tb'];

  let i = 0;

  for (i; bytes >= 1024 && i < 4; i++) {
    bytes /= 1024;
  }

  return `${bytes.toFixed(2)} ${units[i]}`;
};