Je l'ai googlé beaucoup, mais je ne trouve pas de fonctions utiles en fonction de mes questions.Raccourcir les nombres longs en K/M/B?
Ce que je veux est:
100 -> 100
1000 -> 1,000
142840 -> 142,840
MAIS
2023150 -> 2.023M (i still want 3 additional numbers for more accuracy)
5430120215 -> 5.430B
je serais tout à fait apprécier toutes les fonctions personnalisées de choisir dynamiquement la limite si possible.
Merci!
Utilisation number_format():
if ($n < 1000000) {
// Anything less than a million
$n_format = number_format($n);
} else if ($n < 1000000000) {
// Anything less than a billion
$n_format = number_format($n/1000000, 3) . 'M';
} else {
// At least a billion
$n_format = number_format($n/1000000000, 3) . 'B';
}
Je totalement apprécier toutes les fonctions personnalisées de choisir dynamiquement la limite si possible.
Si "limite" fait référence au nombre de décimales (la précision), c'est facile:
function custom_number_format($n, $precision = 3) {
if ($n < 1000000) {
// Anything less than a million
$n_format = number_format($n);
} else if ($n < 1000000000) {
// Anything less than a billion
$n_format = number_format($n/1000000, $precision) . 'M';
} else {
// At least a billion
$n_format = number_format($n/1000000000, $precision) . 'B';
}
return $n_format;
}
CakePHP a une Number Helper avec une méthode toReadableSize. Vous devriez être capable de le faire et de trouver quelque chose par vous-même. Dans celui-ci, $this->precision est fondamentalement comme number_format(), et __n est une fonction singulière ou plurielle.
J'ai pris la réponse BoltClock fournie et l'ai un peu ajusté avec la facilité de la configuration à l'esprit.
// Shortens a number and attaches K, M, B, etc. accordingly
function number_shorten($number, $precision = 3, $divisors = null) {
// Setup default $divisors if not provided
if (!isset($divisors)) {
$divisors = array(
pow(1000, 0) => '', // 1000^0 == 1
pow(1000, 1) => 'K', // Thousand
pow(1000, 2) => 'M', // Million
pow(1000, 3) => 'B', // Billion
pow(1000, 4) => 'T', // Trillion
pow(1000, 5) => 'Qa', // Quadrillion
pow(1000, 6) => 'Qi', // Quintillion
);
}
// Loop through each $divisor and find the
// lowest amount that matches
foreach ($divisors as $divisor => $shorthand) {
if (abs($number) < ($divisor * 1000)) {
// We found a match!
break;
}
}
// We found our match, or there were no matches.
// Either way, use the last defined value for $divisor.
return number_format($number/$divisor, $precision) . $shorthand;
}
Belle réponse Kyle. Quelques remarques cependant: Vous devriez utiliser 'if (abs ($ number) <($ divisor * 1000)) {', sinon les nombres négatifs ne seront jamais raccourcis. En outre, il peut être judicieux d'instancier '$ divisor' et' $ shortand', juste pour s'assurer qu'il n'y a pas d'exception quand un utilisateur peut passer un '$ divisors' vide. Merci! –
Lazily 'return 0 + number_format ($ nombre/$ diviseur, $ precision). $ shorthand; 'éliminer les zéros insignifiants (dont je n'avais pas besoin dans mon cas). – Redhart
<?php
// Converts a number into a short version, eg: 1000 -> 1k
// Based on: http://stackoverflow.com/a/4371114
function number_format_short($n, $precision = 1) {
if ($n < 900) {
// 0 - 900
$n_format = number_format($n, $precision);
$suffix = '';
} else if ($n < 900000) {
// 0.9k-850k
$n_format = number_format($n/1000, $precision);
$suffix = 'K';
} else if ($n < 900000000) {
// 0.9m-850m
$n_format = number_format($n/1000000, $precision);
$suffix = 'M';
} else if ($n < 900000000000) {
// 0.9b-850b
$n_format = number_format($n/1000000000, $precision);
$suffix = 'B';
} else {
// 0.9t+
$n_format = number_format($n/1000000000000, $precision);
$suffix = 'T';
}
// Remove unecessary zeroes after decimal. "1.0" -> "1"; "1.00" -> "1"
// Intentionally does not affect partials, eg "1.50" -> "1.50"
if ($precision > 0) {
$dotzero = '.' . str_repeat('0', $precision);
$n_format = str_replace($dotzero, '', $n_format);
}
return $n_format . $suffix;
}
/*
Example Usage:
number_format_short(7201); // Output: 7.2k
Demo:
echo '<table>';
for($d = 0; $d < 16; $d++) {
$n = intval("09" . str_repeat("0", $d));
$n = $n/10;
echo number_format_short($n) .'<br>'; // 0.9
$n = intval("1" . str_repeat("0", $d));
echo number_format_short($n) .'<br>'; // 1.0
$n = intval("11" . str_repeat("0", $d));;
$n = $n/10;
echo number_format_short($n) .'<br>'; // 1.1
}
echo '</table>';
Demo Output:
0.9
1
1.1
9
10
11
90
100
110
0.9K
1K
1.1K
9K
10K
11K
90K
100K
110K
0.9M
1M
1.1M
9M
10M
11M
90M
100M
110M
0.9B
1B
1.1B
9B
10B
11B
90B
100B
110B
0.9T
1T
1.1T
9T
10T
11T
90T
100T
110T
900T
1,000T
1,100T
*/
Vous pouvez essayer cette
function number_formation($number, $precision = 3) {
if ($number < 1000000) {
$formatted_number = number_format($number); /* less than a million */
} else if ($number < 1000000000) {
$formatted_number = number_format($number/1000000, $precision) . 'M'; /* billion */
} else {
$formatted_number = number_format($number/1000000000, $precision) . 'B'; /* for billion */
}
return $formatted_number;
}
Essayez cette
function custom_number_format($n, $precision = 1) {
if ($n < 900) {
// Default
$n_format = number_format($n);
} else if ($n < 900000) {
// Thausand
$n_format = number_format($n/1000, $precision). 'K';
} else if ($n < 900000000) {
// Million
$n_format = number_format($n/1000000, $precision). 'M';
} else if ($n < 900000000000) {
// Billion
$n_format = number_format($n/1000000000, $precision). 'B';
} else {
// Trillion
$n_format = number_format($n/1000000000000, $precision). 'T';
}
return $n_format;
}
function number_abbr($number)
{
$abbrevs = [12 => 'T', 9 => 'B', 6 => 'M', 3 => 'K', 0 => ''];
foreach ($abbrevs as $exponent => $abbrev) {
if (abs($number) >= pow(10, $exponent)) {
$display = $number/pow(10, $exponent);
$decimals = ($exponent >= 3 && round($display) < 100) ? 1 : 0;
$number = number_format($display, $decimals).$abbrev;
break;
}
}
return $number;
}
Works pour points positifs et négatifs.
Choisir quelle limite? – BoltClock
ne veux-tu pas dire "K/M/G" pour "Kilo/Méga/Giga", pas "Mille/Million/Milliard"? – zzzzBov