Les chiffres réels aux valeurs lisibles par l'homme
https://stackoverflow.com/questions/4498866
-
12-10-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
J'ai données en octets. Je dois tirer ces valeurs comme des étiquettes lisibles par l'homme sur un graphique (comme 2,5 kb, 14MB, etc.) et ont besoin d'aide avec la fonction (données d'entrée - valeur réelle, sortie - chaîne lisible par l'homme).
Je l'ai funcion comme ça, mais je veux réaliser plus élégant
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]
}
}
La solution
J'adore cette mise en œuvre: clair et compact:
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];
}
Utilisation:
readablizeBytes(10000000)
"9.54 MB"
Je ne prends pas le crédit de cela.
Autres conseils
est ce que je l'utilise. Il arrondit à l'unité la plus proche, si 1000 est « 0.98KB » Si vous ne voulez pas, puis modifiez le premier Math.round à un étage.
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';
}
Peut-être quelque chose comme ça?
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]
D'accord, puisque vous voulez quelque chose de plus élégant, je suppose que vous pensez d'une boucle. Peut-être cela répondra à vos besoins:
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];
}
Ici, je suppose type était un booléen - changement à tout ce qui vous convient le mieux
Version modifiée de 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"
- CEI suffixes
- Pas suffixes non standard
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) ) );
Sortie:
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
Je pris ce que je ressentais le meilleur des deux meilleurs solutions et est venu avec cela, son plus rapide que le premier, plus lent que le second. Mais son but est d'avoir toujours exactement 3 caractères, et non pas ronds. La raison de la limite de 3 caractères est due à des contraintes de taille pour le conteneur, il était placé dans. De plus si vous voulez l'utiliser pour formater base non 2 numéros tous que vous devez faire est de changer le kilo à 1000. Il a également des courts-circuits si le nombre est sous 1k
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;
};
Les réponses m'a vraiment aidé, donc je décidé d'écrire une méthode utilitaire qui permet de résoudre ce problème de taille mise en forme une fois pour toutes.
Vérifiez mes JSutils repo wiki: https://bitbucket.org/AAverin/jsutils/ | https://github.com/AAverin/JSUtils Il a humanReadeableSize méthode qui utilise la manière de Amir d'arrondir la taille, mais supporte également la conversion entre la base habituelle de 2 (Kio, MiB) et la base de 10 numéros (Ko, Mo).
Il peut arrondir à la valeur la plus proche, mais aussi en rond dans le cas où vous voulez, par exemple, obtenir la quantité KB sont en PB.
Ne hésitez pas à le saisir et à utiliser dans vos projets!
On pourrait utiliser number_to_human_size (nombre, options = {})
number_to_human_size(1234567)
Exemples:
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
dans la documentation http: //api.rubyonrails .org / classes / ActionView / Helpers / NumberHelper.html # méthode i-number_to_human_size
