PHP Count round thousand to a K style count like facebook Share . . . Twitter Button ect

Ok so I am trying to turn my hit counter to round thousands to a single digit too display 3 thousand hits as 3K for example, like the Facebook Share and Twitter Tweet Buttons do. Here is my code. Any idea what I am doing wrong?

$postresultscount = (($resultscount) ? $resultscount->sumCount : 1);
$k = 1000;
$L = '';
if ($postresultscount > $k) {
    $echoxcount = round($postresultscount/$k);
    $L = 'K';
} else if ($postresultscount == $k) {
    $echoxcount = 1;
    $L = 'K';
} else {
    $echoxcount = $postr开发者_开发问答esultscount;
}

echo 'document.write("'.$echoxcount.' '.$L.'")';

Here comes a PHP function to format numbers to nearest thousands such as Kilos, Millions, Billions, and Trillions with comma

Function

function thousandsCurrencyFormat($num) {

  if($num>1000) {

        $x = round($num);
        $x_number_format = number_format($x);
        $x_array = explode(',', $x_number_format);
        $x_parts = array('k', 'm', 'b', 't');
        $x_count_parts = count($x_array) - 1;
        $x_display = $x;
        $x_display = $x_array[0] . ((int) $x_array[1][0] !== 0 ? '.' . $x_array[1][0] : '');
        $x_display .= $x_parts[$x_count_parts - 1];

        return $x_display;

  }

  return $num;
}

Output

thousandsCurrencyFormat(3000) - 3k
thousandsCurrencyFormat(35500) - 35.5k
thousandsCurrencyFormat(905000) - 905k
thousandsCurrencyFormat(5500000) - 5.5m
thousandsCurrencyFormat(88800000) - 88.8m
thousandsCurrencyFormat(745000000) - 745m
thousandsCurrencyFormat(2000000000) - 2b
thousandsCurrencyFormat(22200000000) - 22.2b
thousandsCurrencyFormat(1000000000000) - 1t (1 trillion)

Resources

https://code.recuweb.com/2018/php-format-numbers-to-nearest-thousands/

function shortNumber($num) 
{
    $units = ['', 'K', 'M', 'B', 'T'];
    for ($i = 0; $num >= 1000; $i++) {
        $num /= 1000;
    }
    return round($num, 1) . $units[$i];
}

I adapted this one from a function created to display bytes in human readable form by bashy here:

https://laracasts.com/discuss/channels/laravel/human-readable-file-size-and-time

a bit better than the post of Yuki

if ($value > 999 && $value <= 999999) {
    $result = floor($value / 1000) . ' K';
} elseif ($value > 999999) {
    $result = floor($value / 1000000) . ' M';
} else {
    $result = $value;
}

Question is 8 years old but each time I see an answer that contains an else statement, I think it can be done in a better (cleaner) way.

<?php

if (!function_exists('format_number_in_k_notation')) {
    function format_number_in_k_notation(int $number): string
    {
        $suffixByNumber = function () use ($number) {
            if ($number < 1000) {
                return sprintf('%d', $number);
            }

            if ($number < 1000000) {
                return sprintf('%d%s', floor($number / 1000), 'K+');
            }

            if ($number >= 1000000 && $number < 1000000000) {
                return sprintf('%d%s', floor($number / 1000000), 'M+');
            }

            if ($number >= 1000000000 && $number < 1000000000000) {
                return sprintf('%d%s', floor($number / 1000000000), 'B+');
            }

            return sprintf('%d%s', floor($number / 1000000000000), 'T+');
        };

        return $suffixByNumber();
    }
}

dump(format_number_in_k_notation(123)); // "123"
dump(format_number_in_k_notation(73000)); // "73K+"
dump(format_number_in_k_notation(216000)); // "216K+"
dump(format_number_in_k_notation(50400123)); // "50M+"
dump(format_number_in_k_notation(12213500100600)); // "12T+"

die;

function print_number_count($number) {
    $units = array( '', 'K', 'M', 'B');
    $power = $number > 0 ? floor(log($number, 1000)) : 0;
    if($power > 0)
        return @number_format($number / pow(1000, $power), 2, ',', ' ').' '.$units[$power];
    else
        return @number_format($number / pow(1000, $power), 0, '', '');
}

Use floor instead of round if you want 3500 to round down to 3 K.

Otherwise, your code works, albeit problematically. Try this:

if ($postresultscount > 1000) {
  $result = floor($postresultscount / 1000) . 'K';
} else {
  $result = $postresultscount;
}

echo 'document.write("' . $result . '")";

It also appears you're writing JavaScript using PHP—take care.

My func

function numsize($size,$round=2){
    $unit=['', 'K', 'M', 'G', 'T'];
    return round($size/pow(1000,($i=floor(log($size,1000)))),$round).$unit[$i];
}

