Php 是否将长数字缩短为K/M/B？

我在谷歌上搜索了很多，但根据我的查询，我找不到任何有用的函数

我想要的是：

100 -> 100
1000 -> 1,000
142840 -> 142,840

但是

如果可能的话，我非常感谢任何自定义函数动态选择限制

谢谢

使用

数字格式（）

：

if（$n<1000000）{
//少于一百万的
$n\u格式=数字\u格式（$n）；
}否则，如果（$n<100000000）{
//任何少于十亿的东西
$n_格式=数字_格式（$n/1000000，3）。'M'；
}否则{
//至少10亿
$n_格式=数字_格式（$n/100000000，3）。'B'；
}

如果可能的话，我非常感谢任何自定义函数动态选择限制

如果“limit”指的是小数位数（精度），那么很简单：

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;
}

函数自定义编号格式（$n，$precision=3）{
如果（$n<1000000）{
//少于一百万的
$n\u格式=数字\u格式（$n）；
}否则，如果（$n<100000000）{
//任何少于十亿的东西
$n_格式=数字_格式（$n/1000000，$precision）。'M'；
}否则{
//至少10亿
$n_格式=数字_格式（$n/100000000，$precision）。'B'；
}
返回$n_格式；
}

CakePHP有一个带有方法的。你应该能够自己摸索并想出一些办法。在它里面，

$this->precision

基本上类似于

number\u format（）

，而

\u n

是一个单数或复数函数。

我接受了提供的答案，并考虑到配置的方便，对它进行了一些调整

// 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;
}

//缩短数字并相应地附加K、M、B等
函数编号\u缩短（$number，$precision=3，$divisions=null）{
//设置默认的$除数（如果未提供）
if（！isset（$除数））{
$除数=数组(
功率（1000，0）=>1，//1000^0==1
功率（1000，1）=>K'，//千
功率（1000，2）=>M'，//百万
功率（1000，3）=>B'，//十亿
功率（1000，4）=>‘T’，//万亿
功率（1000，5）=>‘Qa’，//万亿
战力（1000，6）=>‘气’，//五百万
);    
}
//循环遍历每个$除数并找到
//匹配的最低金额
foreach（$除数为$除数=>$速记）{
if（绝对值（$数字）<（$除数*1000））{
//我们找到了一根火柴！
打破
}
}
//我们找到了匹配项，或者没有匹配项。
//无论哪种方式，都使用上次定义的$divisor值。
返回数字格式（$number/$divisior，$precision）。$shorthand；
}

你可以试试这个

 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;
    }

函数编号\u格式（$number，$precision=3）{
如果（$number<1000000）{
$formatted_number=number_format（$number）；/*少于一百万*/
}否则，如果（$number<100000000）{
$formatted_number=number_format（$number/1000000，$precision）。'M'；/*十亿*/
}否则{
$formatted_number=number_格式（$number/100000000，$precision）。'B'；/*表示十亿*/
}
返回$U编号；
}
试试这个

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;
    }

函数自定义编号格式（$n，$precision=1）{
如果（$n<900）{
//违约
$n\u格式=数字\u格式（$n）；
}否则，如果（$n<900000）{
//泰山
$n_格式=数字_格式（$n/1000，$precision）。'K'；
}否则，如果（$n<900000000）{
//百万
$n_格式=数字_格式（$n/1000000，$precision）。'M'；
}其他如果（$n<90000000000）{
//十亿
$n_格式=数字_格式（$n/100000000，$precision）。'B'；
}否则{
//万亿
$n_格式=数字_格式（$n/10000000000，$precision）。'T'；
}
返回$n_格式；
}
功能编号\u缩写（$number）
{
$abbrevs=[12=>'T'，9=>'B'，6=>'M'，3=>'K'，0=>''；
foreach（$abbrevs作为$exponent=>$abbrev）{
如果（abs（$number）>=pow（10，$index））{
$display=$number/pow（10，$index）；
$decimals=（$index>=3&&round（$display）<100）？1:0；
$number=数字\格式（$display，$decimals）。$abbrev；
打破
}
}
返回$number；
}

适用于积极和消极方面。
虽然这个问题很久以前被问到，但我有一个不同的解决方案，我认为更简单：

function shorten($number){
    $suffix = ["", "K", "M", "B"];
    $precision = 1;
    for($i = 0; $i < count($suffix); $i++){
        $divide = $number / pow(1000, $i);
        if($divide < 1000){
            return round($divide, $precision).$suffix[$i];
            break;
        }
    }
}
echo shorten(1000);

函数缩短（$number）{
$suffix=[“”，“K”，“M”，“B”]；
$precision=1；
对于（$i=0；$i

我希望它对某些人仍然有帮助。
试试这个。解释了k、M、B、T和Q（万亿次方）群。任何高于999Q的值都显示为999Q+

function number(float $num, int $precision = 2): string
{
    $absNum = abs($num);

    if ($absNum < 1000)
    {
        return (string)round($num, $precision);
    }

    $groups = ['k','M','B','T','Q'];

    foreach ($groups as $i => $group)
    {
        $div = 1000 ** ($i + 1);

        if ($absNum < $div * 1000)
        {
            return round($num / $div, $precision) . $group;
        }
    }

    return '999Q+';
}

函数编号（float$num，int$precision=2）：字符串
{
$absNum=abs（$num）；
如果（$absNum<1000）
{
返回（字符串）四舍五入（$num，$precision）；
}
$groups=['k'，'M'，'B'，'T'，'Q']；
foreach（$i=>$group的组）
{
$div=1000**（$i+1）；
如果（$absNum<$div*1000）
{
返回轮（$num/$div，$precision）。$group；
}
}
返回'999Q+'；
}
基于之前的解决方案，我采取了不同的方法。基本上，它使用
log（）
函数来摆脱
for
语句：

函数编号\u缩短（$number，$precision=3）
{
$suffix=['''K'，'M'，'B'，'T'，'Qa'，'Qi']；
$index=（int）log（abs（$number），1000）；
$index=max（0，min（count（$后缀）-1，$index））；//钳制到有效后缀的索引
返回数字格式（$number/1000**$index，$precision）。$后缀[$index]；
}

它适用于正数和负数。
你是说“K/M/G”代表的是
Kilo/Meg吗
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;
}

function shorten($number){
    $suffix = ["", "K", "M", "B"];
    $precision = 1;
    for($i = 0; $i < count($suffix); $i++){
        $divide = $number / pow(1000, $i);
        if($divide < 1000){
            return round($divide, $precision).$suffix[$i];
            break;
        }
    }
}
echo shorten(1000);

function number(float $num, int $precision = 2): string
{
    $absNum = abs($num);

    if ($absNum < 1000)
    {
        return (string)round($num, $precision);
    }

    $groups = ['k','M','B','T','Q'];

    foreach ($groups as $i => $group)
    {
        $div = 1000 ** ($i + 1);

        if ($absNum < $div * 1000)
        {
            return round($num / $div, $precision) . $group;
        }
    }

    return '999Q+';
}