Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets
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.
Viele von uns wissen, wie wichtig es ist, die Ladezeit und die Leistung einer Website im Auge zu behalten. 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 Plugin vollends seine Funktionalität, da der Code nicht mehr den neuesten PHP-Standards entsprach.
WP Page Load Stats – Einblicke in Website-Performance für Webmaster und Besucher.
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.
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' und 'Interne 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 oder auch 9)' geschaffen, die wir hier zur Verfügung stellen.
So gehst du vor,
um das Plug-in zu verwenden
Gehe über "Plug-ins" 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".
Leistungsmetriken (Interne Version)
Hier bieten wir eine leicht abgeänderte Version der Metriken von WP Page Load Stats an. Die Metriken umfassen zum Beispiel:
- Serverreaktion: 0,200 sec.
- DB-Abfrage: 0,138 sec.
- 355 Abfragen
- in 0,293 sec.
- Serverantwort: 0,294 sec.
- Page Load Time: 1,121 sec.
- Mem Usage: 21,08 MB (8,23 %).
- "Serverreaktion": 0,200 sec.
- 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 benötigt, 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.
Die Serverreaktion hier auf dieser Website beträgt konstant etwa 0,200 Sekunden. Um festzustellen, ob diese Zeit überhaupt gemessen wird, sollten die Dezimalstellen erhöht werden. Diese Anpassung kann im Code vorgenommen werden.
- "DB-Abfrage": 0,138 Sekunden
- Das ist die Datenbankabfragezeit. Diese Metrik zeigt die Effizienz der Datenbanknutzung an. Der Wert gibt die Gesamtzeit an, die benötigt wurde, 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.
Hinweis: Es ist möglich, dass die Datenbankabfragezeit nicht angezeigt wird, wenn die Seite sehr schnell geladen wird. Dies liegt daran, dass die Messung der Datenbankabfragezeit in der Regel auf dem Zeitpunkt basiert, wenn die Seite generiert wird und Datenbankabfragen durchgeführt werden. Wenn die Seite jedoch sehr schnell geladen wird, können diese Datenbankabfragen bereits abgeschlossen sein, bevor die Messung beginnt. In diesem Fall wäre selbst eine Erhöhung der Dezimalstellen zwecklos. Daher könnte dann diese Zeile aus dem Code entfernt werden.- 355 "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 wichtiger 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 wichtige Metrik zu analysieren und Optimierungspotenzial zu identifizieren.
- …in 0,293 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
- "Serverantwort": 0,294 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.
- "Page Load Time": 1,121 sec.
- Die Page Load Time ist die Gesamtzeit, die benötigt wurde, um die gesamte Webseite einschließlich aller Ressourcen und Daten zu laden. Hierbei spielt das Rendering eine entscheidende Rolle, da es ein wichtiger Prozess ist, der 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.
- Mem Usage: 21,08 MB (8,23 %)
- 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.
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 bin ich 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 jedoch mithilfe von Pingdom eingesehen werden. Sollte das Ergebnis (1) nicht wie erwartet angezeigt werden, da es anscheinend während des Messzeitraums nicht vollständig generiert wurde:
… dann klicke auf "Ergebnis teilen" (2). Die Ergebnisse sind dann per E-Mail abrufbar. Zum Beispiel:
… The web page took 1701 ms to load, used 159 requests, and weighed in at 7.9 MB . The Google Page Speed performance grade for this web page is 83/100.
Zusammenfassend können Webanalysetools wie https://tools.pingdom.com/ genutzt werden, um die Seite zu analysieren und wichtige Leistungsmetriken zu ermitteln.
Query Monitor vs. WP Page Load Stats
Vier Metriken sind dieselben wie die, die auch das Plug-in Query Monitor in der Headerzeile anzeigt. Diese Metriken sind die 'Abfragen' (Gesamtzahl der Datenabfragen) zusammen mit der Gesamtzeit der Datenabfragen, der DB-Abfrage und der verwendete Speicher, wenn auch in anderer Reihenfolge. Es ist jedoch 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.
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.
Anhaltspunkte
'WP Page Load Stats 9' (Interne Version)
Es wäre hier dann noch die 'Rendertime' und die 'Time To Interactive' im Angebot. Diese Werte ziehen fast gleich mit der 'Page Load Time', darum haben wir diese zusammen in separaten Code gepackt im Namen 'WP Page Load Stats 9', das ist also mit 9 Metriken. Anmkerkung: Die Kommastellen der beiden sind über eine Millisecunde (1 Tausendstelsekunde: 0,001) hinaus auf vier erhöht, um meist überhaupt einen Unterschied messen zu können. Das kann denn zum Ausprobieren mal ganz interessant sein.
9 Leistungsmetriken im Blick. OT: Wie die ZEIT vergeht –. Je älter man wird. Bild, Alexas_Fotos, Audio 'Alter Wecker' (old_alarm_clock_ticking) so 15 sec. 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.
Abänderung der Texte und Optionen
Einstellungen wie Sprache und sonstiges sind nicht vorhanden. Für die individuelle Anpassung der Texte kann jeder Benutzer leicht die Dateiwp-page-load-stats.phpbearbeiten und die gewünschten Texte direkt in denli-Elementen festlegen. Diese Anpassungen können in der Datei unter dem Abschnitt [// Info anzeigen] vorgenommen werden. Das letzteli-Element mit der Klassepage-load-timeerfordert eine separate Anpassung des Textes und des Dezimalzeichens, was im JavaScript-Code auch der Datei/wp-page-load-stats.phpzu tun ist.
Zusätzliche Informationen zu den Optionen ist nach dem Code für 'WP Page Load Stats 7' zu finden.
Hinweis: 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.cssdes Plug-ins.WP Page Load Stats 7 ab PHP 7+
(Interne Version, 7 Metriken)
7 Leistungsmetriken im Blick Das ist die 'Interne Version' mit 7 Metriken von 'WP Page Load Stats' präsentiert. 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.
WP Page Load Stats 7 Metriken (Interne Version)
/wp-page-load-stats.php<?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 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: http://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() { 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_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() { // 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 sec.', 'wp-page-load-stats' ), number_format_i18n( $server_response_time, 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="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 } /** * Serverreaktionszeit für die aktuelle Seite messen. * * @return float Serverreaktionszeit in Sekunden. */ private function get_server_response_time() { $start_time = microtime(true); // Dummy-Berechnung durchführen, um die Serverreaktionszeit zu messen usleep(200000); // Hier wird eine Verzögerung von 200 Millisekunden (200000 Mikrosekunden) hinzugefügt $end_time = microtime(true); // Serverreaktionszeit in Sekunden berechnen $response_time = $end_time - $start_time; return $response_time; } /** * 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 nur im Frontend
Folgendes ist hier für beide Versionen anwendbar. Wenn das Anzeigenfeld im Frontend für Besucher, Administratoren und angemeldete Benutzer sichtbar sein soll, aber nicht im administrativen Bereich:
// Im administrativen Bereich (Dashboard) nicht anzeigen if (is_admin()) { return; }Code kopieren und in der Datei folgendem Bereich einfügen:
/** * 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; }Code kopieren und in der Datei folgendem Bereich einfügen:
/** * 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 // ...Option:
Dezimalzeichen von Komma zu PunktIm Anzeigenfled die Dezimalzeichen von Komma zu Punkt? Durch die Funktion
number_format_i18nin WordPress ist eine internationale Formatierung für Zahlen möglich. Dasi18nin 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.Wenn du jedoch im Anzeigefeld das Dezimalzeichen statt Komma lieber als Punkt haben möchtest, dann ist nach
// Info anzeigenfolgendes auszutauschen:<ul> <li><?php echo sprintf( __( '%s Abfragen in %s sec.', 'wp-page-load-stats' ), $query_count, str_replace( ',', '.', $timer_stop ) ); ?></li> <li><?php printf( __( 'DB-Abfrage: %s sec.', 'wp-page-load-stats' ), number_format( $db_query_time, 3, '.', '' ) ); ?></li> <li><?php echo sprintf( __( 'Speicher: %s MB (%s).', 'wp-page-load-stats' ), str_replace(',', '.', $memory_usage), number_format( ( $memory_usage / $memory_limit ) * 100, 2, '.', '' ) . '%' ); ?></li> <li><?php echo sprintf( __( 'Serverantwort: %s sec.', 'wp-page-load-stats' ), number_format( $server_response_time, 4, '.', '' ) ); ?></li> <li><?php echo sprintf( __( 'Serverarbeit: %s sec.', 'wp-page-load-stats' ), number_format( $total_load_time_without_response - $server_response_time, 3, '.', '' ) ); ?></li> <li class="page-load-time"></li> <!-- Dezimalzeichen und Text ist weiter unterhalb beim JavaScript-Code --> </ul>Folge des obigen Codes ist, dass das Element
<li class="page-load-time"></li>Dezimalzeichen und Text unterhalb beim JavaScript-Code separat anzupassen sind. Das JavaScript übermittelt das Dezimalzeichen und den Text über die Class in dasli-Element. Somit ist das Beispiel wie folgt anzupassen:var pageLoadTime = wpplsTimeRounded.toFixed(3).toString().replace(',', '.'); var pageLoadTimeElement = wpplsDiv.querySelector('.page-load-time'); pageLoadTimeElement.textContent = 'Page Load Time: ' + pageLoadTime + ' sec.';WP Page Load Stats 9 ab PHP 7+
(Interne Version, 9 Metriken)
9 Leistungsmetriken im Blick Das ist die 'Interne Version' mit 9 Metriken von WP Page Load Stats präsentiert. 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 sich 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.
WP Page Load Stats 9 Metriken (Interne Version)
/wp-page-load-stats.php<?php /* Plugin Name: WP Page Load Stats 9 (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), 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) Author URI: http://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 sec.', 'wp-page-load-stats' ), number_format_i18n( $server_response_time, 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 = microtime(true); // Dummy-Berechnung durchführen, um die Serverantwortzeit zu messen usleep(200000); // Hier wird eine Verzögerung von 200 Millisekunden (200000 Mikrosekunden) hinzugefügt $end_time = microtime(true); // Serverantwortzeit in Sekunden berechnen $response_time = $end_time - $start_time; return $response_time; } /** * 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(); ?>Und der Code für das Dezimalzeichen als Punkt oder Komma individuell:
public function output_render_time_js($decimalSeparator = '.') { ?> <script type="text/javascript"> var renderStartTime = performance.now(); window.addEventListener('load', function() { var renderEndTime = performance.now(); var renderTime = renderEndTime - renderStartTime; var renderTimeInSeconds = renderTime / 1000; var wpplsDiv = document.getElementById('wp_pls'); var renderTimeElement = wpplsDiv.querySelector('.render-time'); renderTimeElement.textContent = 'Rendertime: ' + renderTimeInSeconds.toFixed(6).replace(',', '.', '<?php echo $decimalSeparator; ?>') + ' sec'; }); </script> <?php } public function output_tti_js($decimalSeparator = '.') { ?> <script type="text/javascript"> var ttiStart = performance.now(); window.addEventListener('load', function() { var ttiEnd = performance.now(); var ttiTime = ttiEnd - ttiStart; var wpplsDiv = document.getElementById('wp_pls'); var ttiElement = wpplsDiv.querySelector('.tti'); ttiElement.textContent = 'Time To Interactive: ' + (ttiTime / 1000).toFixed(6).replace(',', '.', '<?php echo $decimalSeparator; ?>') + ' sec'; }); </script> <?php }
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.
WP Page Load Stats (Inoffizielle Version)
/wp-page-load-stats.php
<?php
/*
Plugin Name: WP Page Load Stats (Inoffizielle Version)
Plugin URI originär: https://github.com/mikejolley/WP-Page-Load-Stats
Description: Display memory, page load time, average load time and query count in the footer. Requires PHP 7.4+
Version: 1.0.2
Author: Mike Jolley (Originalversion), [Ditmar Winkler] (Inoffizielle Version)
Author URI: http://mikejolley.com / [https://wegerl.at/wp-page-load-stats] (Inoffizielle Version)
Text Domain: wp-page-load-stats
Domain Path: /languages/
Note: Dies ist eine inoffizielle Version des WP Page Load Stats Plugins, die von [Ditmar Winkler] bereitgestellt wird. – Für offizielle Unterstützung und Updates besuchen Sie bitte die GitHub-Seite des Autors Mike Jolley.
*/
/**
* WP_Page_Load_Stats Class
*/
class WP_Page_Load_Stats {
/**
* Stores the name of the option where averages get saved.
* @var string
*/
private $average_option;
/**
* Gets things started
*/
public function __construct() {
add_action( 'init', array( $this, 'init' ) );
add_action( 'wp_head', array( $this, 'wp_head' ) );
add_action( 'wp_footer', array( $this, 'wp_footer' ) );
add_action( 'admin_head', array( $this, 'wp_head' ) );
add_action( 'admin_footer', array( $this, 'wp_footer' ) );
add_action( 'admin_enqueue_scripts', array( $this, 'enqueue' ) );
add_action( 'wp_enqueue_scripts', array( $this, 'enqueue' ) );
}
/**
* init function.
*/
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 function.
*/
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 function.
*/
public function wp_footer() {
$this->display();
$this->output_js();
}
/**
* enqueue function.
*/
public function enqueue() {
wp_enqueue_style( 'wp_pls-style', plugins_url('style.css', __FILE__) );
}
/**
* display function.
*/
public function display() {
// Get values we're displaying
$timer_stop = timer_stop(0);
$query_count = get_num_queries();
$memory_usage = round( memory_get_usage() / 1024 / 1024, 2 ); // Convert to MB
$memory_peak_usage = round( memory_get_peak_usage() / 1024 / 1024, 2 ); // Convert to MB
$memory_limit = round( $this->let_to_num( WP_MEMORY_LIMIT ) / 1024 / 1024, 2 ); // Convert to MB
$load_times = array_filter( (array) get_option( $this->average_option, array() ) );
$load_times[] = $timer_stop;
// Update load times
update_option( $this->average_option, $load_times );
// Get average
if ( sizeof( $load_times ) > 0 ) {
$average_load_time = round( array_sum( $load_times ) / sizeof( $load_times ), 4 );
}
// Display the info
?>
<div id="wp_pls">
<ul>
<li><?php printf( __( '%s Abfragen in %s Secunden.', 'wp-page-load-stats' ), $query_count, $timer_stop ); ?></li>
<li><?php printf( __( 'Im Mittel %s (%s Rd.).', 'wp-page-load-stats' ), $average_load_time, sizeof( $load_times ) ); ?></li>
<li><?php printf( __( '%s von %s MB (%s) Verwendung.', 'wp-page-load-stats' ), $memory_usage, $memory_limit, round( ( $memory_usage / $memory_limit ), 2 ) * 100 . '%' ); ?></li>
<li><?php printf( __( 'Max. Speichernutzung %s MB.', 'wp-page-load-stats' ), $memory_peak_usage ); ?></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
}
/**
* let_to_num function.
*
* This function transforms the php.ini notation for numbers (like '2M') to an integer
*
* @param $size
* @return int
*/
public function let_to_num( $size ) {
$l = substr( $size, -1 );
$ret = substr( $size, 0, -1 );
switch( strtoupper( $l ) ) {
case 'P':
$ret *= 1024;
case 'T':
$ret *= 1024;
case 'G':
$ret *= 1024;
case 'M':
$ret *= 1024;
case 'K':
$ret *= 1024;
}
return $ret;
}
/**
* Output the JavaScript code.
*/
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: Das langersehnte Update!
Von Zahlen zur Erfahrung: Die wahre Performance
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.
Aktualisiert im Jahr 2023-September
