Ob Upload-Formular, Backup-Skript oder Storage-Report: früher oder später will ein PHP-Programm wissen, wie viele Bytes eine Datei belegt. Genau dafür gibt es filesize() und ein paar hilfreiche Schwesterfunktionen. Dieses Tutorial zeigt die Byte-Ermittlung, eine lesbare Formatierung, die serverseitige Upload-Validierung und die Prüfung von freiem Plattenplatz.
Was leistet PHP filesize()?
Wer in PHP mit Datei-Uploads, Backup-Skripten oder Reporting-Modulen arbeitet, braucht früher oder später eine verlässliche Antwort auf eine simple Frage: Wie groß ist diese Datei? Genau das macht PHP filesize. Die Funktion liefert die Dateigröße in Bytes als Integer, im Fehlerfall false. Aus dieser Zahl entstehen mit ein paar Zeilen Code menschenlesbare Angaben wie 4,2 MB oder 1,3 GB.
Bevor formatBytes-Helper und Quota-Patterns folgen, ein kurzer Blick auf die drei typischen Einsatz-Szenarien aus dem Alltag.
Im Alltag taucht das Thema in drei typischen Situationen auf. Erstens bei der Validierung von Uploads, wenn man verhindern will, dass jemand 200 MB große Bilder hochlädt. Zweitens bei Quota-Prüfungen, wenn pro Kunde nur eine bestimmte Storage-Menge erlaubt ist. Drittens bei Wartungs- und Reporting-Skripten, die über Tausende Dateien laufen und Statistiken über Auslastung erzeugen. Dieses Tutorial zeigt die wichtigsten Patterns plus die zwei Schwesterfunktionen disk_free_space() und disk_total_space().
Syntax und Rückgabewert von PHP filesize
Die Signatur von PHP filesize ist denkbar einfach. filesize() erwartet einen Pfad und gibt die Größe in Bytes als Integer zurück.
<?php
filesize(string $filename): int|false
Bei nicht existierenden Dateien oder fehlenden Berechtigungen liefert die Funktion false und gibt zusätzlich ein Warning aus. Eine Prüfung mit file_exists() vorab schützt vor unangenehmen Überraschungen.
<?php
$datei = 'beispiel.pdf';
if (file_exists($datei)) {
$bytes = filesize($datei);
echo $datei . ' belegt ' . $bytes . ' Bytes';
}
Der Rückgabewert sollte konsequent geprüft werden. Eine Prüfung mit === false ist sicherer als ein einfaches if, weil eine leere Datei den Wert 0 zurückgibt und damit als falsy gelten würde. Wer ein robustes Skript baut, fragt also explizit auf false ab.
Bytes lesbar formatieren mit formatBytes() und PHP filesize
Bytes sind für Menschen schwer zu greifen. Ein 4-Megabyte-Bild meldet sich als 4194304 Bytes und fühlt sich erstmal nach einer Zufallszahl an. Eine kurze Helper-Funktion macht aus dem Wert ein freundliches "4,21 MB", indem sie immer wieder durch 1024 teilt, bis die nächste Einheit klar ist.
<?php
function formatBytes(int $bytes, int $stellen = 2): string
{
$einheiten = ['B', 'KB', 'MB', 'GB', 'TB'];
$i = 0;
while ($bytes >= 1024 && $i < count($einheiten) - 1) {
$bytes /= 1024;
$i++;
}
return number_format($bytes, $stellen, ',', '.') . ' ' . $einheiten[$i];
}
echo formatBytes(filesize('beispiel.pdf'));
/* z.B. 4,21 MB */
Die Funktion arbeitet mit den klassischen 1024er-Schritten. Wer die SI-Konvention 1000 bevorzugt (Festplattenhersteller schreiben gern "GB" und meinen 10^9), tauscht den Schwellwert aus. Mit number_format() lässt sich die Ausgabe noch feiner steuern, etwa für englische Trennzeichen. Im deutschen Frontend ist das Komma als Dezimaltrenner aber meist die richtige Wahl.
Upload-Größen serverseitig mit PHP filesize validieren
Bei Uploads liegt eine Falle: Der vom Browser gemeldete Wert in $_FILES['datei']['size'] ist letztlich Client-Information und kann manipuliert werden. Wer wirklich sichergehen will, prüft mit PHP filesize direkt am tatsächlich hochgeladenen tmp-File.
<?php
$maxBytes = 5 * 1024 * 1024; /* 5 MB */
if ($_FILES['datei']['error'] !== UPLOAD_ERR_OK) {
exit('Upload-Fehler');
}
$tatsaechlich = filesize($_FILES['datei']['tmp_name']);
if ($tatsaechlich === false || $tatsaechlich > $maxBytes) {
exit('Datei zu gross oder ungueltig.');
}
move_uploaded_file(
$_FILES['datei']['tmp_name'],
'uploads/' . basename($_FILES['datei']['name'])
);
Dieses Pattern fasst die wichtigsten Schritte zusammen: Upload-Status prüfen, Server-side Re-Check der Größe und erst dann die Datei verschieben. Wer noch eine Schicht weiter geht, ergänzt einen MIME-Type-Check via finfo und whitelistet erlaubte Endungen. Für das eigentliche Verschieben ist move_uploaded_file die richtige Wahl, weil sie zusätzlich prüft, ob die Quelle wirklich aus einem HTTP-Upload stammt.
Freien Plattenplatz mit disk_free_space() neben PHP filesize prüfen
Wer PHP filesize um eine Sicht auf das gesamte Volume erweitern will, greift auf zwei Schwesterfunktionen zurück. Die Schwesterfunktionen disk_free_space() und disk_total_space() liefern die Bytes des Dateisystems, auf dem ein Verzeichnis liegt. Beide geben einen Float zurück, weil moderne Platten Werte jenseits der 32-Bit-Grenze locker erreichen. Eine Prozent-Auslastung berechnet sich aus dem Verhältnis.
<?php
$dir = '/var/www/html';
$frei = disk_free_space($dir);
$total = disk_total_space($dir);
if ($frei !== false && $total !== false) {
$auslastung = (1 - $frei / $total) * 100;
echo 'Freier Speicher: ' . formatBytes((int) $frei) . "\n";
echo 'Auslastung: ' . round($auslastung, 1) . ' %';
}
In Cron-Skripten reicht es, den Wert mit einem Schwellwert zu vergleichen und ab einer Auslastung von 90 Prozent eine Warn-Mail zu schicken. Im Shared-Hosting funktionieren die Funktionen je nach Provider, manche schränken die Sichtbarkeit auf das jeweilige Account-Verzeichnis ein und liefern dann gar nicht den globalen Wert. Vor dem produktiven Einsatz also einmal auf dem Zielserver testen.
flowchart TD
A[Datei vorhanden] --> B{filesize Aufruf}
B -->|Erfolg| C[Bytes als int]
B -->|Fehler| D[false zurueck]
C --> E[formatBytes umwandeln]
E --> F[Anzeige als KB/MB/GB]
D --> G[Logging und Fehlermeldung]
Verzeichnisgröße rekursiv summieren mit PHP filesize
Mit PHP filesize allein lässt sich eine ganze Hierarchie nicht messen. Eine eingebaute Funktion für die Gesamtgröße eines Verzeichnisses gibt es nicht. Mit RecursiveDirectoryIterator plus RecursiveIteratorIterator ist die Summe in wenigen Zeilen geschrieben.
<?php
function verzeichnisGroesse(string $pfad): int
{
$summe = 0;
$iterator = new RecursiveIteratorIterator(
new RecursiveDirectoryIterator($pfad, FilesystemIterator::SKIP_DOTS)
);
foreach ($iterator as $datei) {
if ($datei->isFile()) {
$summe += $datei->getSize();
}
}
return $summe;
}
echo formatBytes(verzeichnisGroesse('uploads/'));
Die Methode getSize() der SplFileInfo-Objekte ruft intern filesize() auf. Das Pattern eignet sich für Quota-Reports, Storage-Statistiken oder einfach für das Aufräumen von verlassenen Cache-Verzeichnissen. Wer in einem Mandanten-System pro Kunde rechnet, ergänzt einen Filter und überspringt versteckte Dateien wie .DS_Store oder Thumbs.db.
Stolperfalle stat-Cache und clearstatcache() bei PHP filesize
PHP cacht die Ergebnisse von Datei-Statistik-Funktionen wie PHP filesize, filemtime() oder is_writable() innerhalb einer Skriptausführung. Das ist meist nützlich, kann aber stören, wenn ein Skript eine Datei selbst verändert und gleich danach die neue Größe messen will.
<?php
$datei = 'log.txt';
file_put_contents($datei, 'erste Zeile' . PHP_EOL);
echo filesize($datei) . "\n";
/* z.B. 12 */
file_put_contents($datei, 'zweite Zeile' . PHP_EOL, FILE_APPEND);
clearstatcache(true, $datei);
echo filesize($datei);
/* erst nach clearstatcache stimmt der Wert */
Ohne clearstatcache() liefert der zweite filesize()-Aufruf den alten Wert. Der zweite Parameter true schränkt das Cache-Leeren auf die genannte Datei ein und ist effizienter als das pauschale clearstatcache() ohne Argumente.
Grenzen von PHP filesize bei sehr großen Dateien
Auf modernen 64-Bit-Systemen ist PHP filesize unkritisch. Auf 32-Bit-Systemen oder mit bestimmten Stream-Wrappern verhält sich die Funktion bei Dateien jenseits der 2-Gigabyte-Grenze unerwartet, weil die Bytes in einem signed 32-Bit-Integer überlaufen. Das Ergebnis kann ein negativer Wert oder eine völlig falsche Zahl sein. Wer in einer Umgebung arbeitet, in der Mediendateien diese Größen erreichen, sollte zur Sicherheit den 64-Bit-Build von PHP nutzen oder bei Remote-Quellen auf den Content-Length-Header zurückgreifen, den get_headers() liefert.
Auch bei HTTP-URLs ist PHP filesize keine zuverlässige Wahl. Manche Stream-Wrapper unterstützen die Funktion gar nicht und liefern false, andere liefern 0. Für Remote-Dateien ist die saubere Lösung ein HEAD-Request mit Auswertung des Content-Length-Headers.
Fazit zu PHP filesize
PHP filesize ist die Standardfunktion in PHP, um Bytes einer Datei zu ermitteln. PHP filesize ist schnell, einfach zu nutzen und im Alltag die erste Wahl für jede Größenprüfung. Sie arbeitet mit dem stat-Cache, was bei mehrfachen Aufrufen Performance bringt, und kommt in Upload-Validierung, Quota-Prüfung und Reporting gleichermaßen zum Einsatz. Mit einer kurzen formatBytes-Funktion wird der Bytes-Wert lesbar, mit disk_free_space() und disk_total_space() lassen sich Quotas und Auslastung prüfen. Wer den stat-Cache, das 32-bit-Limit und die Eigenheiten von Remote-URLs kennt, kann Datei-Validierung in Uploads, Backups und Reporting-Skripten zuverlässig umsetzen.
