Einen Integer auf Zehner, Hunderter oder Tausender runden (Thema: PHP Beispiele)

1. Einleitung

PHP stellt zum Runden von Zahlen die Funktionen round($number, $precision, $mode), ceil($number) und floor($number) zur Verfügung. Erste führt „normales” Runden durch, letztere runden immer auf (ceil) bzw. ab (floor). Typischerweise werden diese Funktionen auf Floats mit Nachkommastellen angewendet, um diese zu glatten Zahlen umzuwandeln. Es ist aber auch möglich, sie für Vorkommastellen zu verwenden. Mit dem Parameter $precision ist round() bereits darauf ausgelegt, auf eine bestimmte Anzahl von Stellen zu runden. Die Funktion kann daher zum Runden auf Zehner, Hunderter oder Tausender genutzt werden, indem für $precision ein negativer Wert übergeben wird (etwa -1 zum Runden auf die nächste Zehnerpotenz). ceil() und floor() verfügen nicht über einen derartigen Parameter. Daher muss zunächst durch die gewünschte Zehnerpotenz geteilt werden (etwa Teilung durch 100 für das Runden auf Hunderter), anschließend ceil()/floor() angewendet und zuletzt wieder mit der gewünschten Zehnerpotenz multipliziert werden.

Beim Abrunden auf das nächste Vielfache von 102 (Abrunden auf Hunderter) würde also wie folgt vorgegangen werden:

• Zahl definieren, etwa $n = 12345.
• Zahl durch 100 teilen, etwa $n = $n / 100; (ergäbe hier 123,45).
• Zahl abrunden, etwa $n = floor($n); (ergäbe hier 123).
• Zahl mit 100 multiplizieren, etwa $n = $n * 100; (ergäbe hier 12300).

2. Beispiel: Auf Zehner runden

In diesem Beispiel wird auf Zehner (Vielfache von 101) gerundet, sodass die letzte Ziffer der Zahl immer eine Null ist. Es werden sowohl round() als auch ceil() und floor() verwendet. Bei round() wird unterschieden zwischen auf- und abrunden falls die Zahl auf der Ziffer 5 endet. Wie zuvor beschrieben wird bei ceil() und floor() jeweils ein Mal durch Zehn dividiert und danach wieder mit Zehn multipliziert.

<?php
	$number = 1666777888;

	// normales Runden und 0.5 wird zu 1
	var_dump(round($number, -1, PHP_ROUND_HALF_UP)); // 1666777890
	
	// normales Runden und 0.5 wird zu 0
	var_dump(round($number, -1, PHP_ROUND_HALF_DOWN)); // 1666777890

	// immer aufrunden
	var_dump(ceil($number/pow(10, 1)) * pow(10, 1)); // 1666777890

	// immer abrunden
	var_dump(floor($number/pow(10, 1)) * pow(10, 1)); // 1666777880
?>

float(1666777890)
float(1666777890)
float(1666777890)
float(1666777880)

3. Beispiel: Auf Hunderter runden

In diesem Beispiel wird auf Zehner (Vielfache von 102) gerundet, sodass die letzten beiden Ziffern der Zahl immer jeweils Null sind. Das Vorgehen ist identisch zu dem Vorherigem (siehe „Beispiel: Auf Zehner runden”).

<?php
	$number = 1666777888;

	// normales Runden und 0.5 wird zu 1
	var_dump(round($number, -2, PHP_ROUND_HALF_UP)); // 1666777900
	
	// normales Runden und 0.5 wird zu 0
	var_dump(round($number, -2, PHP_ROUND_HALF_DOWN)); // 1666777900

	// immer aufrunden
	var_dump(ceil($number/pow(10, 2)) * pow(10, 2)); // 1666777900

	// immer abrunden
	var_dump(floor($number/pow(10, 2)) * pow(10, 2)); // 1666777800
?>

float(1666777900)
float(1666777900)
float(1666777900)
float(1666777800)

4. Beispiel: Auf Tausender runden

In diesem Beispiel wird auf Hunderter (Vielfache von 103) gerundet, sodass die letzten drei Ziffern der Zahl immer jeweils Null sind. Das Vorgehen ist identisch zu dem Vorherigem (siehe „Beispiel: Auf Zehner runden”).

<?php
	$number = 1666777888;

	// normales Runden und 0.5 wird zu 1
	var_dump(round($number, -3, PHP_ROUND_HALF_UP)); // 1666778000
	
	// normales Runden und 0.5 wird zu 0
	var_dump(round($number, -3, PHP_ROUND_HALF_DOWN)); // 1666778000

	// immer aufrunden
	var_dump(ceil($number/pow(10, 3)) * pow(10, 3)); // 1666778000

	// immer abrunden
	var_dump(floor($number/pow(10, 3)) * pow(10, 3)); // 1666777000
?>

float(1666778000)
float(1666778000)
float(1666778000)
float(1666777000)

5. Verallgemeinerung für ceil() und floor()

Während round() bereits hinreichend verallgemeinert ist (man muss nur einen negativen Wert für $precision übergeben), ist dies bei ceil() und floor() noch nicht der Fall. Beide erfordern zum Runden auf Zehnerpotenzen störende eigene Berechnungen. Daher werden nun zwei Funktionen definiert, die einem diese Berechnungen abnehmen und — ähnlich wie round() — einen $precision-Parameter erwarten. Im Gegensatz zu round() sind diese Funktionen aber auf das Runden von Zehnerpotenzen ausgelegt und erwarten daher positive Werte für $precision. $precision=3 entspricht demnach dem Runden auf 104 (nächstes Vielfaches von 1000).

<?php
	// floor() mit $precision
	function floorIntegerPart($number, $precision) {
		return floor($number/pow(10, $precision)) * pow(10, $precision);
	}	

	// ceil mit $precision
	function ceilIntegerPart($number, $precision) {
		return ceil($number/pow(10, $precision)) * pow(10, $precision);
	}

	$number = 1666777888;

	var_dump(floorIntegerPart($number, 1)); // 1666777880
	var_dump(floorIntegerPart($number, 2)); // 1666777800
	var_dump(floorIntegerPart($number, 3)); // 1666777000
	var_dump(floorIntegerPart($number, 4)); // 1666770000

	var_dump(ceilIntegerPart($number, 1)); // 1666777890
	var_dump(ceilIntegerPart($number, 2)); // 1666777900
	var_dump(ceilIntegerPart($number, 3)); // 1666778000
	var_dump(ceilIntegerPart($number, 4)); // 1666780000
?>

float(1666777880)
float(1666777800)
float(1666777000)
float(1666770000)
float(1666777890)
float(1666777900)
float(1666778000)
float(1666780000)