Das Plug-in WP Page Load Stats bietet den Besuchern einer Website einen Einblick in die Hintergrundprozesse während der Seitenladung. Es zeigt wichtige Leistungsmetriken an, die Aufschluss darüber geben, wie effizient und reaktionsschnell die Website arbeitet. Durch die Überwachung dieser Metriken wird Klarheit darüber gewonnen, welche Zusammenhänge es zur Page Load Time gibt. Website-Betreiber können potenzielle Leistungsprobleme erkennen und Optimierungen vornehmen, um die Benutzererfahrung zu verbessern.
Die Bedeutung der Ladezeit und die Leistung einer Website sind vielen von uns bewusst. Das WP Page Load Stats Plug-in war in der Vergangenheit eine zuverlässige Option, um genau das zu tun. Leider hat dieses nützliche Tool in den letzten Jahren seinen Dienst eingestellt, und die Kompatibilität mit den neuesten PHP-Versionen wurde zum Problem.
Mit PHP 8 verlor das Plug-in vollends seine Funktionalität, da der Code nicht mehr den neuesten PHP-Standards entsprach.
Das grundlegende Plug-in zur folgenden Funktionalität ist auch hier zum Download wp-page-load-stats.1.0.2
WP Page Load Stats – Einblicke in Website-Performance für Webmaster und Besucher.
Servus, ich bin das 'Helferlein'!
Aber zum Glück gibt es immer noch eine Möglichkeit, dieses hilfreiche Tool weiterhin zu nutzen! Dank der Unterstützung von ChatGPT, einem fortschrittlichen KI-Modell, konnte eine aktualisierte Version des Plug-ins erstellt werden, die mit PHP 8 und sogar den neuesten PHP-Versionen kompatibel ist. Mit einigen Anpassungen konnte das Plug-in wieder zum Leben erweckt werden und bietet uns die Möglichkeit, die Leistung unserer Website auch weiterhin im Blick zu behalten.
Hallo, ich bin da "Wegerl"!
Wir freuen uns, dir diese aktualisierte Version von 'WP Page Load Stats' + das interne 'WP Page Load Stats 7' und 'WP Page Load Stats 9' Plug-in präsentieren zu können. Wir möchten jedoch darauf hinweisen, dass der ursprüngliche Autor das Plug-in nicht mehr unterstützt, und wir es daher als 'Inoffizielle Version' anbieten. Obwohl wir unser Bestes tun, um das Plug-in funktionsfähig zu halten, können wir keine Garantie für zukünftige Updates oder Fehlerbehebungen geben.
Wir möchten an dieser Stelle ein herzliches Dankeschön an Mike Jolley aussprechen, den ursprünglichen Autor von "WP Page Load Stats". Obwohl das Plug-in nicht mehr offiziell unterstützt wird, bietet er es immer noch zum Download an. Seine Arbeit hat die Grundlage für die Entwicklung der 'Inoffizielle Versionen' und 'Interene Version (WP Page Load Stats 7 und 9)' geschaffen, die wir hier zur Verfügung stellen.
So gehst du vor, um das Plug-in zu verwenden
Gehe über "Plugins" Installieren zum Pluginverzeichnis und suche nach "WP Page Load Stats Mike Jolley".
Nach dem Installieren bitte nicht aktivieren, wenn du einen Server ab PHP 8 hast. Andernfalls könnte es zu einem Fatal Error kommen.
Sobald das Plug-in installiert ist, gehe über das WordPress-Dashboard zu "Plugins" in der linken Seitenleiste. Klicke auf "Plugin-Datei-Editor" und wähle das Plug-in "WP Page Load Stats" aus der Dropdown-Liste. Die Datei wp-page-load-stats.php wird angezeigt. Lösche den gesamten Inhalt dieser Datei und füge den hier kopierten Code ein. Speichere die Änderungen ab und aktiviere das Plug-in anschließend über das Dashboard unter "Plugins > Installierte Plugins".
Bevor wir uns den Programmierungscodes zuwenden, befassen wir uns mit den Details der Leistungsmetriken und geben Erläuterungen zum Plug-in.
Leistungsmetriken, basal!
Die Browser zeigen unterschiedliche Ergebnisse in Bezug auf die Page Load Time. Diese Zeit variiert erheblich und kann bis zu mehr als die Hälfte schwanken. Es geht hier darum, die gemessenen Daten zu verstehen und zu interpretieren.
Hier bieten wir eine leicht abgeänderte Version der Metriken von WP Page Load Stats an. Die Metriken umfassen zum Beispiel:
Serverreaktion: 0,251 ms.
DB-Abfrage: 0,072 sec.
21 Abfragen…
…in 0,311 sec.
Serverantwort: 0,313 sec.
Page Load Time: 1,953 sec.
Mem Usage: 21,76 MB (8,50 %).
Die Leistungsmetriken unter der Lupe
Die Leistungsmetriken sieh folgend im Scrolle:
(1) "Serverreaktion": 0,251 ms.
Die Serverreaktion gibt an, wie schnell der Server auf eine Anfrage reagiert und mit dem Laden der Seite beginnt. Es ist die Zeit, die der Server braucht, um die Anfrage zu verarbeiten und die ersten Daten an den Browser des Besuchers zu senden.
Eine niedrige Serverreaktion ist von entscheidender Bedeutung, um eine schnelle Website zu gewährleisten. Wenn die Serverreaktion hoch ist, kann dies zu Verzögerungen beim Laden der Seite führen und sich negativ auf die Benutzererfahrung auswirken.
(2) "DB-Abfrage": 0,072 Sekunden
Die Datenbankabfragezeit. Diese Metrik zeigt die Effizienz der Datenbanknutzung an. Der Wert gibt die Gesamtzeit an, um die Datenbankabfragen zu bearbeiten. Er bezieht sich ausschließlich auf die Zeit, die für die Datenbankabfragen aufgewendet wurde, und nicht auf andere Dateien oder Servervorgänge.
Eine optimierte Datenbankabfragezeit trägt zur Verbesserung der Gesamtperformance der Website bei.
Bitte beachten! – das zur DB-Abfrage kann Probleme machen. Hier war das durch Aktivierung des Plug-ins Query-Monitor in Ordnung zu bringen. Dies funktioniert dann auch nach Deaktivierung des Plug-ins:
Manchmal können bestimmte Konstellationen von Plug-ins, Konfigurationseinstellungen oder temporäre Zustände dazu führen, dass bestimmte Funktionen oder Anzeigen auf einer Website nicht wie erwartet funktionieren. Das Aktivieren von Query Monitor könnte dazu geführt haben, dass diese Konstellation neu bewertet wurde, und möglicherweise hat sich dadurch etwas im System "gelöst".
Die Deaktivierung von Query Monitor könnte dann weiterhin die Funktionalität beibehalten haben, weil die zuvor möglicherweise beeinflussenden Faktoren stabilisiert wurden oder sich geändert haben.
Es ist nicht ungewöhnlich, dass solche Dinge in der Welt der Webentwicklung auftreten, und manchmal können sie schwer vorhersehbar sein.
Eine veraltete Darstellung der Entwicklung von WP Page Load Stats 7.
Wenn jedoch trotz der vorübergehenden Aktivierung von 'Query Monitor' diese Funktion nicht in Betrieb ist, kann der folgende Abschnitt in unserem Plug-in entfernt werden:
Somit könnte man auch das auskommentieren oder entfernen:
/* Aktuelle Datenbankabfragezeit abrufen
global $wpdb;
$db_query_time = 0;
if (isset($wpdb->queries) && is_array($wpdb->queries)) {
foreach ($wpdb->queries as $query) {
$db_query_time += isset($query[1]) ? floatval($query[1]) : 0;
}
}
*/
Fachsimpel: Es ist grundsätzlich nichts falsch daran, die Datenbankabfragezeit auf diese Weise abzurufen, solange $wpdb->queries verfügbar ist und korrekt gefüllt wird. Dieser Ansatz ist nicht direkt abhängig von define('SAVEQUERIES', true);, welches ein gewisses Sicherheitsrisiko darstellen würde.
Damit die DB-Abfrage zuverlässig funktionieren, wenn so Probleme auftreten, würde (würde!) das mit folgende Code in der wp-config.php funktional:
define( 'SAVEQUERIES', true );
Es ist wichtig zu beachten, dass solcherart das Speichern von Abfragen nur für Debugging-Zwecke verwendet werden sollte und in einer Produktionsumgebung deaktiviert werden sollte, um mögliche Sicherheitsrisiken zu minimieren.
Das Anzeigen von Datenbankabfrageinformationen im Frontend kann sensible Informationen über deine Website preisgeben.
Die Datenbankabfrageinformationen selbst enthalten normalerweise keine sensiblen personenbezogenen Daten, aber sie könnten möglicherweise Informationen über die Struktur und möglicherweise sogar den Inhalt deiner Datenbank preisgeben. Dies könnte einem potenziellen Angreifer Anhaltspunkte darüber geben, wie deine Website aufgebaut ist, und möglicherweise Schwachstellen offenlegen.
Tabellennamen und -präfixe: Die Namen und Präfixe deiner Datenbanktabellen könnten möglicherweise Rückschlüsse darauf zulassen, welche Plug-ins oder Themes du verwendest, und somit Informationen über die Funktionalität deiner Website preisgeben.
Verwendete Abfragen: Die angezeigten Datenbankabfragen könnten auf bestimmte Funktionen, Plug-ins oder Themes hinweisen, die du verwendest. Dies könnte ebenfalls Informationen über die Struktur deiner Website liefern.
Datenbankstruktur: In einigen Fällen könnten die Abfragen Hinweise darauf geben, welche Art von Daten in deiner Datenbank gespeichert sind, wenn spezifische Tabellennamen oder Abfragekriterien erkennbar sind.
Es ist zu beachten, dass dies keine direkten personenbezogenen Informationen (wie Benutzerdaten) sind, aber dennoch könnte ein gewisses Maß an Informationen über die Website-Struktur und -Funktionalität offengelegt werden. Daher ist Vorsicht geboten, insbesondere wenn diese Informationen für nicht autorisierte Benutzer sichtbar sind.
Daher ist es ratsam, die Anzeige von Datenbankabfrageinformationen auf autorisierte Benutzer zu beschränken und sie in Produktionsumgebungen zu deaktivieren. Das bedeutet, dass die Anwendung des define( 'SAVEQUERIES', true ); zu diesem Zweck nicht empfohlen ist.
(3) 21 "Abfragen"…
Dieser Wert zeigt die Gesamtzahl der Datenabfragen an, die während der Seitenladung ausgeführt wurden. Es handelt sich um alle Abfragen, die sowohl die Dateien auf dem Server (z. B. Medien, Plug-ins und andere Ressourcen) als auch die Datenbank betreffen können.
Datenabfragen umfassen verschiedene Vorgänge, bei denen die Website Informationen von der Datenbank oder anderen Serverressourcen abruft, um die Webseite vollständig darzustellen. Diese Abfragen können das Laden von Seiteninhalten, Bildern, CSS-Dateien, JavaScript und anderen Dateien umfassen, die für das ordnungsgemäße Funktionieren der Webseite sind.
Die Anzahl der Abfragen ist ein weiterer Indikator für die Effizienz und Leistung der Website. Je weniger Abfragen eine Webseite während der Ladezeit ausführen muss, desto schneller und reibungsloser kann die Seite geladen werden. Durch die Optimierung der Anzahl der Abfragen können Ladezeiten verkürzt und die Benutzererfahrung verbessert werden.
Dies kann beispielsweise durch das Minimieren von HTTP-Anfragen, das Zusammenfassen von CSS- und JavaScript-Dateien und den effizienten Einsatz von Caching-Techniken erreicht werden. Eine effiziente Datenabfrage reduziert auch die Serverbelastung und kann Kosten sparen, insbesondere in Bezug auf Hosting-Ressourcen.
Daher ist es wichtig, die Anzahl der Abfragen zu überwachen und bei Bedarf Maßnahmen zu ergreifen, um die Leistung der Website zu optimieren und eine bessere Benutzererfahrung zu bieten. Tools wie WP Page Load Stats können dabei helfen, diese Metrik zu analysieren und Optimierungspotenzial zu identifizieren.
(4) (21 "Abfragen") in 0,311 Sekunden
Dieser Wert gibt die Gesamtzeit an, die sich aus der Gesamtzahl der Datenabfragen (259 Abfragen) ergibt, einschließlich aller Vorgänge, die sowohl Dateien als auch Datenbank betreffen. Die Gesamtzeit der Datenabfragen repräsentiert die kumulierte Zeit, die benötigt wird, um sämtliche Informationen und Ressourcen einer Webseite zu laden. Hierbei handelt es sich nicht nur um die Datenbankabfragen, sondern auch um das Abrufen von Dateien wie Plug-ins, Medien und anderen Ressourcen.
Die Gesamtzeit der Datenabfragen ist ein wesentlicher Leistungsfaktor für die Seitenladungsgeschwindigkeit einer Webseite. Eine niedrige Gesamtzeit der Datenabfragen deutet darauf hin, dass die Website effizient arbeitet und ihre Ressourcen schnell bereitstellt. Dies führt zu einer besseren Benutzererfahrung, da die Seiten schneller geladen werden und Besucher weniger Wartezeit haben.
Um die Gesamtzeit der Datenabfragen zu verbessern, können verschiedene Maßnahmen ergriffen werden, wie die Optimierung von Datenbankabfragen, die Verwendung von Caching-Techniken und das effiziente Laden von Ressourcen. Diese Optimierungen führen zu einer schnelleren und reaktionsschneller Website für deine Besucher.
(5) "Serverantwort": 0,313 sec.
Die Serverantwort umfasst die Zeit, die der Server gebraucht hat, um alle erforderlichen Daten und Ressourcen für die vollständige Darstellung der Seite zu sammeln und an den Browser des Besuchers zu liefern.
Während die Serverreaktion die Zeit bis zum Beginn des Ladens der Seite misst, gibt die Serverantwort an, wie lange der Server benötigt hat, um alle Inhalte, Bilder, Skripte und andere Ressourcen der Webseite zu sammeln und an den Browser zu übertragen.
In diesem Beispiel sind die Reaktionszeit (0,200 Sekunden) und die Antwortzeit (0,294 Sekunden), was in Summe 0,494 Sekunden ergibt. Alle anderen zeitlichen Verzögerungen entstehen vor allem durch den Rendering-Prozess und ähnliche technische Faktoren.
Eine niedrige Serverarbeitzeit ist, um sicherzustellen, dass die Seite schnell und vollständig geladen wird, was zu einer positiven Benutzererfahrung führt.
Die Serverantwortzeit (auch als "Time to First Byte" oder TTFB bezeichnet) kann mit der eigenen Bandbreite zusammenhängen, insbesondere wenn du als Benutzer oder Entwickler die Webseite aufrufst. Hier ist, wie die Bandbreite in Bezug auf die Serverantwortzeit eine Rolle spielt:
Client-zu-Server-Kommunikation: Wenn du eine Webseite besuchen, sendet Ihr Webbrowser eine Anforderung an den Webserver, um die benötigten Ressourcen wie HTML, CSS, JavaScript und Bilder abzurufen. Die Geschwindigkeit, mit der dein Browser diese Anforderungen senden kann, hängt von deiner eigenen Bandbreite ab. Eine schnellere Bandbreite ermöglicht es dir, diese Anfragen schneller zu versenden.
Server-zu-Client-Kommunikation: Nachdem der Webserver die Anforderungen erhalten hat, sendet er die entsprechenden Ressourcen als Antwort zurück an deinen Browser. Die Serverantwortzeit (TTFB) hängt von der Bandbreite des Servers ab. Ein Server mit einer höheren Bandbreite kann die Ressourcen schneller an den Client senden.
Paketverlust und Stabilität: Die Bandbreite beeinflusst auch die Stabilität der Verbindung zwischen deinem Client (Browser) und dem Server. Eine instabile oder niedrige Bandbreite kann zu Paketverlusten und Verzögerungen bei der Kommunikation führen, was sich auf die Serverantwortzeit auswirken kann.
(6) "Page Load Time": 1,953 sec.
Die Page Load Time ist die Gesamtzeit, die gebraucht wurde, um die gesamte Webseite einschließlich aller Ressourcen und Daten zu laden. Hierbei spielt das Rendering eine entscheidende Rolle, da es ein Teil der 'Page Load Time' ist. Das Rendering bezieht sich auf den Vorgang, bei dem der Browser die heruntergeladenen Daten in sichtbare Inhalte umwandelt und die Webseite für den Benutzer darstellt. Dies beinhaltet das Anzeigen von Text, Bildern, Videos und anderen Elementen der Webseite.
Eine schnelle Page Load Time und ein effizientes Rendering sind entscheidend für eine positive Benutzererfahrung und ein besseres Ranking in den Suchergebnissen.
Um diese Metrik zu optimieren, können verschiedene Maßnahmen ergriffen werden, wie die Reduzierung der Dateigröße von Bildern, die Verwendung von Lazy Loading für Bilder und Videos, die Minimierung von JavaScript und CSS-Dateien sowie die Nutzung von modernen Webtechnologien. Durch diese Optimierungen kann die Page Load Time reduziert und die Website schneller und reaktionsschneller gemacht werden.
Die 'Page Load Time' hängt eng mit der 'Rendertime' und der 'Time To Interactive' zusammen und wird zudem von der Netzwerkgeschwindigkeit oder Bandbreite beeinflusst, die vom Internetanbieter bereitgestellt wird. Letztere bestimmt, wie schnell Daten über das Internet übertragen werden können. Die Netzwerkgeschwindigkeit, zusammen mit ihr die 'Page Load Time', kann auch je nach regionalen und zeitlichen Anforderungen an Daten variieren.
Wenn die 'Page Load Time' nicht mit anderen Messwerten wie der Serverantwortzeit oder der Datenbankabfragezeit übereinstimmt, könnte dies auf die Netzwerkgeschwindigkeit zurückzuführen sein. Eine langsame Netzwerkgeschwindigkeit kann längere Ladezeiten zur Folge haben, selbst wenn der Server und andere Ressourcen schnell reagieren.
Die 'Page Load Time' wird von der Serverleistung, der Größe der Ressourcen und vor allem der Netzwerkgeschwindigkeit beeinflusst. Diese Wechselwirkung unterschiedlicher Faktoren trägt zur Gesamtladezeit bei und kann zu Abweichungen zwischen den gemessenen Werten führen.
Serverantwort und Page Load Time: Normalerweise sollte die Page Load Time länger sein als die Serverantwortzeit, da sie die Zeit beinhaltet, die der Server braucht, um die Ressourcen zu generieren und an den Client zu senden. In anderem Beispiel ist die Serverantwortzeit (1,254 Sekunden) länger als die Page Load Time (0,951 Sekunden), was ungewöhnlich ist.
Eine Diskrepanz zwischen gemessenen Werten wie der Serverantwortzeit und der Page Load Time kann in einigen Fällen auf Messfehler oder Schwankungen zurückzuführen sein. Es gibt mehrere Faktoren, die dazu beitragen können:
Caching: Wenn die Seite oder bestimmte Ressourcen im Cache gespeichert sind, kann dies die Page Load Time verkürzen, da der Server weniger Arbeit hat. Die Serverantwortzeit bleibt jedoch unverändert.
Parallelisierung: In einigen Fällen kann der Browser mehrere Ressourcen parallel laden. Dies könnte die wahrgenommene Page Load Time verkürzen, da einige Ressourcen gleichzeitig geladen werden, während andere noch auf die Serverantwort warten.
Externe Ressourcen: Wenn die Seite externe Ressourcen von Drittanbietern wie Werbenetzwerken oder Analysetools enthält, können Verzögerungen beim Laden dieser Ressourcen die Page Load Time verlängern.
Serverleistungsschwankungen: Die Serverleistung kann schwanken, abhängig von der aktuellen Auslastung, dem Datenverkehr und anderen Faktoren. Dies kann zu Unterschieden in der Serverantwortzeit führen, wenn Messungen zu unterschiedlichen Zeiten durchgeführt werden.
Netzwerkschwankungen: Das Internet ist ein dynamisches Umfeld, und die Netzwerkschwankungen können dazu führen, dass die Übertragungsgeschwindigkeit zwischen dem Server und dem Client variiert. Dies kann sich auf die Messungen auswirken.
Clientseitige Prozesse: Der Client (der Browser des Benutzers) führt auch verschiedene Prozesse aus, um Ressourcen zu laden und anzuzeigen. Diese Prozesse können je nach Browser und Betriebssystem variieren und zu Unterschieden in der Page Load Time führen.
(7) "Mem Usage": 21,76 MB (8,50 %)
Speichernutzung (Memory Usage): Dies bezieht sich auf die Menge an Speicher, die von PHP-Funktionen und anderen Ressourcen während des Ladevorgangs der Seite verwendet wird. Die "Speichernutzung" kann sich also auf den tatsächlichen Arbeitsspeicher (RAM) beziehen, den der Server oder der Browser benötigt, um die Website auszuführen.
Dieser Wert gibt die aktuelle Gesamtnutzung des Speichers für die Website an, einschließlich sowohl der Dateien als auch der Datenbank. Dabei entsprechen des Beispiel die 8,23 % dem verfügbaren Speicherplatz von 256 MB. Dieser Wert berücksichtigt den Speicherplatz, der von der Datenbank für die gespeicherten Daten verwendet wird.
Eine ausreichende Speichernutzung ist entscheidend für die reibungslose Funktion der Website und stellt sicher, dass genügend Ressourcen vorhanden sind, um Inhalte und Daten effizient zu verwalten.
Bei einer hohen Speichernutzung kann es zu Leistungsproblemen kommen, während eine optimierte Speicherverwendung die Ladegeschwindigkeit und die Benutzererfahrung verbessert.
"Speichernutzung" und "Seitengröße": Die "Speichernutzung" ist nicht dasselbe wie die "Seitengröße". Die exakte Ermittlung der Page Size ist in der Praxis recht komplex, da verschiedene Faktoren wie Caching, Serverzustände usw. berücksichtigt werden müssen. Während meiner Tests habe ich mit KI-Texter erfolgreich die HTML-Größe, CSS-Dateien und JavaScript-Dateien ermittelt.
Allerdings sind wir bei dem Versuch, die Bildgrößen zu berechnen, gescheitert, da die Webseite dadurch hängenblieb und der Ladevorgang nicht abgeschlossen werden konnte.
Page Size: Die 'Page Size' kann beispielsweise mithilfe von Pingdom eingesehen werden. Sollte das Ergebnis nicht wie erwartet angezeigt werden, da es anscheinend während des Messzeitraums nicht vollständig generiert wurde: dann klicke auf "Ergebnis teilen". Die Ergebnisse sind dann per E-Mail abrufbar.
In diesem Beitrag WP: Caching unter der Lupe – Einblicke in die Unterschiede werfen wir einen genaueren Blick auf Caching, um die Unterschiede besser zu verstehen und wie sie sich auf die vollständige Ladegeschwindigkeit der Website auswirken.
Wer viel misst, misst viel Mist ⸮
Query Monitor vs. WP Page Load Stats
Query Monitor ist eine leistungsfähige WordPress-Erweiterung, das fortgeschrittenen Webmasters detailliert Auskünfte über ihre Website gibt. Es zeigt umfassende Diagnosedaten wie Abfragezeiten, Speichernutzung, PHP-Fehler und vieles mehr an, um die Website-Optimierung zu erleichtern.
Bemerkung zu den Leistungsmetriken: Vier Metriken entsprechen jenen, die auch das Plug-in Query Monitor in der Headerzeile anzeigt. Diese Metriken sind, wenn auch in anderer Reihenfolge:
WP Page Load Stats 7: Die Zeit der DB-Abfrage (entspricht dem Messwert an der dritten Stelle im 'Query Monitor').
WP Page Load Stats 7: Die 'Abfragen' (Gesamtzahl der Datenabfragen) zusammen mit der Gesamtzeit der Datenabfragen (entsprechen dem letzten und ersten Messwert im 'Query Monitor').
WP Page Load Stats 7: Der verwendete Speicher wird im 'Query Monitor' als zweiter Messwert angezeigt.
WP Page Load Stats 7
Query Monitor
Es ist ebenda auch möglich, dass die angezeigten Werte zwischen 'WP Page Load Stats' und 'Query Monitor' geringfügig variieren. Beide Plug-ins verwenden möglicherweise unterschiedliche Methoden, um die Website-Performance zu messen.
Messwerkzeuge und -methoden: Unterschiedliche Messwerkzeuge können leicht unterschiedliche Ergebnisse liefern.
Anhaltspunkte
Eine kurze Einführung in 'WP Page Load Stats 9',
Erläuterungen zu den 'Internen Versionen' sowie
Informationen zu Dezimalzeichen und möglichen Anpassungen der Texte im Anzeigenfeld.
'WP Page Load Stats 9'
Das Plug-in WP Page Load Stats 9 (Interne Version) bietet dieselben Leistungsmetriken wie 'WP Page Load Stats 7' und zusätzlich die 'Rendertime' und die 'Time To Interactive'. Das ist also mit 9 Metriken. Anmkerkung: Die Kommastellen der beiden zusätzlichen Metriken und hier der Page Load Time sind über eine Millisecunde (1 Tausendstelsekunde: 0,001) hinaus auf vier erhöht, um meist überhaupt eine Abweichung erkennen zu können. Das kann denn zum Ausprobieren mal ganz interessant sein.
Erläuterung zu den 'Interen Verionen'
In der 'Internen Version' 'WP Page Load Stats 7' sowie in 'WP Page Load Stats 9' wurden die Funktionen zur Berechnung des Durchschnitts der Abfragezeiten in Sekunden aus dem ursprünglichen Plug-in entfernt, da wir sie als praktisch irrelevant erachteten. Ebenso wird die Anzeige der maximalen Speichernutzung nicht mehr dargestellt, da diese Information bereits aus den Prozentsätzen der direkten Nutzung abgeleitet werden kann.
Daher führt das Plug-in 'WP Page Load Stats 7' auch 'WP Page Load Stats 9' keine Datenbankinteraktionen durch, da die Funktion update_option() und ähnliche Funktionen, die normalerweise Daten in der Datenbank speichern würden, nicht mehr vorhanden sind. Die Messdaten werden stattdessen im laufenden Prozess in Variablen gespeichert und in Echtzeit im Frontend angezeigt, ohne in der Datenbank abgelegt zu werden.
Stattdessen wurde bei beiden 'Internen Versionen' die Gesamtzeit für Datenbankabfragen hinzugefügt, was eine interessante Gegenbetrachtung zur Gesamtzahl der Datenabfragen darstellt. Zusätzlich wurden die Serverreaktion, die Serverantwort und die gesamte Seitenladezeit (Page Load Time) eingeführt.
Die Version im Namen Inoffizielle Version hingegen wurde im Wesentlichen unverändert beibehalten, jedoch so angepasst, dass sie auch unter PHP 8 einwandfrei funktioniert.
Informationen zu Dezimalzeichen und möglichen Anpassungen der Texte im Anzeigenfeld
Standardmäßig verwendet PHP den Punkt als Dezimaltrennzeichen. Dies ist besonders relevant, wenn die Benutzeroberfläche auf eine andere Dezimaltrennung eingestellt ist, wie es zum Beispiel in vielen europäischen Ländern mit dem Komma der Fall ist.
Durch die Funktion number_format_i18n in WordPress ist eine internationale Formatierung für Zahlen möglich. Das 'i18n' in der Funktion steht für 'Internationalization', was darauf hinweist, dass die Funktion speziell für die Anpassung von Zahlen an verschiedene Ländereinstellungen und Sprachen entwickelt wurde. Das Dezimalzeichen wird also automatisch angepasst.
Der Teil zu den 'Abfragen' passt sich durch die Verwendung von $timer_stop = timer_stop(0) automatisch dem Dezimalzeichen an, um die internationale Formatierung zu berücksichtigen. Dies ist eine PHP-Funktion, die auf der Serverseite ausgeführt wird.
Das Element mit der Classe <li class="page-load-time"></li> wird direkt durch JavaScript aktualisiert. Es ist nicht erforderlich, dies mit number_format_i18n zu tun, da diese Funktion in PHP arbeitet.
Einstellungen wie Sprache und sonstiges sind nicht vorhanden. Für die individuelle Anpassung der Texte kann jeder Benutzer leicht die Datei wp-page-load-stats.php bearbeiten und die gewünschten Texte direkt in den li-Elementen festlegen.
Das li-Element mit der Classe 'page-load-time' erfordert eine separate Anpassung des Textes im JavaScript.
Diese Anpassungen können also im Abschnitt [// Info anzeigen] in der Datei vorgenommen werden. Das <li>-Element mit der Classe page-load-time erfordert jedoch eine separate Anpassung des Textes 'Page Load Time', falls dies erwünscht ist. Dies kann im entsprechenden JavaScript-Code in der Datei /wp-page-load-stats.php erfolgen.
Bei der Änderung des Textes "Page Load Time" ist eine separate Anpassung im JavaScript erforderlich.
Zusätzliche Informationen zu Optionen ist nach dem Code für 'WP Page Load Stats 7' zu finden.
Fachsimpel zur Serverreaktionszeit
Die Berechnung der Serverreaktionszeit mit acht Dezimalstellen bietet eine höhere Genauigkeit bei der Erfassung der Zeitdifferenz zwischen Start und Ende der Serverreaktion. Dies ermöglicht eine präzisere Messung, insbesondere wenn die Zeitdifferenzen sehr klein sind.
Die Serverreaktionszeit in Millisekunden wird mit 8 Dezimalstellen berechnet und hier mit 8 Dezimalstellen formatiert.
Die Entscheidung, nur drei Dezimalstellen in der Anzeige zu verwenden, erfolgt oft aus Gründen der Lesbarkeit und Konvention. In vielen Fällen werden Millisekunden mit drei Dezimalstellen angezeigt, was eine gängige Praxis ist. Dies erleichtert die Interpretation der Werte, ohne die Anzeige zu überladen.
Das Ergebnis der Serverreaktionszeit wird mit 3 Dezimalstellen angezeigt.
Zusammenfassend wird die höhere interne Genauigkeit beibehalten, um genauere Messungen zu ermöglichen, während die Anzeige mit drei Dezimalstellen erfolgt, um die Informationen leichter verständlich und lesbar zu halten.
Hinweis CSS: Die beiden Buttons "Schließen" und "Neuladen" haben hier ein leicht abweichendes Design und stehen nicht in Verbindung mit den in dieser Plug-in-Version vorgestellten Elementen. Die Anpassung dieser Buttons erfolgt in der style.css des Plug-ins.
Folgend sind die Programmierungs-Codes für WP Page Load Stats 7, WP Page Load Stats 9 und WP Page Load Stats (Inoffizielle Version). Die Codes werden mit dem Original der Datei ausgetauscht.
Das präsentiert die 'Interne Version' mit 7 Metriken von 'WP Page Load Stats'. Diese Version ab PHP 7+ enthält spezielle Anpassungen und Änderungen, die sie zu einer ausgezeichneten Option machen, um die Leistung einer Website zu überwachen.
<?php
/*
Plugin Name: WP Page Load Stats 7 (Interne Version)
Plugin URI: https://wegerl.at/wp-page-load-stats-7/
Description: Zeigt 7 Leistungsmetriken im Footer an: Serverreaktionszeit, Gesamtzeit für Datenbankabfragen, Gesamtzahl und Gesamtzeit der Datenabfragen, Serverarbeitungszeit (Serverantwort), Gesamtladezeit der Seite (Page Load Time) und Speichernutzung (Memory Usage).
Erfordert PHP 7.4
Version: 1.0.2
Author: Mike Jolley (Originalversion), [Ditmar Winkler] (Interne Version)
License: GPLv3
License URI: http://www.gnu.org/licenses/gpl-3.0.html
Author URI: https://mikejolley.com
Text Domain: wp-page-load-stats
Domain Path: /languages/
Note: Dies ist eine inoffizielle Version des WP Page Load Stats Plugins, bereitgestellt von [Ditmar Winkler].
*/
/**
* WP_Page_Load_Stats Klasse
*/
class WP_Page_Load_Stats
{
/**
* Speichert den Namen der Option, in der Durchschnittswerte gespeichert werden.
* @var string
*/
private $average_option;
/**
* Initialisiert das Plugin
*/
public function __construct()
{
add_action("init", [$this, "init"]);
add_action("wp_head", [$this, "wp_head"]);
add_action("wp_footer", [$this, "wp_footer"]);
add_action("admin_head", [$this, "wp_head"]);
add_action("admin_footer", [$this, "wp_footer"]);
add_action("admin_enqueue_scripts", [$this, "enqueue"]);
add_action("wp_enqueue_scripts", [$this, "enqueue"]);
}
/**
* Initialisierungsfunktion.
*/
public function init()
{
$this->average_option = is_admin()
? "wp_pls_admin_load_times"
: "wp_pls_load_times";
load_plugin_textdomain(
"wp-page-load-stats",
false,
dirname(plugin_basename(__FILE__)) . "/languages/"
);
if (
isset($_GET["reset_wp_pls_stats"]) &&
$_GET["reset_wp_pls_stats"] == 1
) {
delete_option($this->average_option);
wp_safe_redirect(wp_get_referer());
exit();
}
}
/**
* JavaScript-Code ausgeben.
*/
public function output_js()
{
?>
<script type="text/javascript">
function wp_pls_hide() {
var wpplsDiv = document.getElementById('wp_pls');
wpplsDiv.style.display = 'none';
}
</script>
<?php
}
/**
* wp_head Funktion.
*/
public function wp_head()
{
$this->output_js();
}
/**
* wp_footer Funktion.
*/
public function wp_footer()
{
$this->display();
$this->output_page_load_time_js();
}
/**
* JavaScript-Code ausgeben für die Berechnung der Page Load Time.
*/
public function output_page_load_time_js()
{
?>
<script type="text/javascript">
var wpplsStart = performance.now();
window.addEventListener('load', function() {
var wpplsDiv = document.getElementById('wp_pls');
var wpplsEnd = performance.now();
var wpplsTime = (wpplsEnd - wpplsStart) / 1000;
var wpplsTimeRounded = Math.round(wpplsTime * 1000) / 1000;
var pageLoadTime = wpplsTimeRounded.toFixed(3).toString().replace('.', ',');
var pageLoadTimeElement = wpplsDiv.querySelector('.page-load-time');
pageLoadTimeElement.textContent = 'Page Load Time: ' + pageLoadTime + ' sec.';
});
</script>
<?php
}
/**
* enqueue Funktion.
*/
public function enqueue()
{
wp_enqueue_style("wp_pls-style", plugins_url("style.css", __FILE__));
}
/**
* Anzeigefunktion.
*/
public function display()
{
// Im administrativen Bereich (Dashboard) nicht anzeigen
if (is_admin()) {
return;
}
// Werte, die angezeigt werden sollen, abrufen
$query_count = get_num_queries();
$memory_usage = round(memory_get_usage() / 1024 / 1024, 2); // In MB umrechnen
$memory_peak_usage = round(memory_get_peak_usage() / 1024 / 1024, 2); // In MB umrechnen
$memory_limit = round(
$this->let_to_num(WP_MEMORY_LIMIT) / 1024 / 1024,
2
); // In MB umrechnen
$load_times = array_filter(
(array) get_option($this->average_option, [])
);
// Aktuelle Ladezeit abrufen
$timer_stop = timer_stop(0);
// Ladezeiten aktualisieren
$load_times[] = $timer_stop;
update_option($this->average_option, $load_times);
// Aktuelle Datenbankabfragezeit abrufen
global $wpdb;
$db_query_time = 0;
if (isset($wpdb->queries) && is_array($wpdb->queries)) {
foreach ($wpdb->queries as $query) {
$db_query_time += isset($query[1]) ? floatval($query[1]) : 0;
}
}
// Serververarbeitungszeit für die aktuelle Seite messen
$server_response_time = floatval($this->get_server_response_time());
// Gesamte Ladezeit der Seite abrufen (ohne Serverantwort)
$total_load_time_without_response = $this->get_total_page_load_time_without_response();
// Info anzeigen
?>
<div id="wp_pls">
<b>Leistungsmetriken im Blick</b>
<ul>
<li><?php echo sprintf(
__("Serverreaktion: %s ms.", "wp-page-load-stats"),
number_format_i18n($server_response_time * 1000, 3, ".", "")
); ?></li>
<li><?php printf(
__("DB-Abfrage: %s sec.", "wp-page-load-stats"),
number_format_i18n($db_query_time, 3)
); ?></li>
<li><?php echo sprintf(
__("%s Abfragen in %s sec.", "wp-page-load-stats"),
$query_count,
$timer_stop,
3
); ?></li>
<li><?php echo sprintf(
__("Serverantwort: %s sec.", "wp-page-load-stats"),
number_format_i18n(
$total_load_time_without_response - $server_response_time,
3
)
); ?></li>
<li class="page-load-time"></li>
<hr style="margin: 5px; width: 100%" />
<li><?php echo sprintf(
__("Mem Usage: %s MB (%s).", "wp-page-load-stats"),
str_replace(".", ",", $memory_usage),
number_format(($memory_usage / $memory_limit) * 100, 2, ",", ".") . "%"
); ?></li>
</ul>
<div class="actions">
<a onclick="wp_pls_hide()" href="javascript:void(0);">×</a>
<a class="reset" href="<?php echo add_query_arg(
"reset_wp_pls_stats",
1
); ?>">-</a>
</div>
</div>
<?php
}
/**
* Serverreaktionszeit für die aktuelle Seite messen.
*
* @return float Serverreaktionszeit in Millisekunden.
*/
private function get_server_response_time()
{
$start_time = hrtime(true);
// Hier wird dein Code ausgeführt
$end_time = hrtime(true);
// Serverreaktionszeit in Sekunden mit höherer Genauigkeit berechnen
$response_time_seconds = ($end_time - $start_time) / 1e9;
// Serverreaktionszeit in Millisekunden umrechnen
$response_time_ms = $response_time_seconds * 1000;
// Das Ergebnis wird mit 8 Dezimalstellen formatiert
return sprintf("%.8f", $response_time_ms);
}
/**
* Gesamte Ladezeit der Seite abrufen (ohne Serverantwort).
*
* @return float Gesamte Ladezeit der Seite (ohne Serverantwort) in Sekunden.
*/
private function get_total_page_load_time_without_response()
{
$start_time = $_SERVER["REQUEST_TIME_FLOAT"];
// Warten, bis die Seite vollständig geladen ist, und die gesamte Ladezeit der Seite (ohne Serverantwort) abrufen
$total_load_time_without_response = microtime(true) - $start_time;
return $total_load_time_without_response;
}
/**
* Funktion zur Umwandlung der php.ini-Notation für Zahlen (z. B. '2M') in eine Gleitkommazahl (float).
*
* @param string $size Die Größe im php.ini-Format, z. B. '2M', '64K', etc.
* @return float Die umgewandelte Größe als Gleitkommazahl in Megabyte.
*/
public function let_to_num($size)
{
$size = trim($size);
$last = strtolower($size[strlen($size) - 1]);
$size = (float) $size;
switch ($last) {
case "g":
$size *= 1024;
case "m":
$size *= 1024;
case "k":
$size *= 1024;
}
return $size;
}
}
$WP_Page_Load_Stats = new WP_Page_Load_Stats();
?>
Option: Anzeigenfeld auch im Dashboard
Diese Anpassung betrifft beide Versionen. Wenn das Anzeigenfeld im Frontend für Besucher sowie für Administratoren und angemeldete Benutzer im administrativen Bereich sichtbar sein soll, ist folgender in grün hinterlegte Code zu entfernen:
/**
* Anzeigefunktion. / display function.
*/
public function display() {
// Im administrativen Bereich (Dashboard) nicht anzeigen
if (is_admin()) {
return;
}
// Der Rest der Funktion bleibt unverändert
// ...
Option: Anzeigenfeld nur für Admin
Wenn das Anzeigenfeld nur für den Administrator sichtbar sein soll und zusätzlich nur im Frontend, also auf der Website selbst, und nicht im Administrationsbereich:
// Nur für den Administrator im Frontend anzeigen
if (is_admin() || !current_user_can('administrator')) {
return;
}
Den obigen Code kopieren und in der Datei folgendem Bereich austauschen:
/**
* Anzeigefunktion. / display function.
*/
public function display() {
// Nur für den Administrator im Frontend anzeigen
if (is_admin() || !current_user_can('administrator')) {
return;
}
// Der Rest der Funktion bleibt unverändert
// ...
Das präsentiert die 'Interne Version' mit 9 Metriken von WP Page Load Stats. Diese Version ab PHP 7+ enthält spezielle Anpassungen und Änderungen, die sie zu einer ausgezeichneten Option machen, um die Leistung deiner Website zu überwachen.
Der Unterschied zum WP Page Load Stats 7 liegt darin, dass die 'Rendertime' und die 'Time To Interactive' inkludiert sind. Da diese drei Messwerte sehr nahe beieinander befinden, haben wir hier vier Dezimalstellen festgelegt, um überhaupt Unterschiede erkennen zu können. Dies kann hilfreich sein, um das Umfeld der 'Page Load Time' besser zu verstehen.
<?php
/*
Plugin Name: WP Page Load Stats 9 (Interne Version)
Plugin URI: https://wegerl.at/wp-page-load-stats-7/
Description: Zeigt 9 Leistungsmetriken im Footer an: Serverreaktionszeit, Gesamtzeit für Datenbankabfragen, Gesamtzahl und Gesamtzeit der Datenabfragen, Serverarbeitungszeit (Serverantwort), Rendertime, Time To Interactive, Gesamtladezeit der Seite und Speichernutzung (Memory Usage).
Erfordert PHP 7.4
Version: 1.0.2
Author: Mike Jolley (Originalversion), [Ditmar Winkler] (Interne Version)
License: GPLv3
License URI: http://www.gnu.org/licenses/gpl-3.0.html
Author URI: https://mikejolley.com
Text Domain: wp-page-load-stats
Domain Path: /languages/
Note: Dies ist eine inoffizielle Version des WP Page Load Stats Plugins, bereitgestellt von [Ditmar Winkler].
*/
/**
* WP_Page_Load_Stats Klasse
*/
class WP_Page_Load_Stats
{
/**
* Speichert den Namen der Option, in der Durchschnittswerte gespeichert werden.
* @var string
*/
private $average_option;
/**
* Initialisiert das Plugin
*/
public function __construct()
{
add_action("init", [$this, "init"]);
add_action("wp_head", [$this, "wp_head"]);
add_action("wp_footer", [$this, "wp_footer"]);
add_action("admin_head", [$this, "wp_head"]);
add_action("admin_footer", [$this, "wp_footer"]);
add_action("admin_enqueue_scripts", [$this, "enqueue"]);
add_action("wp_enqueue_scripts", [$this, "enqueue"]);
}
/**
* Initialisierungsfunktion.
*/
public function init()
{
$this->average_option = is_admin()
? "wp_pls_admin_load_times"
: "wp_pls_load_times";
load_plugin_textdomain(
"wp-page-load-stats",
false,
dirname(plugin_basename(__FILE__)) . "/languages/"
);
if (
isset($_GET["reset_wp_pls_stats"]) &&
$_GET["reset_wp_pls_stats"] == 1
) {
delete_option($this->average_option);
wp_safe_redirect(wp_get_referer());
exit();
}
}
/**
* wp_head Funktion.
*/
public function wp_head()
{
echo "<script type='text/javascript'>
function wp_pls_hide(){
var wpplsDiv = document.getElementById('wp_pls');
wpplsDiv.style.display = 'none';
}
</script>";
}
/**
* wp_footer Funktion.
*/
public function wp_footer()
{
$this->display();
$this->output_js();
$this->output_render_time_js();
$this->output_tti_js();
$this->output_page_load_time_js();
}
/**
* JavaScript-Code ausgeben zur Messung der Rendertime.
*/
public function output_render_time_js()
{
?>
<script type="text/javascript">
var renderStartTime = performance.now();
// Hier können Sie Ihre Webseite-Inhalte rendern lassen (z.B. durch das Laden von Bildern, CSS, JavaScript usw.)
window.addEventListener('load', function() {
var renderEndTime = performance.now();
var renderTime = renderEndTime - renderStartTime;
var renderTimeInSeconds = renderTime / 1000; // Umrechnung von Millisekunden in Sekunden
var decimalSeparator = (1.1).toLocaleString().substring(1, 2); // Ermitteln des Dezimalzeichens
var wpplsDiv = document.getElementById('wp_pls');
var renderTimeElement = wpplsDiv.querySelector('.render-time');
renderTimeElement.textContent = 'Rendertime: ' + renderTimeInSeconds.toLocaleString(undefined, { minimumFractionDigits: 4, maximumFractionDigits: 4 }).replace('.', decimalSeparator) + ' sec';
});
</script>
<?php
}
/**
* JavaScript-Code ausgeben zur Messung der Time To Interactive (TTI).
*/
public function output_tti_js()
{
?>
<script type="text/javascript">
var ttiStart = performance.now();
// Fügen Sie hier den Code ein, der die Seite interaktiv macht (z.B. das Laden von JavaScript, das Initialisieren von Interaktionselementen usw.)
window.addEventListener('load', function() {
var ttiEnd = performance.now();
var ttiTime = ttiEnd - ttiStart;
var decimalSeparator = (1.1).toLocaleString().substring(1, 2); // Ermitteln des Dezimalzeichens
var wpplsDiv = document.getElementById('wp_pls');
var ttiElement = wpplsDiv.querySelector('.tti');
ttiElement.textContent = 'Time To Interac.: ' + (ttiTime / 1000).toLocaleString(undefined, { minimumFractionDigits: 4, maximumFractionDigits: 4 }).replace('.', decimalSeparator) + ' sec';
});
</script>
<?php
}
/**
* JavaScript-Code ausgeben für die Berechnung der Page Load Time.
*/
public function output_page_load_time_js()
{
?>
<script type="text/javascript">
var wpplsStart = performance.now();
window.addEventListener('load', function() {
var wpplsDiv = document.getElementById('wp_pls');
var wpplsEnd = performance.now();
var wpplsTime = (wpplsEnd - wpplsStart) / 1000;
// Formatierung der Dezimalstelle im JavaScript-Code
var pageLoadTime = wpplsTime.toLocaleString(undefined, { minimumFractionDigits: 4, maximumFractionDigits: 4 }).replace('.', ',');
var pageLoadTimeElement = wpplsDiv.querySelector('.page-load-time');
pageLoadTimeElement.textContent = 'Page Load Time: ' + pageLoadTime + ' sec.';
});
</script>
<?php
}
/**
* enqueue Funktion.
*/
public function enqueue()
{
wp_enqueue_style("wp_pls-style", plugins_url("style.css", __FILE__));
}
/**
* Anzeigefunktion.
*/
public function display()
{
// Werte, die angezeigt werden sollen, abrufen
$query_count = get_num_queries();
$memory_usage = round(memory_get_usage() / 1024 / 1024, 2); // In MB umrechnen
$memory_peak_usage = round(memory_get_peak_usage() / 1024 / 1024, 2); // In MB umrechnen
$memory_limit = round(
$this->let_to_num(WP_MEMORY_LIMIT) / 1024 / 1024,
2
); // In MB umrechnen
$load_times = array_filter(
(array) get_option($this->average_option, [])
);
// Aktuelle Ladezeit abrufen
$timer_stop = timer_stop(0);
// Ladezeiten aktualisieren
$load_times[] = $timer_stop;
update_option($this->average_option, $load_times);
// Aktuelle Datenbankabfragezeit abrufen
global $wpdb;
$db_query_time = 0;
if (isset($wpdb->queries) && is_array($wpdb->queries)) {
foreach ($wpdb->queries as $query) {
$db_query_time += isset($query[1]) ? floatval($query[1]) : 0;
}
}
// Serververarbeitungszeit für die aktuelle Seite messen
$server_response_time = floatval($this->get_server_response_time());
// Gesamte Ladezeit der Seite abrufen (ohne Serverantwort)
$total_load_time_without_response = $this->get_total_page_load_time_without_response();
// Info anzeigen
?>
<div id="wp_pls">
<b>Leistungsmetriken im Blick</b>
<ul>
<li>
<?php echo sprintf(
__("Serverreaktion: %s ms.", "wp-page-load-stats"),
number_format_i18n($server_response_time * 1000, 3, ".", "")
); ?>
</li>
<li>
<?php printf(
__("DB-Abfrage: %s sec.", "wp-page-load-stats"),
number_format_i18n($db_query_time, 3)
); ?>
</li>
<li>
<?php echo sprintf(
__("%s Abfragen in %s sec.", "wp-page-load-stats"),
$query_count,
$timer_stop,
3
); ?>
</li>
<li>
<?php echo sprintf(
__("Serverantwort: %s sec.", "wp-page-load-stats"),
number_format_i18n(
$total_load_time_without_response - $server_response_time,
3
)
); ?>
</li>
<li class="render-time">Rendertime:</li>
<li class="tti">Time To Interactive:</li>
<li class="page-load-time"></li>
<hr style="border-color: #D2DBF4; margin: 5px 0; width: 100%;" />
<li>
<?php echo sprintf(
__("Mem Usage: %s MB (%s).", "wp-page-load-stats"),
str_replace(".", ",", $memory_usage),
number_format(($memory_usage / $memory_limit) * 100, 2, ",", ".") .
"%"
); ?>
</li>
</ul>
<div class="actions">
<a onclick="wp_pls_hide()" href="javascript:void(0);">×</a>
<a class="reset" href="<?php echo add_query_arg(
"reset_wp_pls_stats",
1
); ?>">-</a>
</div>
</div>
<?php
}
/**
* Serverantwortzeit für die aktuelle Seite messen.
*
* @return float Serverantwortzeit in Sekunden.
*/
private function get_server_response_time()
{
$start_time = hrtime(true);
// Hier wird dein Code ausgeführt
$end_time = hrtime(true);
// Serverreaktionszeit in Sekunden mit höherer Genauigkeit berechnen
$response_time_seconds = ($end_time - $start_time) / 1e9;
// Serverreaktionszeit in Millisekunden umrechnen
$response_time_ms = $response_time_seconds * 1000;
// Das Ergebnis wird mit 8 Dezimalstellen formatiert
return sprintf("%.8f", $response_time_ms);
}
/**
* Gesamte Ladezeit der Seite abrufen (ohne Serverantwort).
*
* @return float Gesamte Ladezeit der Seite (ohne Serverantwort) in Sekunden.
*/
private function get_total_page_load_time_without_response()
{
$start_time = $_SERVER["REQUEST_TIME_FLOAT"];
// Warten, bis die Seite vollständig geladen ist, und die gesamte Ladezeit der Seite (ohne Serverantwort) abrufen
$total_load_time_without_response = microtime(true) - $start_time;
return $total_load_time_without_response;
}
/**
* Funktion zur Umwandlung der php.ini-Notation für Zahlen (z. B. '2M') in eine Gleitkommazahl (float).
*
* @param string $size Die Größe im php.ini-Format, z. B. '2M', '64K', etc.
* @return float Die umgewandelte Größe als Gleitkommazahl in Megabyte.
*/
public function let_to_num($size)
{
$size = trim($size);
$last = strtolower($size[strlen($size) - 1]);
$size = (float) $size;
switch ($last) {
case "g":
$size *= 1024;
case "m":
$size *= 1024;
case "k":
$size *= 1024;
}
return $size;
}
/**
* JavaScript-Code ausgeben.
*/
public function output_js()
{
?>
<script type="text/javascript">
function wp_pls_hide() {
var wpplsDiv = document.getElementById('wp_pls');
wpplsDiv.style.display = 'none';
}
</script>
<?php
}
}
$WP_Page_Load_Stats = new WP_Page_Load_Stats();
?>
WP Page Load Stats ab PHP 7+ (Inoffizielle Version)
Zusätzlich bieten wir auch die aktualisierte Version vom originär 'WP Page Load Stats' an, die speziell für PHP 7.4+ optimiert ist und eine verbesserte Leistung bietet.
Wenn eine Webseite solide Leistungsmetriken aufweist und bereits verschiedene Optimierungsschritte unternommen wurden, ist es ratsam, sich vor allem auf die tatsächliche Benutzererfahrung zu fokussieren. Eine Webseite, die für Besucher schnell lädt und eine gute Performance bietet, ist ein positiver Indikator, unabhängig von den Ergebnissen unterschiedlicher Testdienste. Diese Dienste können zu verschiedenen Ergebnissen kommen, da sie jeweils unterschiedliche Parameter und Algorithmen verwenden.
Leistung im Blick, Benutzererfahrung im Herzen.
Der Beitrag wurde mit fachlicher Unterstützung erstellt.
Schaffe mit WordPress und Advanced Editor schöne Websites. Hier ist für dich, euch eine leicht lesbare und freundliche Anleitung.
Hinweis: Unsere Website verwendet ausschließlich funktionale Cookies und setzt keine Cookies von Drittanbietern.
Aber hallo!
– zur Begrüßung eine Rundfrage?
🧡 … das so zum Zeit entschleunigen.
Technische Herausforderungen sind Teil des Website-Betriebs. Wir interessieren uns dafür, wie du mit solchen Problemen umgehst. Bitte teile uns mit, ob du bereits technische Probleme auf deiner Website hattest und wie du sie gelöst hast.
Wird geladen ...
Während deines Besuchs kann es neben informativen Ergebnissen auch zu Klangeffekten kommen, um bestimmte Elemente hervorzuheben. – Viel Spaß beim Erkunden!
Pop-up
Das zur Umfrage ist von WP-Polls und das Pop-up ist von Boxzilla.
