Mit log() bietet PHP eine zentrale Funktion zur Berechnung des Logarithmus einer Zahl. In diesem Artikel lernst du, wie du log() richtig und effizient in deinen Projekten einsetzt. Du erhältst fundiertes Hintergrundwissen und praktische Beispiele für typische Anwendungsfälle.
1. Einleitung: Was ist die PHP log() Funktion?
Mit log() berechnest du in PHP den Logarithmus einer Zahl. Ohne weitere Angabe liefert die Funktion den natürlichen Logarithmus zur Basis e (etwa 2.71828). Gerade wenn du Vorgänge wie exponentielles Wachstum oder Zerfall programmierst, sind Logarithmen ein unverzichtbares Werkzeug.
2. Grundlagen des Logarithmus (Kurz und Verständlich)
Bevor du log() gezielt einsetzt, solltest du das mathematische Konzept des Logarithmus verstehen.
Ein Logarithmus ist die Umkehrung einer Potenzfunktion. Wenn gilt b^x = y, dann ist log_b(y) = x. Der Logarithmus beantwortet die Frage: Mit welchem Exponenten muss ich die Basis potenzieren, um einen bestimmten Wert zu erhalten?
Der natürliche Logarithmus nutzt als Basis die Eulersche Zahl e (etwa 2.71828). Diese Zahl spielt in vielen mathematischen und naturwissenschaftlichen Bereichen eine zentrale Rolle. Deshalb ist sie auch die Standardbasis bei log() in PHP.
Der dekadische Logarithmus arbeitet mit der Basis 10. Er wird in vielen technischen und wissenschaftlichen Bereichen verwendet.
Mit log() kannst du auch andere Basen angeben. So berechnest du beliebige Logarithmen.
3. Syntax der PHP log() Funktion
Die genaue Syntax und die Bedeutung der Parameter sind entscheidend für den korrekten Einsatz der Funktion.
float log(float $fZahl, ?float $fBasis = M_E)
| Parameter | Beschreibung |
| $fZahl | Die Zahl, deren Logarithmus berechnet werden soll (Pflichtparameter) |
| $fBasis | (Optional) Die Basis für den Logarithmus. Standardwert ist die Eulersche Zahl (M_E) |
| Rückgabewert | float, also der Logarithmus von $fZahl zur angegebenen Basis |
Wenn du keine Basis angibst, verwendet PHP automatisch e. Du kannst aber auch jede positive Basis größer als 0 und ungleich 1 angeben.
4. Verwendung der log() Funktion: Praktische Beispiele
Die folgenden Beispiele zeigen verschiedene typische Einsatzmöglichkeiten.
4.1. Den natürlichen Logarithmus berechnen (Standardverhalten)
Rufst du log() ohne zweite Angabe auf, berechnet PHP den natürlichen Logarithmus.
$fErgebnis = log(10);
echo $fErgebnis;
/**
* Gibt ungefähr 2.302585092994 zurück.
* Das bedeutet: e hoch 2.30 ergibt etwa 10.
*/
Die Funktion exp() ist die Umkehrung zu log():
$fWert = exp(log(10));
echo $fWert;
/**
* Gibt wieder 10 zurück.
*/
4.2. Logarithmus zu einer spezifischen Basis berechnen
Mit Angabe des zweiten Parameters nutzt du eine andere Basis.
$fErgebnis = log(100, 10);
echo $fErgebnis;
/**
* Gibt 2 zurück, denn 10^2 = 100.
*/
$fErgebnis = log(8, 2);
echo $fErgebnis;
/**
* Gibt 3 zurück, denn 2^3 = 8.
*/
Auch ungewöhnliche Basen wie 1.5 oder 7 sind möglich, solange die Basis größer als 0 und nicht 1 ist.
4.3. Typische Anwendungsfälle in der PHP-Programmierung
Logarithmen begegnen dir in der PHP-Entwicklung häufiger, als du vielleicht denkst. Die folgenden Beispiele zeigen konkrete Anwendungsfälle mit Code.
4.3.1 Dateigrößen in lesbare Einheiten umrechnen
Wenn du Datei- oder Speichergrößen anzeigst, brauchst du eine Umrechnung von Bytes in KB, MB oder GB. Mit log() bestimmst du die passende Einheit automatisch:
<?php
function formatBytes(int $iBytes): string
{
if ($iBytes === 0) {
return '0 Bytes';
}
$aEinheiten = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
$iIndex = (int) floor(log($iBytes, 1024));
return round($iBytes / pow(1024, $iIndex), 2)
. ' ' . $aEinheiten[$iIndex];
}
echo formatBytes(0); // 0 Bytes
echo formatBytes(1024); // 1 KB
echo formatBytes(1048576); // 1 MB
echo formatBytes(1073741824); // 1 GB
?>
Die Funktion berechnet per floor(log($iBytes, 1024)) den Index der richtigen Einheit. Bei 1.048.576 Bytes ergibt log(1048576, 1024) genau 2, also wird "MB" gewählt.
4.3.2 Logarithmische Skalierung für Diagramme
Wenn deine Datenpunkte stark schwanken (zum Beispiel Besucherzahlen von 10 bis 1.000.000), hilft eine logarithmische Skalierung. So werden kleine und große Werte gleichzeitig lesbar:
<?php
$aBesucher = [15, 230, 4500, 89000, 1200000];
foreach ($aBesucher as $iAnzahl) {
$fSkaliert = log($iAnzahl + 1);
$iBalken = (int) round($fSkaliert * 5);
echo str_pad($iAnzahl, 10)
. str_repeat('#', $iBalken)
. "\n";
}
/*
* Ausgabe (gekürzt):
* 15 ##############
* 230 ###########################
* 1200000 ##############################################
*/
?>
Durch log($iAnzahl + 1) werden die Unterschiede zwischen kleinen und großen Werten geglättet. Das "+1" verhindert log(0), das -INF zurückgeben würde.
5. Fehlerbehandlung und Randfälle
log() gibt bei Grenzfällen spezielle Werte zurück, die du beachten solltest.
5.1. Logarithmus von 0 (log(0))
$fErgebnis = log(0);
/**
* $fErgebnis ist -INF (minus unendlich)
* Mathematisch strebt der Logarithmus von 0 gegen minus unendlich
*/
5.2. Logarithmus von negativen Zahlen (log(-x))
$fErgebnis = log(-1);
/**
* $fErgebnis ist NAN (Not A Number)
* Für negative Zahlen ist der Logarithmus im Bereich der reellen Zahlen nicht definiert
*/
5.3. Ungültige Basen (z.B. base <= 0 oder base = 1)
$fErgebnis = log(100, -2);
/**
* $fErgebnis ist NAN, weil die Basis negativ ist
*/
$fErgebnis = log(100, 1);
/**
* $fErgebnis ist NAN, da die Basis 1 mathematisch nicht zulässig ist
*/
Die Basis muss größer als 0 und verschieden von 1 sein. Bei ungültigen Werten gibt PHP eine Warnung aus und liefert NAN.
5.4. Prüfung auf NAN und INF für robuste Anwendungen
Prüfe Ergebnisse von log() immer auf INF oder NAN, bevor du weiterrechnest.
if (is_nan($fErgebnis) || is_infinite($fErgebnis)) {
/** Hier solltest du eine Fehlerbehandlung einbauen */
}
5.5. Gleitkomma-Präzision bei Vergleichen
Da log() Gleitkommazahlen zurückgibt, solltest du Ergebnisse nie direkt mit == vergleichen. Rundungsfehler können dazu führen, dass zwei mathematisch gleiche Werte in PHP unterschiedlich sind:
<?php
$fErgebnis = log(1000, 10);
/* Falsch: kann fehlschlagen */
if ($fErgebnis == 3) {
echo 'Exakt 3';
}
/* Richtig: Toleranz verwenden */
if (abs($fErgebnis - 3) < PHP_FLOAT_EPSILON) {
echo 'Nahe genug an 3';
}
?>
Verwende für solche Vergleiche immer eine kleine Toleranz wie PHP_FLOAT_EPSILON oder einen Schwellenwert wie 1e-10.
6. Abgrenzung und Verwandte Mathematische Funktionen
Je nach Anforderung stehen dir verschiedene verwandte Funktionen zur Verfügung. Die folgende Tabelle gibt dir eine schnelle Übersicht:
| Funktion | Basis | Typischer Einsatz | Beispiel |
log($x) | e (2.71828) | Wachstum, Zerfall, Statistik | log(10) = 2.302 |
log10($x) | 10 | Größenordnungen, Dezibel | log10(1000) = 3 |
log($x, 2) | 2 | Informatik, Binärbäume, Bits | log(256, 2) = 8 |
log($x, $b) | Beliebig | Spezielle Berechnungen | log(81, 3) = 4 |
Im Folgenden werden die wichtigsten Funktionen einzeln erklärt.
6.1. log10(): Der Zehnerlogarithmus
Die Funktion log10() berechnet direkt den Logarithmus zur Basis 10.
$fErgebnis = log10(1000);
/**
* Gibt 3 zurück, denn 10^3 = 1000.
*/
Verwende log10(), wenn du immer Basis 10 brauchst. Sie ist präziser und direkter als log(x, 10).
6.2. exp(): Die Exponentialfunktion zur Basis e
Mit exp() erhältst du die Umkehrfunktion zu log().
$fErgebnis = exp(2);
/**
* Gibt etwa 7.389056 zurück.
*/
exp(log(x)) ergibt wieder x.
6.3. pow(): Allgemeine Potenzfunktion
Mit pow() berechnest du beliebige Potenzen.
$fErgebnis = pow(2, 3);
/**
* Gibt 8 zurück, denn 2^3 = 8.
*/
pow() ist das Gegenstück zu log(x, basis).
6.4. log() mit Basis 2: Der Zweierlogarithmus
In der Informatik begegnet dir der Logarithmus zur Basis 2 besonders oft. Er beantwortet die Frage: Wie viele Bits brauche ich, um eine bestimmte Anzahl von Werten darzustellen? PHP bietet dafür keine eigene Funktion, aber du kannst log($x, 2) verwenden:
<?php
/* Wie viele Bits braucht man für 256 Werte? */
$iBits = (int) log(256, 2);
echo $iBits; // 8
/* Tiefe eines balancierten Binärbaums */
$iKnoten = 1000;
$iTiefe = (int) ceil(log($iKnoten, 2));
echo $iTiefe; // 10
?>
Für Algorithmus-Analyse (O-Notation) oder Speicherberechnungen ist der Zweierlogarithmus unverzichtbar. Wenn du häufig mit Basis 2 rechnest, lohnt sich eine kleine Hilfsfunktion:
<?php
function log2(float $fZahl): float
{
return log($fZahl, 2);
}
echo log2(1024); // 10.0
?>
7. PHP Versionskompatibilität
Den zweiten Parameter für die Basis gibt es ab PHP 4.3. In allen modernen PHP-Versionen (PHP 7, PHP 8) kannst du log() wie beschrieben verwenden. In alten PHP-Versionen steht nur der natürliche Logarithmus zur Verfügung.
8. Häufige Fragen zu log()
Wie berechne ich log2 in PHP?
PHP hat keine eigene log2()-Funktion, aber du kannst einfach log($x, 2) aufrufen. Das zweite Argument legt die Basis fest. Für 256 ergibt log(256, 2) den Wert 8, weil 2 hoch 8 gleich 256 ist.
Was gibt log(0) zurück?
log(0) gibt -INF zurück (minus unendlich). Mathematisch ist der Logarithmus von 0 nicht definiert, aber PHP liefert statt eines Fehlers den Grenzwert. Prüfe das Ergebnis mit is_infinite(), bevor du weiterrechnest.
Was ist der Unterschied zwischen log() und log10()?
log() berechnet standardmäßig den natürlichen Logarithmus (Basis e), während log10() immer Basis 10 verwendet. Du kannst mit log($x, 10) dasselbe Ergebnis wie log10($x) erzielen, aber log10() ist etwas präziser und besser lesbar.
9. Fazit: Welche Funktion für welchen Zweck?
Mit log() hast du in PHP ein vielseitiges Werkzeug für mathematische Berechnungen. Damit du schnell die richtige Funktion findest, hier eine kurze Entscheidungshilfe:
- Natürlicher Logarithmus (Wachstum, Zerfall, Statistik):
log($x) - Zehnerlogarithmus (Größenordnungen, Dezibel):
log10($x) - Zweierlogarithmus (Informatik, Bits, Algorithmen):
log($x, 2) - Umkehrfunktion (e hoch x berechnen):
exp($x) - Beliebige Potenzen:
pow($basis, $exponent)
Denke immer daran, die Rückgabewerte auf NAN und INF zu prüfen, und vergleiche Gleitkommazahlen nie direkt mit ==. Mit diesen Grundregeln setzt du Logarithmen in PHP zuverlässig ein.