This is a modified version with k and m lowercase and show one decimal place for milllions.

<?php

    if ($value > 999 && $value <= 999999) {
    $result  = floor($value / 1000) . 'k';
    } elseif ($value > 999999) {
    $result  = number_format((float)$value , 1, '.', '')/1000000 . 'm';
    } else {
    $result  = $value;
    }
?>

Several good answers have already been given to this particularly old question, however, most are too simple for my taste or not easy to extend for more units, so here's what I use:

# The function that returns a number formatted as a string in thousands, millions etc.
public static function getNumberAbbreviation (Int $number, Int $decimals = 1) : String {
    # Define the unit size and supported units.
    $unitSize = 1000;
    $units = ["", "K", "M", "B", "T"];

    # Calculate the number of units as the logarithm of the absolute value with the
    # unit size as base.
    $unitsCount = ($number === 0) ? 0 : floor(log(abs($number), $unitSize));

    # Decide the unit to be used based on the counter.
    $unit = $units[min($unitsCount, count($units) - 1)];

    # Divide the value by unit size in the power of the counter and round it to keep 
    # at most the given number of decimal digits.
    $value = round($number / pow($unitSize, $unitsCount), $decimals);

    # Assemble and return the string.
    return $value . $unit;
}

I created my own method inspired by Twitter.

Function:

function legibleNumb($numb, $lang = 'en') {
    if ($lang == 'tr') { // Usage with commas in Turkish
        if ($numb >= 1000000) { // Million
            if (strstr(round(number_format($numb,0,',','.'),1),'.')) {
                $legibleNumb = number_format(round(number_format($numb,0,',','.'),1),1,',','.') . ' Mn';
            } else {
                $legibleNumb = round(number_format($numb,0,',','.'),1) . ' Mn';
            }
        } elseif ($numb >= 100000 && $numb < 1000000) { // One hundred thousand
            $legibleNumb = round(number_format($numb,0,',','.'),0) . ' B';
        } elseif ($numb >= 10000 && $numb < 100000) { // Ten thousand
            if (strstr(round(number_format($numb,0,',','.'),1),'.')) {
                $legibleNumb = number_format(round(number_format($numb,0,',','.'),1),1,',','.') . ' B';
            } else {
                $legibleNumb = round(number_format($numb,0,',','.'),1) . ' B';
            }
        } else {
            $legibleNumb = number_format($numb,0,',','.');
        }
    } else { // Dotted usage in English
        if ($numb >= 1000000) { // Million
            $legibleNumb = round(number_format($numb,0,',','.'),1) . ' M';
        } elseif ($numb >= 100000 && $numb < 1000000) { // One hundred thousand
            $legibleNumb = round(number_format($numb,0,',','.'),0) . ' K';
        } elseif ($numb >= 10000 && $numb < 100000) { // Ten thousand
            $legibleNumb = round(number_format($numb,0,',','.'),1) . ' K';
        } else {
            $legibleNumb = number_format($numb,0,',','.');
        }
    }
    return $legibleNumb;
}

Usage:

echo legibleNumb(9999999,'en');
echo legibleNumb(9999999,'tr');

echo legibleNumb(54669,'en');
echo legibleNumb(54669,'tr');

echo legibleNumb(5466,'en');
echo legibleNumb(5466,'tr');

Results:

10 M
10 Mn

54.7 K
54,7 B

5.466
5.466

You can try it here and check out sample usages: https://glot.io/snippets/eljyd9ssjx

if ($postresultscount > 999999) {
    $postresultscount = floor($postresultscount / 1000000) . ' M';
}
elseif ($postresultscount > 999) {
    $postresultscount = floor($postresultscount / 1000) . ' K';
}
echo $postresultscount;

This questuion have the same goal as this question in here Shorten long numbers to K/M/B?

Reference: https://gist.github.com/RadGH/84edff0cc81e6326029c

Try this code:

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

The code above create a function to convert the numbers. To use this function later just call it like in the code below:

// Example Usage:
number_format_short(7201); // Output: 7.2k

Rounding up, not accounting for any abbreviations above 'k' or thousands, showing one decimal place.

function numToKs($number) {
    if ($number >= 1000) {
        return number_format(($number / 1000), 1) . 'k';
    } else {
        return $number;
    }
}

numToKs(1)          = 1
numToKs(111)        = 111
numToKs(999)        = 999
numToKs(1000)       = "1.0k"
numToKs(1499)       = "1.5k"
numToKs(1500)       = "1.5k"
numToKs(1501)       = "1.5k"
numToKs(1550)       = "1.6k"
numToKs(11501)      = "11.5k"
numToKs(1000000000) = "1,000,000.0k"
numToKs(1234567890) = "1,234,567.9k"