Die tatsächlichen Zahlen zu den Menschen lesbaren Werte

Question

Ich habe Daten in Bytes. Ich brauche diese Werte als für Menschen lesbare Etikett auf einem Diagramm zu zeichnen (wie 2,5 kb, 14MB etc.) und Notwendigkeit Hilfe bei der Funktion (Eingangsdaten - Istwert, Ausgangs - Menschen lesbarer String).

Ich habe funcion wie diese, aber ich will mehr elegante Realisierung

function tickFormatter(value, type) {

    var suffix = (type == "bytes") ? ['B', 'KB', 'MB', 'GB'] : ['', 'K', 'M', 'G']

    if(value > (1024 * 1024 * 1024 * 1024)) {
        return (value / (1024 * 1024 * 1024 * 1024)).toFixed(2) + suffix[3]
    } else if(value > (1024 * 1024 * 1024)) {
        return (value / (1024 * 1024 * 1024)).toFixed(2) + suffix[2]
    } else if (value > (1024 * 1024)) {
        return (value / (1024 * 1024)).toFixed(2) + suffix[1]
    } else {
        return value.toFixed(2) + suffix[0]
    }
}

Answer 1

Ich liebe diese Umsetzung: klar und kompakt:

function readablizeBytes(bytes) {
    var s = ['bytes', 'kB', 'MB', 'GB', 'TB', 'PB'];
    var e = Math.floor(Math.log(bytes) / Math.log(1024));
    return (bytes / Math.pow(1024, e)).toFixed(2) + " " + s[e];
}

Verbrauch:

readablizeBytes(10000000)
"9.54 MB"

Ich nehme nicht den Kredit dafür.

Answer 2

Dies ist, was ich benutze. Es rundet auf die nächste Einheit, so 1000 „0.98KB“ Wenn Sie nicht wollen, dass dann die erste Math.round zu einem Boden verändern.

var SizePrefixes = ' KMGTPEZYXWVU';
function GetHumanSize(size) {
  if(size <= 0) return '0';
  var t2 = Math.min(Math.round(Math.log(size)/Math.log(1024)), 12);
  return (Math.round(size * 100 / Math.pow(1024, t2)) / 100) +
    SizePrefixes.charAt(t2).replace(' ', '') + 'B';
}

Answer 3

Vielleicht so etwas wie das?

function readable (nb_bytes) {
    if (nb_bytes < 1024) return nb_bytes + 'B';
    else if (nb_bytes < 1024 * 1024) return (Math.round((nb_bytes / 1024) * 100) / 100) + 'KB';
    else return (Math.round((nb_bytes / 1024 / 1024) * 100) / 100) + 'MB';
}

[EDIT]

In Ordnung, da Sie etwas elegantere wollen, nehme ich an Sie denken an eine Schleife. Vielleicht wird dies Ihre Bedürfnisse anzupassen:

function readable (nb_bytes,type) {
    var suffix = type ? ['B','KB','MB','GB'] : ['','K','M','G'];
    var i = 0;
    while (nb_bytes > 1024 && i < suffix.length - 1) {
        ++i;
        nb_bytes = Math.round((nb_bytes / 1024) * 100) / 100;
    }
    return (nb_bytes) + suffix[i];
}

Hier ging ich davon aus type war ein boolean - Wechsel auf was auch immer Sie am besten paßt

.

Answer 4

Modifizierte Version von Amer:

(function GetHumanSize(size) {
  var SizePrefixes = ['','K','M','G','T','P','E','Z','Y'];
  if(size <= 0) return '0';
  var t2 = Math.min(Math.round(Math.log(size)/Math.log(1024)),
                    SizePrefixes.length-1);
  return String((Math.round(size * 100 / Math.pow(1024, t2)) / 100)) + 
         ' ' + SizePrefixes[t2] + 'iB';
})(Math.pow(2,131)) === "2251799813685248 YiB"

Mit:

