Supprimer les chiffres après la deuxième décimale, sans arrondir la valeur

TL;DR:

La fonction native de PHP bcdiv semble faire précisément ce qui est nécessaire, et correctement.

Simplement "tronquer" un certain nombre, bcdiv($var, 1, 2); où 2 est le nombre de décimales à préserver (et 1 est la denomenator - diviser le nombre par 1 vous permet de simplement couper l'origine nombre souhaité de décimales)

Réponse complète (pour l'histoire)

Cela s'avère plus difficile qu'on pourrait le penser.

Après cette réponse a été (à tort) upvoted un peu, il est venu à mon attention que même sprintf rond.

Plutôt que de supprimer cette réponse, je suis en le transformant en un plus robuste explication /discussion de chaque solution proposée.

number_format - Incorrect. (tours)

Essayez d'utiliser format de nombre:

$var = number_format($var, 2, '.', '');  //Last two parameters are optional
echo $var;
//Outputs 2.50

Si vous voulez qu'il soit un nombre, puis tapez simplement en fonte pour un float:

$var = (float)number_format($var, 2, '.', '');

Remarque: comme cela a été souligné dans les commentaires, cela n'en fait ronde le nombre.

sprintf - incorrect. (sprintf aussi des tours)

Si pas en arrondissant ce nombre est important, puis par la réponse ci-dessous, utilisez sprintf:

$var = sprintf("%01.2f", $var);

étage - pas tout à fait! (étage des tours des nombres négatifs)

étage, avec quelques calculs, viendra près de faire ce que vous voulez:

floor(2.56789 * 100) / 100; //2.56

Où 100 représente la précision que vous voulez. Si vous le voulais à trois chiffres, puis:

floor(2.56789 * 1000) / 1000; //2.567

Cependant, cela a un problème avec les nombres négatifs. Les nombres négatifs toujours obtenir arrondie, plutôt que tronquée:

floor(-2.56789 * 100) / 100; //-2.57

"Vieux" réponse Correcte: la fonction en utilisant étage

Donc pleinement solution robuste nécessite une fonction:

function truncate_number( $number, $precision = 2) {
    //Zero causes issues, and no need to truncate
    if ( 0 == (int)$number ) {
        return $number;
    }
    //Are we negative?
    $negative = $number / abs($number);
    //Cast the number to a positive to solve rounding
    $number = abs($number);
    //Calculate precision number for dividing /multiplying
    $precision = pow(10, $precision);
    //Run the math, re-applying the negative value to ensure returns correctly negative /positive
    return floor( $number * $precision ) / $precision * $negative;
}

Les résultats de la fonction ci-dessus:

echo truncate_number(2.56789, 1); //2.5
echo truncate_number(2.56789);    //2.56
echo truncate_number(2.56789, 3); //2.567

echo truncate_number(-2.56789, 1); //-2.5
echo truncate_number(-2.56789);    //-2.56
echo truncate_number(-2.56789, 3); //-2.567

Nouvelle Réponse Correcte

Utiliser la fonction native de PHP bcdiv

echo bcdiv(2.56789, 1, 1);  //2.5
echo bcdiv(2.56789, 1, 2);  //2.56
echo bcdiv(2.56789, 1, 3);  //2.567
echo bcdiv(-2.56789, 1, 1); //-2.5
echo bcdiv(-2.56789, 1, 2); //-2.56
echo bcdiv(-2.56789, 1, 3); //-2.567

Vous demandez une fonction qui renvoie "2.50" et pas 2.5, donc vous ne parlons pas de l'arithmétique ici, mais de manipulation de chaîne. Puis preg_replace est votre ami:

$truncatedVar = preg_replace('/\.(\d{2}).*/', '.$1', $var);

//"2.500000050" -> "2.50", "2.509" -> "2.50", "-2.509" -> "2.50", "2.5" -> "2.5"

Si vous voulez le faire avec l'arithmétique, il suffit d'utiliser:

$truncatedVar = round($var * 100) / 100);

//"2.500000050" -> "2.5", "2.599" -> "2.59", "-2.599" -> "2.59"

utilisation sprintf

sprintf("%01.2f", $var);

quelqu'un a posté ici sur

étage(2.500000550 * 100) /100;

function cutAfterDot($number, $afterDot = 2){
$a = $number * pow(10, $afterDot);
$b = floor($a);
$c = pow(10, $afterDot);
echo "a $a, b $b, c $c<br/>";
return $b/$c ;
}
echo cutAfterDot(2.05,2);

a 205, b 204, c 100
2.04

donc dans leur forme brute, ne pas l'utiliser...
Mais si vous ajoutez un peu d'epsilon...

function cutAfterDot($number, $afterDot = 2){
        return floor($number * pow(10, $afterDot) + 0.00001) / pow(10, $afterDot);
    }

ça marche!!!

Toutes les solutions qui utilisent le number_format sont mauvais parce que number_format effectue l'arrondissement.

La fonction ci-dessous devrait fonctionner sur tous les numéros, vous pouvez spécifier le séparateur décimal pour les pays qui utilisent des ','.

function truncate_decimal($number, $truncate_decimal_length = 2, $decimal_character = '.', $thousands_character = '') {

$number = explode($decimal_character, $number);
$number[1] = substr($number[1], 0, $truncate_decimal_length);
$number_truncated = implode($decimal_character, $number);
return number_format($number_truncated, $truncate_decimal_length, $decimal_character, $thousands_character);

}

Une fonction simple à suivre serait "Si elle est supérieure à 0 étage, d'autre ceil", à l'aide d'un multiplicateur pour l'élever au-dessus du point décimal temporairement alors que faire:

function trim_num($num_in, $dec_places = 2) {
    $multiplier = pow(10, $dec_places); //10, 100, 1000, etc
    if ($num_in > 0) {
        $num_out = floor($num_in * $multiplier) / $multiplier;
    } else {
        $num_out = ceil($num_in * $multiplier) / $multiplier;
    }
    return $num_out;
}

étage - pas tout à fait! (étage des tours des nombres négatifs)

Une solution possible à partir de cale_b réponse.

static public function rateFloor($rate, $decimals)
{

    $div = "1" . str_repeat("0", $decimals);

    if ($rate > 0) {
        return floor($rate * $div) / $div;
    }

    $return = floor(abs($rate) * $div) / $div;

    return -($return);

}

---

static public function rateCeil($rate, $decimals)
{

    $div = "1" . str_repeat("0", $decimals);

    if ($rate > 0) {
        return ceil($rate * $div) / $div;
    }

    $return = ceil(abs($rate) * $div) / $div;

    return -($return);

}

Positif

Taux: 0.00302471

Étage: 0.00302400

Ceil: 0.00302500

Négatif

Taux: -0.00302471

Étage: -0.00302400

Ceil: -0.00302500