• IEC Suffixe
• Kein Nicht-Standard-Suffixe

Answer 5

function formatSize(size, standard) {
    if (standard) { 
        standard = standard.toLowerCase();
    }

    var n = 0, 
        base = standard == 'si' ? 1000 : 1024, 
        prefixes = ' KMGTPEZY';

    if (size < 1) {
        return 0;
    }
    else if (size >= base) {
        n = Math.floor( Math.log(size) / Math.log(base) );

        if (n >= prefixes.length) {
            return 'N/A';
        }

        size = ( size / Math.pow(base, n) ).toFixed(2) * 1 + ' ';
    }

    return size + prefixes[n] + ( n && standard == 'iec' ? 'i' : '' ) + 'B';
}

Test:

for (var i = 0; i++ < 10;) console.log( formatSize( Math.pow(10, i) ) ); 

Ausgabe:

10 B
100 B
1000 B
9.77 KB
97.66 KB
976.56 KB
9.54 MB
95.37 MB
953.67 MB
9.31 GB

Answer 6

Ich habe, was ich fühlte das Beste aus den beiden besten Lösungen und kam mit diesem, seine schneller als den ersten, langsamer als den zweiten. Aber ihr Ziel ist immer genau 3 Zeichen zu haben, und nicht rund. Der Grund für die 3 Zeichen begrenzt war aufgrund von Größenbeschränkungen für den Behälter, den er in platziert wurde. Zusätzlich sollten Sie es verwenden möchten nicht Basis zu formatieren 2 Zahlen alles, was Sie tun müssen, ist die Veränderung Kilo bis 1000. Es ist auch Kurzschlüsse, wenn die Anzahl unter 1k ist

var kilo = 1024, suffix = ' KMGTPEZYXWVU', humanReadable = function (number) {
  var retValue = false;
  if (typeof number == "number") {
      if (number < kilo) {
          retValue = number.toString();
      } else {
          var e = Math.floor(Math.log(number) / Math.log(kilo));
          retValue = Number((number / Math.pow(kilo, e)).toString().slice(0, 3)) + suffix.charAt(e) + 'B';
      }
  }
  return retValue;
};

Answer 7

Sie Antworten hat mir wirklich geholfen, so dass ich eine Hilfsmethode schreiben entschieden, dass löst dieses Problem der Größe der Formatierung ein für alle Mal.

Sehen Sie sich meine JSutils Repo Wiki-Seite: https://bitbucket.org/AAverin/jsutils/ | https://github.com/AAverin/JSUtils Es hat humanReadeableSize Methode, die die Größe des Rundungs ??Amirs Weise verwendet, sondern unterstützt auch die Konvertierung zwischen der üblichen Basis 2 (KiB, MIB) und der Basis 10 Zahlen (KB, MB).

Es kann auf den nächsten Wert abrunden, sondern auch um oben an, falls Sie wollen, zum Beispiel, wie viel KB sind in PB.

Fühlen Sie sich frei, um es und die Verwendung in Ihren Projekten zu ergreifen!

Answer 8

Könnte number_to_human_size nutzen (Anzahl Optionen = {})

number_to_human_size(1234567)

Beispiele:

number_to_human_size(123)                                          # => 123 Bytes
number_to_human_size(1234)                                         # => 1.21 KB
number_to_human_size(12345)                                        # => 12.1 KB
number_to_human_size(1234567)                                      # => 1.18 MB
number_to_human_size(1234567890)                                   # => 1.15 GB
number_to_human_size(1234567890123)                                # => 1.12 TB
number_to_human_size(1234567, precision: 2)                        # => 1.2 MB
number_to_human_size(483989, precision: 2)                         # => 470 KB
number_to_human_size(1234567, precision: 2, separator: ',')        # => 1,2 MB

als in der Dokumentation http: //api.rubyonrails .org / classes / ActionView / Helpers / NumberHelper.html # Methode-i-number_to_human_size