WordPress Hooks sind eines der wichtigsten Werkzeuge, die man im Arsenal eines WordPress Entwicklers haben sollte. Sie sind die Grundlage für die Entwicklung von WordPress Plugins und Themes. Du kannst die vielen eingebauten Hooks von WordPress benutzen, um dich mit deinem eigenen Code in den WordPress Core ‚einzuklinken‘ und etwas zu tun oder zu verändern.
Es gibt zwei Arten von WordPress-Hooks: Aktionen und Filter. Hooks sind so weit verbreitet, dass sogar der WordPress Core selbst sie ausgiebig nutzt. WordPress beinhaltet auch eine Möglichkeit für dich, deine eigenen Hooks zu definieren, so dass sich andere Entwickler in deinen Code einklinken können.

Zu lernen, wie Aktionen, Filter und benutzerdefinierte Hooks funktionieren, ist essentiell, um die Entwicklung von WordPress zu beherrschen.

Die erste Hälfte dieses Artikels behandelt die Grundlagen der WordPress-Hooks und erklärt anhand mehrerer Beispiele, wie sie funktionieren. In der zweiten Hälfte lernst du, wie du Hooks benutzen kannst, um WordPress anzupassen, deine eigenen Hooks zu erstellen und sie zu benutzen, um deine eigenen erweiterbaren Plugins zu erstellen.

Klingt aufregend? Lass uns loslegen!

Was sind WordPress Hooks?

Eine WordPress-Seite wird durch Tonnen von Funktionen und Datenbankabfragen zusammengestellt. Der WordPress-Kern, Plugins und das Theme arbeiten zusammen, um die Seitenelemente wie Text, Bilder, Skripte und Stile auszugeben. Sobald sie vollständig zusammengesetzt sind, setzt der Browser sie alle zusammen und rendert die Seite.

WordPress Hooks erlauben es dir, dich an bestimmten Punkten in diesen Erstellungsprozess ‚einzuklinken‘ und deinen eigenen Code auszuführen. Die Hauptfunktion von Hooks ist es, dir zu erlauben, WordPress zu verändern oder Funktionen hinzuzufügen, ohne die Kerndateien zu berühren.

Hooks werden dir helfen WordPress mit deinem eigenen Code zu erweitern

Hooks werden dir helfen WordPress mit deinem eigenen Code zu erweitern

Die WordPress Plugin API steuert die Funktionalität von WordPress Hooks. Du verwendest Hooks, indem du bestimmte WordPress-Funktionen, Hook-Funktionen genannt, an bestimmten Stellen während der WordPress-Laufzeit aufrufst.

Mit Hilfe von Hook-Funktionen kannst du deinen eigenen Code innerhalb einer Callback-Funktion bündeln und ihn mit jedem beliebigen Hook registrieren lassen. Einmal registriert, läuft dieser Callback überall dort, wo sich der Hook befindet, und erlaubt es dir, die Standard WordPress Funktionen zu erweitern oder zu ersetzen.

Die Position des Hook im Code-Ausführungsprozess ist ein wichtiger Faktor. Mehr über seine Bedeutung erfährst du in den kommenden Abschnitten.

Lasst euch von #webdev mit dieser Anleitung für WordPress Hooks begeistern. ⚡️Click to Tweet

Zwei Arten von WordPress Hooks: Aktionen und Filter

WordPress enthält zwei Arten von Hooks, die Aktionen und Filter genannt werden. Mit Aktionen kannst du an bestimmten vordefinierten Punkten in der WordPress Laufzeit etwas tun, während du mit Filtern alle von WordPress verarbeiteten Daten verändern und zurückgeben kannst.

Aktionen werden im Code von WordPress definiert als:

do_action( 'action_name', [optional_arguments] );

Der action_name string ist der Name der Aktion. Du kannst die [optional_arguments] Variable angeben, um zusätzliche Argumente an die Callback-Funktion zu übergeben. Wenn dieses Feld nicht angegeben wird, dann ist sein Standardwert leer.

Beispiel: Die Aktion do_action( 'wp_head' ) kann eingehängt werden, um jedes Mal, wenn WordPress den Header der Webseite verarbeitet, eigenen Code auszuführen. Diese Aktion hat keine weiteren Argumente.

Filter werden im Code von WordPress definiert als:

apply_filters( 'filter_name', 'value_to_be_filtered', [optional_arguments] );

Der filter_name string ist der Name des Filters, die Variable value_to_be_filtered ist der Wert, der gefiltert und zurückgegeben werden muss, und die Variable [optional_arguments] kann zusätzliche Argumente übergeben, genau wie bei Aktionen.

Beispiel: Der apply_filters( 'admin_footer_text' , string $text ) Filter kann eingehakt werden, um den in der Fußzeile des Administrators angezeigten Text zu verändern. Ab WordPress 5.4 zeigt sein Standardwert in der Fußzeile des Adminbereichs den Satz Danke, dass du mit WordPress erstellt hast.

Wie du dich in Aktionen und Filter einklinken kannst, erfährst du später an vielen Beispielen aus dem WordPress Core.

Sobald du dich eingeklinkt hast, kannst du deinen Code anweisen, etwas auf deiner Webseite zu tun oder anzupassen. Zum Beispiel kannst du Hooks verwenden, um nach dem Veröffentlichen eines Beitrags eine automatische E-Mail zu versenden, oder du kannst benutzerdefinierte Stylesheets laden, um das Aussehen deiner Webseite zu verändern.

WordPress Hooks helfen dir, mit deiner Webseite zu interagieren oder sie zu verändern

WordPress Hooks helfen dir, mit deiner Webseite zu interagieren oder sie zu verändern

Der einfachste Weg, Hooks zu verstehen, ist, sich vorzustellen, dass deine Webseite mit WordPress ein Haus baut.

Haken sind so ähnlich wie ein Kran, mit dem man Baugegenstände hin und her bewegt. Die Gegenstände, die übertragen werden, sind die Callback-Funktionen, die deinen eigenen Code enthalten. Diese Gegenstände (oder Funktionen) können dir helfen, das Haus zu bauen oder zu verändern.

Beispiel für das Einhaken in die 'wp_head'-Aktion in WordPress

Beispiel für das Einhaken in die ‚wp_head‘-Aktion in WordPress

Callback-Funktionen können reguläre PHP-Funktionen, standardmäßige WordPress-Funktionen oder von dir definierte benutzerdefinierte Funktionen sein.

Wir können bestimmte Gegenstände nur auf bestimmten Trägern transportieren, die an bestimmten Haken befestigt sind. So können Aktionen nur mit Aktionsfunktionen eingehängt werden. Ebenso können Filter nur mit Filterfunktionen eingehängt werden.

Es ist zwar mühsam, die Haken und Träger an einem Kran zu wechseln, aber WordPress macht es super einfach, indem es über 2.200 Arten von Standard-Hooks enthält.

WordPress 5.1 hat über 2200 native Hooks

WordPress 5.1 hat über 2200 native Hooks (Quelle: Adam Brown)

Du kannst Hooks finden, die über den WordPress Core verteilt sind und es dir ermöglichen, genau die Stelle anzutippen, an der du dich einklinken möchtest, um deinen eigenen Code auszuführen.

WordPress Hooks erlauben es dir, dich in den Seitenaufbau 'einzuklinken' ...und geben dir mehr Kontrolle über das, was du erstellst.⚡️Click to Tweet

Hooks vs Actionen vs Filter

Wie im WordPress Plugin Handbuch beschrieben:

„Hooks sind eine Möglichkeit für ein Stück Code, mit einem anderen Stück Code zu interagieren/modifizieren… Es gibt zwei Arten von Hooks: Aktionen und Filter“.

Es gibt eine weit verbreitete Inkonsistenz mit der Art und Weise, wie die Begriffe Hook, Aktion und Filter verwendet werden. Ein paar Tutorials und Anleitungen vermischen sie mit den damit verbundenen Funktionen. Ein Hauptgrund für diese Verwirrung liegt in der komplexen Natur der Funktionsweise von Hooks.

Selbst wenn du genau in den WordPress Core schaust, wirst du feststellen, dass es keinen großen Unterschied zwischen dem Hinzufügen von Aktionen und Filtern gibt. Hier ist der Quellcode für die add_action()-Funktion aus der wp-includes/plugin.php-Datei:

function add_action( $tag, $function_to_add, $priority = 10, $accepted_args = 1 ) {      
    return add_filter( $tag, $function_to_add, $priority, $accepted_args );
}

Die add_action()-Funktion ruft einfach die add_filter()-Funktion auf und gibt ihren Wert zurück. Warum? Weil beide im Grunde genommen auf die gleiche Weise funktionieren, bis auf einen Unterschied.

Die apply_filters()-Funktion gibt einen Wert zurück, der bestehende Datentypen verändern kann, während die do_action()-Funktion nichts zurückgibt (NULL-Wert in PHP).

Wenn du immer noch verwirrt bist, mach dir keine Sorgen! Wenn du die erste Hälfte dieses Artikels durchgelesen hast, wird alles klar sein. Wir werden uns an die offizielle WordPress-Codex-Terminologie halten, da sie klar, präzise und universell ist.

Macht euch vorerst mit der unten gezeigten Hook-Routine vertraut.

Die Hook-Routine: Hooks, Hook-Funktionen und Callback-Funktionen

Die Hook-Routine: Hooks, Hook-Funktionen und Callback-Funktionen

Lasst uns die Unterschiede zwischen Aktionen und Hooks auflösen.

WordPress Hooks
Actionen Filter
Aktionen werden verwendet, um benutzerdefinierte Funktionen an einem bestimmten Punkt während der Ausführung von WordPress Core auszuführen. Filter werden verwendet, um Daten zu modifizieren oder anzupassen, die von anderen Funktionen verwendet werden.
Actions are defined/created by the function do_action( 'action_name' ) im Code von WordPress definiert/erstellt. Filter werden durch die Funktion apply_filters( 'filter_name', 'value_to_be_filtered' ) im Code von WordPress definiert/erstellt.
Aktionen werden auch Action-Hooks genannt. Filter werden auch Filter-Hooks genannt.
Aktionen können nur mit Aktionsfunktionen eingehängt werden. Z.B. add_action(), remove_action(). Filter können nur mit Filterfunktionen eingehängt werden. Z.B add_filter(), remove_filter().
Action-Funktionen brauchen keine Argumente an ihre Callback-Funktionen zu übergeben. Filterfunktionen benötigen mindestens ein Argument für ihre Callback-Funktionen.
Action-Funktionen brauchen keine Argumente an ihre Callback-Funktionen zu übergeben. Filterfunktionen benötigen mindestens ein Argument für ihre Callback-Funktionen.
Aktionsfunktionen sollten nichts zurückgeben. Sie können jedoch die Ausgabe echoen oder mit der Datenbank interagieren. Filterfunktionen müssen ihre Änderungen als Ausgabe zurückgeben. Selbst wenn eine Filterfunktion nichts ändert, muss sie immer noch die unveränderte Eingabe zurückgeben.
Aktionen können fast alles ausführen, solange der Code gültig ist. Die Filter sollten isoliert arbeiten, damit sie keine unbeabsichtigten Nebenwirkungen haben.
Zusammenfassung: Eine Aktion unterbricht den regulären Code-Ausführungsprozess, um etwas mit den erhaltenen Infos zu machen, gibt aber nichts zurück und beendet sich dann. Zusammenfassung: Ein Filter modifiziert die Informationen, die er erhält, gibt sie an die Calling Hook-Funktion zurück, und andere Funktionen können den Wert, den er zurückgibt, verwenden.

Manchmal kannst du entweder eine Aktion oder einen Filter verwenden, um dasselbe Ziel zu erreichen. Wenn du zum Beispiel den Text in einem Beitrag ändern möchtest, kannst du eine Callback-Funktion mit der Aktion publish_post registrieren und den Inhalt des Beitrags ändern, wenn er in der Datenbank gespeichert wird.

// define the callback function to change the text
function change_text_callback() { 
    // add the code to change text here
}

// hook in to the 'publish_post' action with the add_action() function
add_action( 'publish_post', 'change_text_callback' );

Oder du kannst eine weitere Callback-Funktion mit dem Inhaltsfilter the_content registrieren, um den Inhalt des Beitrags zu ändern, bevor er im Browser angezeigt wird.

// define the callback function to modify the text
function change_text_another_callback( $content ) { 
    // add the code to change text here and then return it 
    return $filtered_content;
}

// hook in to 'the_content' filter with the add_filter() function
add_filter( 'the_content', 'change_text_another_callback');

Zwei verschiedene Ansätze mit dem gleichen Ergebnis. Zu wissen, wann man den einen über den anderen stellt, ist der Schlüssel zu einem guten WordPress-Entwickler.

Wie funktionieren WordPress Hooks?

Das Hausbeispiel war einfach genug, um die grundlegende Funktionsweise von Hooks zu verstehen, aber es erfasst nicht die Komplexität, wie sie funktionieren. Am wichtigsten sind die Konzepte der Hookstellung und der Spezifität.

Ein besseres Beispiel wäre es, sich vorzustellen, eine WordPress-Webseite so zu bearbeiten, wie ein Auto zusammenzubauen. Im Gegensatz zur Herstellung eines Autos, die viel Zeit in Anspruch nimmt, erfolgt der Zusammenbau einer Webseite fast augenblicklich.

Das Zusammensetzen einer Webseite ist wie das Zusammenbauen eines Autos

Das Zusammensetzen einer Webseite ist wie das Zusammenbauen eines Autos

Ähnlich wie ein Auto in einem modernen Fließband Stück für Stück zusammengesetzt wird, wird eine WordPress-Webseite Element für Element durch den Server und den Client zusammengesetzt.

Der WordPress-Kern ist wie der Motor des Autos, das Fahrgestell und andere wesentliche Bestandteile, die den „Kern“ der Webseite ausmachen.

Man kann eine funktionelle Webseite nur mit dem WordPress Core haben, aber wo ist der Spaß dabei? Du brauchst aufregende Funktionen für die Webseite. Hier kommen die WordPress Plugins und Themes ins Spiel, die beide ausgiebig Hooks verwenden.

Im obigen Beispiel ist jede nummerierte Station wie ein Hook im WordPress Core. Es gibt zwei Arten von Stationen, wie Aktionen und Filter. Jede Station enthält einen bestimmten Typ von Slot, der nur bestimmte Werkzeuge akzeptiert, ähnlich wie Aktionsfunktionen und Filterfunktionen.

Alle Stationen sind aus Gründen der Modularität und Effizienz in regelmäßigen Abständen platziert.

Je nach den Anforderungen an einer bestimmten Position können wir das für die Aufgabe am besten geeignete Werkzeug an dieser bestimmten Station anbringen (oder einhaken). Diese Tools sind wie die Callback-Funktionen, mit denen man mit WordPress interagieren oder WordPress modifizieren kann.

Einige Tools können die Funktionsweise erheblich verändern, ähnlich wie Rückrufe, die auf Aktionen registriert sind. Andere Werkzeuge werden nur dazu benutzt, das Aussehen des Autos zu verändern, wie Callbacks, die für Filter registriert sind.

Die Verwendung der richtigen Werkzeuge an den richtigen Stationen ist entscheidend, um ein erstklassiges Auto zu bauen. Auf die gleiche Weise helfen uns Hooks dabei, WordPress an unsere individuellen Bedürfnisse anzupassen.

Wenn man diese Analogie erweitert, sind Plugins wie das Hinzufügen hilfreicher Autofunktionen wie Airbags, Unterhaltungskonsole, ferngesteuertes schlüsselloses System usw. (wie diese, um die Funktionalität von WooCommerce zu verbessern). Themes sind analog zur Anpassung des visuellen Teils des Autos, wie das Gesamtdesign, Lackierung, Felgen, etc. (hier ist, wie ihr euer WordPress Theme anpasst).

Wo registriert man Hooks und ihre Funktionen?

Es gibt zwei empfohlene Wege, um Hooks in WordPress hinzuzufügen:

Für dieses Tutorial wollen wir damit beginnen, ein Plugin zu erstellen. Um das zu tun, erstelle einen neuen Ordner in deinem /wp-content/plugins/ Verzeichnis.

Ich gebe meinem Plugin den Namen Salhooks, aber du kannst es nennen, wie du willst. Gemäß den WordPress-Richtlinien benötigst du eine PHP-Datei mit dem gleichen Namen (salhooks.php) in deinem Plugin-Verzeichnis.

Füge die folgenden Header-Felder zu deiner Plugin-Datei hinzu, um sie bei WordPress zu registrieren. Du kannst mehr über die Anforderungen an den Plugin-Header im WordPress-Codex erfahren.

<?php

/*
Plugin Name:  Salhooks
Version    :  1.0
Description:  Demonstrating WordPress Hooks (Actions and Filters) with multiple examples.
Author     :  Salman Ravoof
Author URI :  https://www.salmanravoof.com/
License    :  GPLv2 or later
License URI:  https://www.gnu.org/licenses/gpl-2.0.html
Text Domain:  salhooks
*/

//=================================================
// Security: Abort if this file is called directly
//=================================================
if ( !defined('ABSPATH') ) { 
    die;
}

Speichere diese Datei und aktiviere dann das Plugin in deinem WordPress Dashboard. Ich werde dieses Plugin innerhalb einer lokalen WordPress-Installation verwenden, um zu demonstrieren, wie Hooks funktionieren.

Nebenbei bemerkt, ihr könnt die WordPress Core Dateien auch direkt bearbeiten, um Hooks zu registrieren. Allerdings ist das nicht empfehlenswert, da bei jedem Update von WordPress dein ganzer benutzerdefinierter Code überschrieben wird. Aus dem gleichen Grund solltest du auch keine Hooks in deinem Parent Theme hinzufügen.

WordPress Hooks benutzen

Ein WordPress Hook allein bewirkt nichts. Er sitzt nur im Code und wartet auf eine Hook-Funktion, die ihn aktiviert. Um einen Hook zu benutzen, brauchst du mindestens 2 andere Funktionen.

Zuerst brauchst du den Hook mit einer Hook-Funktion registrieren und darin eine Callback-Funktion referenzieren. Und dann benötigst du die Callback-Funktion, die du zuvor in der Hook-Funktion erwähnt hast. WordPress wird diese Callback-Funktion jedes Mal ausführen, wenn der Hook gefeuert wird.

Die Reihenfolge, in der du diese Funktionen definierst, spielt keine Rolle, aber es ist eine gute Idee, sie nahe beieinander zu platzieren.

Aktionen und Filter haben unterschiedliche Hook-Funktionen. Von nun an werden sie als Aktionsfunktionen und Filterfunktionen bezeichnet. Wie ihr sehen werdet, haben sie ihre eigene Syntax und Parameteranforderungen.

Eine Aktion einhängen

Aktionen bieten dir die Möglichkeit, deinen benutzerdefinierten Code an einem bestimmten Punkt in der Ausführung von WordPress Core, Plugins oder Themes auszuführen.

Die add_action() Action-Funktion

Du kannst eine Callback-Funktion mit einer Aktion registrieren, indem du diesen Schritten folgst:

  1. Definiere eine Callback-Funktion mit deinem eigenen Code darin. Diese Callback-Funktion wird ausgeführt, wenn eine Aktion, für die sie registriert ist, während der Codeausführung von WordPress ausgelöst wird.
  2. Hänge deine Callback-Funktion mit der add_action()-Funktion an die gewünschte Aktion an. Wie im WordPress-Codex vorgeschrieben, benötigt die add_action()-Funktion mindestens zwei Parameter:
    1. Name der Aktion, in die eingeklinkt werden soll.
    2. Name der Callback-Funktion, die ausgeführt wird, wenn die Aktion ausgelöst wird.
  3. Die add_action()-Funktion akzeptiert auch zwei optionale Parameter, um die Priorität und die Anzahl der Argumente festzulegen. Wir werden beide später besprechen.

Es ist gute Praxis, die Parameter deiner Callbackfunktion so nah wie möglich an die Parameter zu benennen, die von der Hookfunktion übergeben werden.

Schauen wir uns ein Beispiel für die Verwendung der add_action() Funktion an.

// define the callback function, the arguments are optional
function example_callback( $arg1, $arg2 ) {
    // make your code do something with the arguments
}

// hook the callback function to the 'example_action'
add_action( 'example_action', 'example_callback', [priority], [no_of_args] );

// 'priority' and 'number of arguments' are optional parameters

Beispiel für das Einhaken einer Aktion

WordPress enthält eine eingebaute Aktion namens init, die ausgelöst wird, nachdem WordPress fertig geladen und der Benutzer authentifiziert wurde, aber bevor irgendwelche Header gesendet werden. Viele Plugins benutzen diesen Hooks als Startpunkt, um ihren Code zu instanziieren, da fast alle wichtigen Funktionen von WordPress fertig geladen sind, wenn WordPress diese Aktion ausführt.

WordPress hat eine ähnliche Aktion namens admin_init. Sie wird während der Initialisierung des Admin-Bildschirms ausgelöst, während die Aktion init erst dann ausgelöst wird, wenn WordPress fertig geladen ist.

Lass uns einen benutzerdefinierten Code ausführen, um eine einfache Nachricht während der Ausführung der init-Aktion zu echoen. Hier ist, wie man das macht:

function custom_callback_function(){
    // add your custom code here to do something
    echo 'I will be fired on WordPress initialization';
}
add_action( 'init', 'custom_callback_function' );

Du kannst sehen, wie die Nachricht in der linken oberen Ecke meiner lokalen WordPress-Installation wiedergegeben wird.

Nicht so hübsch, aber es ist ein toller Anfang!

Nicht so hübsch, aber es ist ein toller Anfang!

Aktionen finden, die von WordPress unterstützt werden

WordPress beinhaltet jedes Mal Aktionen, wenn es etwas tut, wie z.B. einen Benutzer einloggen oder einen neuen Beitrag veröffentlichen. Eine umfassende Liste aller Aktionen, die von WordPress ausgeführt werden, findest du auf der Plugin API/Action Reference Seite.

Es gibt eine Aktion für fast jeden Einsatz

Es gibt eine Aktion für fast jeden Einsatz

Der Kodex hat alle dort aufgeführten Aktionen in verschiedene Kategorien aufgeteilt und von der ersten bis zur letzten in der WordPress-Ausführungsreihenfolge angeordnet.

In den meisten Fällen werden viele dieser Aktionen nichts ausrichten, da nichts mit ihnen verbunden ist. Aber wenn du sie brauchst, sind sie für dich da, um dich einzuklinken.

Fühlst du dich ein bisschen überfordert mit all den Aktionen? Das ist ganz natürlich. Je mehr Erfahrung du sammelst und den WordPress Core-Quellcode durchsiehst, desto einfacher wird es, den perfekten Hook für deine Bedürfnisse zu finden. Suche einfach nach dem Begriff „do_action“ und du wirst jede Menge Aktionen finden, in die du dich einklinken kannst.

Zusätzliche Parameter für add_action()

Die add_action()-Funktion kann zwei weitere Parameter akzeptieren: einen zum Setzen der Priorität und den anderen zum Setzen der Anzahl der Argumente. Obwohl sie optional sind, können sie, wenn sie richtig verwendet werden, super hilfreich sein.

Priorität

Der erste zusätzliche Parameter, der von der add_action()-Funktion unterstützt wird, setzt die Priorität. Dieser Parameter kann nur eine positive ganze Zahl sein. Je niedriger die Prioritätszahl, desto früher wird die Funktion ausgeführt. Der Standardwert ist 10, wenn du ihn nicht angibst.

Um zu sehen, wie es funktioniert, lass uns drei Callback-Funktionen zur init-Aktion registrieren, aber jede mit einer anderen Priorität.

// priority is set to 9, which is lower than 10, hence it ranks higher
add_action( 'init', 'i_am_high_priority', 9 );

// if no priority is set, the default value of 10 will be used
add_action( 'init', 'i_am_default_priority');

// priority is set to 11, which is higher than 11, hence it ranks lower
add_action( 'init', 'i_am_low_priority', 11 );

In den obigen Beispielen läuft die Callback-Funktion mit der niedrigsten Prioritätsnummer zuerst und die mit der höchsten Nummer zuletzt. Wenn ihre Prioritäten gleich sind, dann laufen sie in der Reihenfolge, in der du sie registriert hast.

Die Priorität spielt eine wichtige Rolle, wenn ein einzelner Hook mehrere Callback-Funktionen bei ihm registriert haben kann. Um unerwartete Ergebnisse zu vermeiden, kannst du für jede Callback-Funktion eine Priorität festlegen, so dass sie in der Reihenfolge ausgeführt werden, in der du sie registrieren möchtest.

Anzahl der Argumente

Standardmäßig erhält jede Callback-Funktion, die über die add_action()-Funktion registriert wird, nur ein Argument. Manchmal benötigst du jedoch zusätzliche Daten an die Callback-Funktion.

Aus diesem Grund akzeptiert die add_action()-Funktion einen optionalen Parameter, um die Anzahl der Argumente festzulegen.

Ein gutes Beispiel dafür ist die comment_post action. Diese Aktion läuft sofort nachdem WordPress einen Kommentar in die Datenbank geschrieben hat. Wenn du den Parameter für die Anzahl der Argumente nicht angibst, wird nur ein einziger Wert an die Callback-Funktion übergeben, der in diesem Fall die comment_ID ist

// register the hook with 'priority' and 'number of arguments' parameters
add_action( 'comment_post', 'show_message_function', 10, 3 );

// define the callback function
function show_message_function( $comment_ID, $comment_approved, $commentdata ) {
    // check whether a comment is approved with the second parameter
    if( 1 === $comment_approved ){
        // runs the code only if the comment is approved
    }
}

Wenn du den Parameter „Anzahl der Argumente“ wie im obigen Beispiel auf 3 setzt, wird die Funktion action drei Werte übergeben: comment_ID, comment_approved und commentdata.

WordPress setzt den comment_approved-Wert auf 1 für genehmigte Kommentare, 0, wenn nicht genehmigt, und ’spam‘, wenn der Kommentar als Spam markiert ist.

Die Variable benutzecommentdata ist ein Array, das alle Kommentardaten enthält, wie den Namen des Kommentarautors, die E-Mail-Adresse, die Webseite und den Inhalt des Kommentars selbst. Im WordPress-Codex findet ihr alle Schlüssel-Werte-Paare, die im Array ‚commentdata‘ enthalten sind.

Du kannst so viele Argumente haben, wie du willst, aber die Callback-Funktion und die add_action()-Funktion benötigen die gleiche Anzahl von Argumenten.

Indem du zusätzliche Parameter an die Callback-Funktion übergibst, kannst du mehr mit deinem Code machen. Zum Beispiel kannst du überprüfen, ob ein Kommentar genehmigt ist oder nicht und den Kommentartext automatisch an den Admin mailen, wenn er genehmigt ist. Dies ist ohne Angabe der zusätzlichen Argumente nicht möglich, da deine Callback-Funktion keinen Zugriff auf die comment_content Daten hat.

Wenn du die Priorität nicht setzen willst, sondern nur die Anzahl der Argumente ändern willst, brauchst du trotzdem eine Priorität. Benutze einfach den Standardwert (z.B. 10).

Wie WordPress Core Aktionen benutzt

WordPress Core selbst verwendet viele seiner eingebauten Aktionen, um verschiedene Funktionen auszuführen.

Nimm zum Beispiel die wp_head Aktion. Sie wird ausgelöst, wenn WordPress den Header-Bereich der Webseiten ausgibt (der Code, der zwischen <head> und </head> liegt).

Die meisten Funktionen der WordPress-Core-Aktion, die sich auf den wp_head-Hook beziehen, findest du in der wp-includes/default-filters.php-Datei. Ich habe mich durch den Code gearbeitet und eine Liste aller add_action()-Funktionen zusammengestellt, die die wp_head-Aktion aufrufen.

add_action( 'wp_head', 'rest_output_link_wp_head', 10, 0 );
add_action( 'wp_head', '_wp_render_title_tag', 1 );
add_action( 'wp_head', 'wp_enqueue_scripts', 1 );
add_action( 'wp_head', 'wp_resource_hints', 2 );
add_action( 'wp_head', 'feed_links', 2 );
add_action( 'wp_head', 'feed_links_extra', 3 );
add_action( 'wp_head', 'rsd_link' );
add_action( 'wp_head', 'wlwmanifest_link' );
add_action( 'wp_head', 'adjacent_posts_rel_link_wp_head', 10, 0 );
add_action( 'wp_head', 'locale_stylesheet' );
add_action( 'wp_head', 'noindex', 1 );
add_action( 'wp_head', 'print_emoji_detection_script', 7 );
add_action( 'wp_head', 'wp_print_styles', 8 );
add_action( 'wp_head', 'wp_print_head_scripts', 9 );
add_action( 'wp_head', 'wp_generator' );
add_action( 'wp_head', 'rel_canonical' );
add_action( 'wp_head', 'wp_shortlink_wp_head', 10, 0 );
add_action( 'wp_head', 'wp_custom_css_cb', 101 );
add_action( 'wp_head', 'wp_site_icon', 99 );
add_action( 'wp_head', 'wp_no_robots' );

Das sind eine Menge Callback-Funktionen, die mit nur einer Aktion verbunden sind. Hier die Priorität zu setzen ist entscheidend, um sicherzustellen, dass die wichtigsten abhängigen Funktionen zuerst ausgeführt werden.

Im obigen Beispiel ist das Laden der Skripte mit der Callback-Funktion wp_enqueue_scripts() wichtiger (Priorität = 1) als das Laden der Icon-Meta-Tags der Webseite mit der Callback-Funktion wp_site_icon() (Priorität = 99).

Info

Alle Callback-Funktionen, die im obigen Beispiel verwendet werden, sind WordPress-Funktionen. Du kannst sie auch in jedem deiner Codes verwenden. Besuche die Seite Funktionsreferenz auf dem WordPress-Codex für weitere Informationen.

Andere Action-Funktionen

Während add_action() die meistgenutzte Action-Funktion ist, gibt es viele andere, die ebenso hilfreich sind. Schauen wir mal, wie sie alle funktionieren.

Diese Aktionsfunktion prüft, ob eine Aktion eingehakt wurde. Sie akzeptiert zwei Parameter. Der erste Parameter ist der Name der Aktion. Der zweite Parameter ist optional und ist der Name der Callback-Funktion.

has_action( 'action_name', 'function_to_check' );

Wenn du nur den ersten Parameter angibst, gibt er true zurück, wenn irgendeine Funktion mit dem Parameter action_name verknüpft ist.

Wenn du aber auch den zweiten Parameter angibst, gibt er false zurück, wenn die angegebene Callback-Funktion nicht auf die erwähnte Aktion registriert ist.

Wenn die Callback-Funktion jedoch an den Action-Hook angehängt ist, gibt sie die Priorität (eine ganze Zahl) zurück, die für diese Funktion an diesem Action-Hook gesetzt wurde.

Wir sind dieser Aktionsfunktion schon einmal begegnet. WordPress benutzt sie, um alle seine Standardaktionen zu definieren, damit andere Funktionen sich in sie einklinken können. Genau wie WordPress kannst du auch die Funktion do_action() verwenden, um eine neue benutzerdefinierte Aktion zu erstellen, indem du einen neuen Aktionsnamen als Parameter angibst.

do_action( 'action_name', [argument1], [argument2] );

Nur diese Funktion zu deklarieren, wird von sich aus nichts bewirken. Aber sie wird im Code sitzen und darauf warten, dass andere Aktionsfunktionen sie aktivieren. Das Übergeben von zusätzlichen Argumenten ist optional, aber es ist wichtig, wenn du willst, dass deine Callback-Funktionen sie benutzen.

Diese Action-Funktion ist identisch mit do_action(), bis auf einen Unterschied. Alle Argumente, die sie durchlaufen, müssen ein Array sein. Wenn du eine Menge Argumente zu übergeben hast oder deine Argumente bereits in einem Array sind, ist diese Funktion super hilfreich.

// here's an example array
$arguments_array = array( 'arg_1', 'foo', true, 'arg_4' );

do_action_ref_array( 'example_action', $arguments_array );

Da PHP-Arrays eine geordnete Karte sind, stelle sicher, dass die Argumente, die du übergibst, in der richtigen Reihenfolge sind.

Ein Beispiel für die Verwendung dieser Aktionsfunktion ist die Aktion admin_bar_menu. Sie kann eingehakt werden, um die verschiedenen Elemente der Admin-Leiste hinzuzufügen, zu manipulieren oder zu entfernen. Alle Elemente der Admin-Leiste sind als Elemente eines Arrays definiert.

Wenn du zählen möchtest, wie oft eine Aktion abgefeuert wird, kannst du diese Aktionsfunktion aufrufen.

did_action( 'action_name' );

Diese Funktion gibt einen ganzzahligen Wert zurück.

Die did_action()-Funktion ist extrem praktisch, wenn du eine Callback-Funktion nur beim ersten Ausführen einer Aktion ausführen willst und nie wieder

function example_callback_function() {
    if( did_action( 'example_action' ) === 1 ) {
    // checks if the 'example_action' hook is fired once, and only runs then, and never again!
    }
}
add_action('example_action', 'example_callback_function');

Diese Action-Funktion entfernt eine Callback-Funktion, die mit der angegebenen Aktion verbunden ist. Zum Beispiel kannst du diese Funktion benutzen, um die Standard WordPress Funktionen, die in eingebauten Aktionen gehakt sind, zu entfernen und sie durch deine eigenen zu ersetzen.

remove_action( 'action_name', 'function_to_be_removed', [priority] );

Es gibt ein paar Voraussetzungen für den Aufruf der remove_action()-Funktion:

  1. Die Parameter function_to_be_removed und priority müssen die gleichen sein wie die, die ursprünglich in der add_action()-Funktion verwendet wurden.
  2. Du kannst die remove_action()-Funktion nicht direkt aufrufen. Du brauchst sie aus einer anderen Funktion heraus aufzurufen.
  3. Wenn die Callback-Funktion von einer Klasse registriert ist, dann hat das Entfernen der Funktion andere Anforderungen. Du kannst die WordPress Codex-Dokumentation für weitere Details lesen.
  4. Du kannst die Callback-Funktion nicht entfernen, bevor sie registriert ist oder nachdem sie ausgeführt wurde.

Hier ist ein Beispiel dafür, wie WooCommerce diese Aktionsfunktion verwendet, um die Standard-Produkt-Miniaturansicht auf der Hauptseite des Shops zu entfernen.

remove_action( 'woocommerce_before_shop_loop_item_title', 'woocommerce_template_loop_product_thumbnail', 10 );

Diese Aktionsfunktion entfernt alles, was mit einer Aktion verbunden ist. Der Parameter priority ist optional.

remove_all_actions( 'action_name', [priority] );

Denke daran, dass diese Funktion nicht von der Aktion aus aufgerufen werden kann, von der du die Callback-Funktionen deregistrieren möchtest. Das würde eine Endlosschleife verursachen. Du kannst dich in eine Aktion einklinken, die früher ausgelöst wurde, um diese Funktion ohne Fehler auszuführen.

Diese Aktionsfunktion prüft, ob die angegebene Aktion ausgeführt wird oder nicht. Sie gibt einen booleschen Wert zurück (true oder false).

// check whether the 'action_name' action is being executed
if ( doing_action( 'action_name' ) ) {
    // execute your code here
}

Du kannst den Parameter action_name leer lassen, um zu prüfen, ob eine Aktion ausgeführt wird. Er wird jedes Mal true zurückgeben, wenn eine Aktion ausgelöst wird.

// check if any action is running and do something
if ( doing_action() ) {
    // the code here is run when any action is fired
}

Aktionen Beispiel 1: Zeige den Besuchern deiner Webseite eine Wartungsmeldung

Manchmal ist es am besten, deine Webseite offline zu nehmen und eine Wartungs-Seite einzurichten. Glücklicherweise bietet dir WordPress eine einfache Möglichkeit, genau das zu tun.

// show a maintenance message for all your site visitors
add_action( 'get_header', 'maintenance_message' );
function maintenance_message() {
    if (current_user_can( 'edit_posts' )) return;
    wp_die( '<h1>Stay Pawsitive!</h1><br>Sorry, we\'re temporarily down for maintenance right meow.' );
}

Lass uns den Code aufschlüsseln und jeden Schritt durchgehen:

Nachdem ich den Code in meinem benutzerdefinierten Plugin gespeichert habe, habe ich meine lokale WordPress-Installation im privaten Browsermodus geladen. Die Seite “Wartung” funktioniert!

Den Besuchern der Webseite eine Fehlermeldung anzeigen

Den Besuchern der Webseite eine Fehlermeldung anzeigen

Die Webseite wird erfolgreich geladen, wenn ich eingeloggt bin, wenn sie den Benutzerfähigkeitstest besteht. Du kannst nun weiter daran arbeiten, deine Webseite zu reparieren, während sie regelmäßigen Besuchern diese Seite anzeigt.

Aktionen Beispiel 2: Dashboard-Menüpunkte vor Nicht-Admin-Benutzern verstecken

Wenn du einen Multi-Autoren-Blog betreibst oder eine Webseite für deine Kunden verwaltest, dann benötigst du eventuell bestimmte Admin-Menüs aus dem WordPress-Dashboard für Nicht-Admin-Benutzer auszublenden. Das kannst du tun, indem du dich in die Aktion admin_menu einhängst.

// remove specific dashboard menus for non-admin users
add_action( 'admin_menu', 'hide_admin_menus' );
function hide_admin_menus() {
    if (current_user_can( 'create_users' )) return;
    if (wp_get_current_user()->display_name == "Salman") return; 
    remove_menu_page( 'plugins.php' ); 
    remove_menu_page( 'themes.php' ); 
    remove_menu_page( 'tools.php' ); 
    remove_menu_page( 'users.php' ); 
    remove_menu_page( 'edit.php?post_type=page' ); 
    remove_menu_page( 'options-general.php' );
}

Hier ist eine Schritt-für-Schritt-Anleitung für den obigen Codeschnipsel:

Nachdem ich die Plugin-Datei gespeichert habe, hier ist ein Schnappschuss des WordPress-Dashboards mit einem eingeloggten Admin.

Das standardmäßige WordPress-Admin-Dashboard

Das standardmäßige WordPress-Admin-Dashboard

Und hier ist ein Screenshot des WordPress-Dashboards mit einem eingeloggten Nicht-Admin-Benutzer.

Sensible Admin-Menüpunkte vor Nicht-Admin-Benutzern verstecken

Sensible Admin-Menüpunkte vor Nicht-Admin-Benutzern verstecken

Diese Lösung versteckt nur die angegebenen Admin-Menüpunkte vor dem Erscheinen im WordPress-Dashboard. Alle Benutzer können trotzdem auf sie zugreifen, indem sie die Menü-URLs in ihren Browsern eingeben.

Um bestimmten Benutzerrollen den Zugriff auf bestimmte Menüs zu verwehren, benötigst du deren Fähigkeiten.

Einen Filter einhängen

Filter bieten dir eine Möglichkeit für deinen benutzerdefinierten Code, um Daten zu verändern, die von anderen WordPress-Funktionen verwendet werden. Im Gegensatz zu Aktionen benötigen Funktionen, die von Filtern abhängig sind, einen Wert zurückgeben.

Die add_filter() Filter Funktion

Du kannst eine Callback-Funktion an einen Filter anhängen, indem du diese Schritte befolgst:

  1. Definiere eine Callback-Funktion, die ausgeführt wird, wenn WordPress den Filter feuert. Callback-Funktionen für Filter benötigen mindestens ein Argument, da alle Filter mindestens einen Wert an ihre Callback-Funktionen übergeben.
  2. Registriere die Callback-Funktion für einen Filter mit der add_filter()-Funktion. Der Filter wird sich um den Aufruf der Callback-Funktion kümmern. Wie im WordPress Codex vorgeschrieben, benötigt die add_filter()-Funktion mindestens zwei Parameter:
      • Name des Filters, in den sie sich einklinken soll.
      • Name der Callback-Funktion, die ausgeführt wird, wenn der Filter feuert.
  3. Die add_filter()-Funktion akzeptiert auch zwei zusätzliche optionale Parameter, um die Priorität und die Anzahl der Argumente festzulegen. Diese Parameter funktionieren auf die gleiche Weise wie bei der add_action()-Funktion.

Hier ist ein Beispiel, wie du die add_filter()-Funktion benutzen kannst, um eine Callback-Funktion mit einem Filter zu verbinden.

// define the filter callback function with at least one argument passed
// the number of arguments that you can pass depends on how the filter is defined
function filter_callback_function( $arg1, $arg2 ) {
    // make your code do something with the arguments and return something
    return $something;
}

// now hook the callback function to the 'example_filter'
add_filter( 'example_filter', 'filter_callback_function', [priority], [no_of_args] );

// '10' is the default priority set for the callback function
// and '1' is the default number of arguments passed

Beispiel für das Einhängen eines Filters

WordPress bietet dir einen Filter namens login_message, um die Nachricht zu filtern, die auf der Anmeldeseite über dem Anmeldeformular angezeigt wird. Der von diesem Filter zurückgegebene Wert kann HTML-Markup haben.

Hängen wir uns in den Filter login_message ein und ändern die Nachricht, die auf der Anmeldeseite angezeigt wird.

// show a custom login message above the login form
function custom_login_message( $message ) {
    if ( empty( $message ) ) {
        return "<h2>Welcome to Let's Develop by Salman Ravoof! Please log in to start learning.</h2>";
    } 
    else {
        return $message;
    }
}
add_filter( 'login_message', 'custom_login_message' );

Die if-else-Anweisung in der Callback-Funktion prüft, ob die Login-Nachricht bereits gesetzt ist, meistens durch ein anderes Plugin oder Theme. In solchen Fällen gibt die Callback-Funktion den ursprünglichen Wert zurück und nimmt keine Änderungen vor. Dies ist eine Möglichkeit, Konflikte mit anderen Plugins oder Themes zu vermeiden.

Du kannst sehen, dass die Nachricht über dem Anmeldeformular auf der WordPress-Anmeldeseite angezeigt wird.

Anzeigen einer benutzerdefinierten Login-Nachricht über dem Login-Formular

Anzeigen einer benutzerdefinierten Login-Nachricht über dem Login-Formular

Du kannst alle Elemente auf der Anmeldeseite stylen, indem du benutzerdefinierte Style Sheets in die Warteschlange stellst. Auf diese Weise kannst du deine standardmäßige WordPress-Anmeldeseite vollständig anpassen.

Im Abschnitt „Die WordPress-Anmeldeseite mit Hooks anpassen“ erfährst du, wie du mithilfe von Aktionen benutzerdefinierte Stylesheets laden kannst.

Von WordPress unterstützte Filter finden

Überall dort, wo WordPress Daten verarbeitet oder verändert, kannst du mit ziemlicher Sicherheit einen Filter finden, in den du dich einklinken und ihn verändern kannst. Stell dir Filter als Schnittstelle zwischen der WordPress-Datenbank und dem Browser vor.

Eine ausführliche Liste aller von WordPress unterstützten Filter findest du auf der Seite Plugin API/Filter-Referenz.

WordPress bietet dir eine Vielzahl von Filtern zum Einklinken

WordPress bietet dir eine Vielzahl von Filtern zum Einklinken

Alle dort aufgeführten Filter sind in mehrere Kategorien aufgeteilt und in der WordPress-Ausführungsreihenfolge von oben nach unten angeordnet.

Wenn du Filter zum Einklinken im WordPress-Quelltext finden möchtest, dann suche nach dem Begriff „apply_filters“ und du wirst tonnenweise Ergebnisse erhalten. Die WordPress Code-Referenz ist auch ein großartiger Ort, um nach allem zu suchen, was in WordPress enthalten ist, einschließlich Aktionen und Filter

Wie der Core von WordPress Filter verwendet

Der WordPress Core selbst verwendet eine Menge seiner eingebauten Filter, um die Daten zu verändern, die von seinen verschiedenen Funktionen verwendet werden.

Betrachte zum Beispiel den the_content-Filter. Er filtert die Inhalte von Beiträgen, nachdem sie aus der Datenbank abgerufen wurden und bevor sie im Browser angezeigt werden.

Genau wie bei den Aktionen findest du die meisten Filterfunktionen des WordPress Core, die sich auf den the_content-Hook beziehen, in der wp-includes/default-filters.php-Datei.

Hier ist eine Liste aller core add_filter()-Funktionen, die sich auf den the_content-Filter beziehen:

add_filter( 'the_content', 'do_blocks', 9 );
add_filter( 'the_content', 'wptexturize' );
add_filter( 'the_content', 'convert_smilies', 20 );
add_filter( 'the_content', 'wpautop' );
add_filter( 'the_content', 'shortcode_unautop' );
add_filter( 'the_content', 'prepend_attachment' );
add_filter( 'the_content', 'wp_make_content_images_responsive' );
add_filter( 'the_content', 'do_shortcode', 11 ); // AFTER wpautop(). 

Beachte die angegebene Priorität für bestimmte Callback-Funktionen.

Zum Beispiel parst die Funktion do_blocks() alle dynamischen Blöcke des Beitragsinhalts und rendert sie neu, damit sie mit dem neuen Blockeditor von WordPress kompatibel sind. Sie hat eine höhere Priorität als die Standardpriorität (10), um sicherzustellen, dass der Inhalt blocktauglich ist, bevor die anderen Funktionen ausgeführt werden.

Die convert_smilies()-Funktion wird mit niedrigerer Priorität ausgeführt, da ihre Aufgabe darin besteht, Text-Smileys in Bild-Sprites zu konvertieren. Es macht Sinn, sie am Ende laufen zu lassen, nachdem der gesamte Inhalt des Beitrags gefiltert wurde.

Fun Fact: Shortcodes sind eine Untermenge von Filtern. Sie nehmen Input vom Shortcode auf, verarbeiten ihn und geben dann den Output wieder zurück. Mehr über Shortcodes erfährst du in dieser ultimativen WordPress Shortcodes Anleitung.

Andere Filterfunktionen

Während add_filter() die meistgenutzte Filterfunktion ist, gibt es viele andere hilfreiche Filterfunktionen. Lass sie uns alle im Detail besprechen.

Diese Funktion prüft, ob der angegebene Filter von einer Funktion abhängig ist. Sie akzeptiert zwei Parameter. Der erste Parameter ist für die Eingabe des Filternamens. Der zweite Parameter ist optional und dient dazu, den Namen der Callback-Funktion einzugeben.

has_filter( 'filter_name', 'function_to_check' );

Wenn du nur den ersten Parameter angibst, wird true zurückgegeben, wenn der filter_name von irgendeiner Funktion angehängt wird.

Wenn du jedoch beide Parameter angibst, wird false zurückgegeben, wenn die erwähnte Callback-Funktion nicht bei dem angegebenen Filter registriert ist. Wenn er die Callback-Funktion findet, die im Filter registriert ist, dann gibt er die Priorität (eine ganze Zahl) zurück, die für diese Funktion in diesem Filter gesetzt wurde.

Eine mögliche Anwendung der has_filter()-Funktion ist es, zu überprüfen, ob irgendein Filter bereits gehakt wurde, und basierend darauf mit der Codeausführung fortzufahren.

// check to see if 'the_content' filter has been hooked
if ( ! has_filter( 'the_content' ) {
    // hook the filter if and only if it hasn't been hooked before
    add_filter( 'the_content', 'modify_the_content' );
}

Diese Filterfunktion ist wie die Aktionsfunktion do_action(). Alle Callback-Funktionen, die mit diesem Filter verbunden sind, werden ausgeführt, wo auch immer diese Funktion im WordPress Code ist.

Du kannst diese Funktion auch benutzen, um einen neuen benutzerdefinierten Filter zu erstellen, indem du den Filternamen und den Filterwert als Parameter angibst.

apply_filters( 'filter_name', 'value_to_filter', [argument1], [argument2] );

Vergiss nicht, zusätzliche Argumente anzugeben, wenn du sie an deine Callback-Funktionen weitergeben möchtest. Die meisten Filter verwenden nur ein Argument, so dass es leicht passieren kann, dass man die zusätzlichen Argumente nicht definiert.

Diese Funktion ist wie die apply_filters()-Funktion, außer dass alle Argumente, die sie akzeptiert, als Array gebündelt sind.

// an example array
$arguments_array = array( 'some_value', 'foo', false, 'another_value' );

apply_filters_ref_array( 'example_filter', $arguments_array );

Diese Filterfunktion kann nützlich sein, wenn du viele Argumente zu übergeben hast oder wenn sich alle Argumente bereits in einem Array befinden. Stelle sicher, dass die Argumente innerhalb des Arrays in der richtigen Reihenfolge sind.

Diese Filterfunktion ruft den Namen des aktuellen Filters oder der gerade ausgeführten Aktion ab. Du brauchst keine Parameter anzugeben, da sie innerhalb der Callback-Funktion läuft.

Hier ist ein Beispiel für ihre Verwendung:

function example_callback() {
    echo current_filter(); // 'the_title' will be echoed
    return
}
add_filter( 'the_title', 'example_callback' );

Trotz ihres Namens kann diese Funktion den Namen sowohl von Aktionen als auch von Filtern abrufen.

Diese Filterfunktion entfernt die Callback-Funktion, die an den angegebenen Filter angehängt ist. Sie funktioniert genau wie die remove_action()-Funktion. Du kannst sie benutzen, um mit einem bestimmten Filter registrierte WordPress-Standardfunktionen zu löschen und sie gegebenenfalls durch deine eigenen Funktionen zu ersetzen.

remove_filter( 'filter_name', 'function_to_be_removed', [priority] );

Um eine Callback-Funktion, die an einen Filter gehookt wurde, wieder zu entfernen, müssen die Parameter function_to_be_removed und priority identisch mit den Argumenten sein, die beim Hooking der Callback-Funktion verwendet wurden.

Wenn der Filter von innerhalb einer Klasse hinzugefügt wurde, was normalerweise der Fall ist, wenn sie von Plugins hinzugefügt wurden, dann benötigt ihr Zugriff auf die Klassenvariable, um den Filter zu entfernen.

// access the class variable first, and then remove the filter through it
global $some_class;

remove_filter( 'the_content', array($some_class, 'class_filter_callback') );

Sehen wir uns ein großartiges Beispiel für remove_filter() in Aktion an.

Das WooCommerce-Plugin verwendet die wc_lostpassword_url() Call Funktion, die an seinen lostpassword_url-Filter gekoppelt ist, um „Passwort vergessen?„-Versuche von Benutzern umzuleiten.

Jeder Benutzer, der auf diesen Link klickt, wird zu einer benutzerdefinierten Frontend-Seite mit der URL /my-account/lost-password weitergeleitet. Ohne diesen Filter würden sie auf die Standard-WordPress-Login-URL unter /wp-login.php weitergeleitet.

Angenommen, du möchtest diese Funktion zurücksetzen und deine Benutzer auf die Standard-Passwortwiederherstellungsseite oder auf eine separate Seite schicken. Du kannst diese Callback-Funktion wie folgt entfernen::

remove_filter( 'lostpassword_url', 'wc_lostpassword_url', 10 ); 

Diese Filterfunktion entfernt alle Callback-Funktionen, die in einem Filter registriert sind.

remove_all_filters( 'filter_name', [priority] );

Es ist ähnlich wie die remove_all_actions()-Funktion.

Das beliebte Advanced Excerpts Plugin benutzt diese Funktion, um alle Standardfunktionen zu entfernen, die mit den Filtern the_excerpt und get_the_excerpt verbunden sind. Nachdem es das getan hat, hängt es dann seine eigene Callback-Funktion an den Filter an.

Brauchst du ein blitzschnelles, sicheres und entwicklerfreundliches Hosting für deine Kunden-Webseiten? Kinsta wurde mit Blick auf WordPress-Entwickler entwickelt und bietet eine Vielzahl von Tools und ein leistungsstarkes Dashboard. Schau dir unsere Pläne an.

// Ensure our filter is hooked, regardless of the page type 
if ( ! has_filter( 'get_the_excerpt', array( $advanced_excerpt, 'filter_excerpt' ) ) ) {
    remove_all_filters( 'get_the_excerpt' ); 
    remove_all_filters( 'the_excerpt' ); 
    add_filter( 'get_the_excerpt', array( $advanced_excerpt, 'filter_excerpt' ) );
}

Diese Filterfunktion prüft, ob der angegebene Filter gerade ausgeführt wird.

if ( doing_filter( 'save_post' ) ) {
    // run your code here
}

Es gibt einen booleschen Wert zurück (true oder false).

Du solltest den Unterschied zwischen dieser Funktion und der current_filter()-Funktion beachten, die den Namen des Filters oder der Aktion, die gerade ausgeführt wird, zurückgibt (ein String).

Filters Beispiel 1: Hinzufügen eines Profanity-Filters für Kommentare

Die Verwaltung aller Kommentare auf deiner WordPress Webseite kann ein mühsamer Prozess sein. Mit dem comment_text Filter kannst du Regeln aufstellen, um die Kommentare zu ändern, bevor sie auf der Seite angezeigt werden.

Ungefilterte Kommentare mit markierten Dummy-Schimpfwörtern

Ungefilterte Kommentare mit markierten Dummy-Schimpfwörtern

Du kannst WordPress anweisen, alle Schimpfwörter automatisch zu entfernen, bevor sie den Besuchern deiner Webseite angezeigt werden. Lass uns zur Sache kommen.

// hook into the 'comment_text' filter with the callback function
add_filter( 'comment_text', 'the_profanity_filter' );

// define a callback function to filter profanities in comments 
function the_profanity_filter( $comment_text ) {
    // define an array of profane words and count how many are there 
    $profaneWords = array('fudge', 'darn', 'pickles', 'blows', 'dangit');
    $profaneWordsCount = sizeof($profaneWords);
    
    // loop through the profanities in $comment_text and replace them with '*'
    for($i=0; $i < $profaneWordsCount; $i++) {
        $comment_text = str_ireplace( $profaneWords[$i], str_repeat('*', strlen( $profaneWords[$i]) ), $comment_text );
    } 
    
    return $comment_text;
}

Hier ist eine zeilenweise Aufschlüsselung des Codes:

Speichere die Änderungen in deiner eigenen Plugin-Datei und lade jeden Beitrag mit Kommentaren neu. Alle Wörter, die ihr in das profaneWords-Array aufgenommen habt, sollten nun durch ‚*‘-Symbole ersetzt werden.

Zensierung von Schimpfwörtern in Kommentaren mit '*'-Symbolen

Zensierung von Schimpfwörtern in Kommentaren mit ‚*‘-Symbolen

Die Originalkommentare werden weiterhin in der Datenbank verfügbar sein. Dieser Filter modifiziert nur den Kommentartext, bevor er auf dem Frontend ausgegeben wird.

Der Originalkommentar im Backend der Webseite

Der Originalkommentar im Backend der Webseite

Wenn du einmal in den richtigen Filter eingehakt bist, kannst du eine Menge cooler Sachen damit machen.

Zum Beispiel kannst du auch den comment_text Filter benutzen, um alle URLs aus allen Kommentaren zu entfernen (lies unbedingt diese ausführliche Anleitung, wie man Spam-Kommentare in WordPress stoppt).

Oder du kannst dich in den pre_comment_approved-Filter einklinken und Kommentare anhand vordefinierter Kriterien als genehmigt, Spam oder Trash markieren.

Filter Beispiel 2: Inhalt nach einem Beitrag einfügen

Du hast bereits gesehen, wie WordPress the_content-Filter benutzt, um Beiträge oder Seiteninhalte zu verändern. Lass uns den gleichen Filter verwenden, um am Ende jedes Beitrags etwas hinzuzufügen.

// hook into 'the_content' filter with a callback function
add_filter( 'the_content', 'insert_content_below' );

// define the callback function to insert something below the post
function insert_content_below( $content ) {
    // check to see if we're inside the main loop in a single post
    if ( is_single() && in_the_loop() && is_main_query() ) {
        return $content . "<h3 style=\"text-align: center;\">Let me insert myself here</h3><p style=\"text-align: center;border: 3px solid #5333ed;\">I'll appear after the post. You can insert anything here. Even HTML. Headers, links, images, scripts, I'll take them all and append it to the end of the post content. You can also give me a class, so you can style me easily with CSS style sheets.</p>" ;
    } 
    
    return $content;
}

Verstehen der Code-Logik im obigen Beispiel:

Speichere deine Plugin-Datei, lade jeden Beitrag auf deiner Webseite und scrolle bis zum Ende.

Etwas am Ende des Beitragsinhalts einfügen

Etwas am Ende des Beitragsinhalts einfügen

Du kannst die gleiche Logik verwenden, um am Anfang aller deiner Beiträge etwas hinzuzufügen, indem du die Position der String-Verkettungsparameter umkehrst (deine Zusätze" . $content).

Anpassen der WordPress-Anmeldeseite mit Hooks

Lass uns sowohl Aktionen als auch Filter verwenden, um die Standard-Anmeldeseite von WordPress anzupassen. Dazu werde ich ein neues Plugin namens Sal Custom Login Page erstellen. Den vollständigen Quellcode dieses Plugins findest du am Ende dieses Abschnitts.

Der finale angepasste WordPress-Anmeldebildschirm

Der finale angepasste WordPress-Anmeldebildschirm

Fangen wir an, indem wir die Standard-Plugin-Header-Felder hinzufügen und es bei WordPress registrieren.

<?php

/*
Plugin Name:  Sal Custom Login Page
Version:  1.0
Description:  Demonstrating WordPress Hooks (Actions and Filters) by customizing the WordPress login page.
Author:  Salman Ravoof
Author URI:  https://www.salmanravoof.com/License: GPLv2 or later
License URI: https://www.gnu.org/licenses/gpl-2.0.html
Text Domain:  sal-custom-login-page
*/

// enqueueing the custom style sheet on WordPress login page
add_action( 'login_enqueue_scripts', 'salhooks_login_stylesheet');
function salhooks_login_stylesheet() {
    // Load the style sheet from the plugin folder
    wp_enqueue_style( 'sal-custom-login-page', plugin_dir_url( __FILE__ ).'sal-custom-login-page-styles.css' );
}

Zuerst musst du dich in die Aktion login_enque_scripts einklinken, um dein benutzerdefiniertes Stylesheet in die Warteschlange zu stellen. Alle Skripte oder Styles, die du hier in die Warteschlange stellst, sind in der Kopfzeile deiner Login-Seite enthalten.

Wenn du benutzerdefinierte Skripte und Stylesheets in das Frontend deiner Webseite laden willst (und nicht in das Admin-Backend oder den Login-Bereich), dann brauchst du die wp_enqueue_scripts-Aktion. Du kannst mehr darüber im WordPress-Codex und in Kinstas Artikel über die Verwendung von wp_enqueue_scripts lesen.

Innerhalb der salhooks_login_stylesheet()-Callback-Funktion, benutze die wp_enqueue_style()-Funktion, um das benutzerdefinierte Stylesheet (sal-custom-login-page-styles.css) zu laden, das sich im Verzeichnis desselben Plugins befindet. WordPress‘ eingebaute plugin_dir_url( __FILE__ ) Funktion macht es einfach, den URL-Pfad (mit einem abschließenden Schrägstrich) des aktuellen Plugin-Verzeichnisses zu ermitteln.

Ich werde hier nicht die angewandten CSS-Stile erklären, aber du kannst sie alle im Quellcode finden, der am Ende dieses Abschnitts verlinkt ist.

// Custom login ERROR message to keep the site more secure
add_filter( 'login_errors', 'salhooks_remove_login_errors', 10 );
function salhooks_remove_login_errors() {
    return 'Incorrect credentials. Please try again!';
}

Als nächstes hakst du dich in den Filter login_errors ein, um die Fehlermeldung zu ändern, die angezeigt wird, wenn jemand falsche Anmeldedaten eingibt. Das Filtern der Fehlermeldung wird Angreifer daran hindern, deinen Benutzernamen leicht zu erraten.

// Remove the login form box shake animation for incorrect credentials
add_action( 'login_head', 'remove_login_error_shake' );
function remove_login_error_shake() {
    remove_action( 'login_head', 'wp_shake_js', 12 );
}

Jedes Mal, wenn jemand falsche Anmeldedaten eingibt, schüttelt die Login-Formularbox aggressiv. Dies ist ein optionaler Schritt, aber ich habe ihn eingefügt, um zu zeigen, dass man bestimmte Funktionen auch von der Login-Seite entfernen kann.

Mehr über die remove_action() und remove_filter() -Funktionen erfährst du im letzten Abschnitt dieses Artikels.

// Change the logo and header link above the login form
add_filter( 'login_headerurl', 'salhooks_login_headerurl');
function salhooks_login_headerurl( $url ) {
    $url = 'https://salmanravoof.com';
    return $url;
}

add_filter( 'login_headertext', 'salhooks_login_headertext');
function salhooks_login_headertext( $text ) {
    $text = 'Salman Ravoof';
    return $text;
}

Der letzte Schritt besteht darin, die URL und den Text des Login-Headers zu ändern. Du kannst dich in die Filter login_headerurl und login_headertext einklinken, um sie beide zu ändern.

Wenn du auf diesem Plugin aufbauen und weiter experimentieren möchtest, kannst du den Quellcode des Plugins herunterladen und loslegen

WordPress Hooks Liste und Ressourcen

Es ist schwer, sich all die verschiedenen Hooks von WordPress zu merken. Es gibt tausende von eingebauten Aktionen und Filtern, in die man sich einklinken kann. Daher kann sich das Finden eines passenden Hooks manchmal wie eine Schnitzeljagd anfühlen.

Glücklicherweise gibt es verschiedene Ressourcen, die du nutzen kannst, um den perfekten Hook für deine Bedürfnisse zu finden.

Der erste Ort, an dem man sich mit Hooks vertraut machen kann, ist der WordPress Codex, insbesondere die Hooks-Sektion im Plugin-Handbuch. Hier findest du wichtige Informationen über Hooks und Links zur vollständigen Dokumentation aller Aktionen und Filter.

Fang an, Hooks mit dem WordPress Plugin-Handbuch zu lernen

Fang an, Hooks mit dem WordPress Plugin-Handbuch zu lernen

Setze ein Lesezeichen für diese hilfreichen Links aus dem Plugin-Handbuch, um deine Suche zu beschleunigen:

Sowohl die Aktions- als auch die Filter-Referenzseiten geben dir eine Liste aller Hooks, die normalerweise während einer bestimmten WordPress-Anfrage laufen.

Du kannst zum Beispiel alle Hooks finden, die beim Zugriff auf eine Admin-Seite, beim Umgang mit Anhängen von Postingseiten oder mit Kategorien ausgelöst werden.

Der WordPress Codex enthält auch ein praktisches Suchtool, um alle seine Funktionen, Hooks, Methoden und Klassen zu finden. Diese Seite listet auch neue und aktualisierte Komponenten in der neuesten Version von WordPress auf. Kommt zuerst hierher, wenn ihr herausfinden wollt, was in WordPress passiert.

Hier kannst du nach allem innerhalb von WordPress suchen

Hier kannst du nach allem innerhalb von WordPress suchen

Dieser Index von WordPress Hooks sortiert alle Hooks nach Typ, der WordPress Version, die sie debütiert haben, und ob sie veraltet sind.

Adam R Browns WordPress Hooks Index

Adam R Browns WordPress Hooks Index

Wenn du die Hooks nach ihrem Aussehen sortierst, wirst du sehen, dass die ältesten WordPress Hooks immer noch die meistbenutzten sind. Wenn du neu in der WordPress-Entwicklung bist, ist es der schnellste Weg, sich mit diesen beliebten Aktionen und Filtern vertraut zu machen.

Obwohl dieser Index seit WordPress 5.1 nicht mehr aktualisiert wurde, ist es trotzdem hilfreich, alle wichtigen Hooks zu überfliegen.

Fällt es dir immer noch schwer, den gewünschten Hook zu finden? Eine Online-Suche mit dem richtigen Stichwort ist immer ein guter Anfang. Wenn alles andere fehlschlägt, kannst du dich jederzeit in den WordPress-Code einarbeiten.

Auf einer WordPress-Seite registrierte Hooks finden

Wie wir gesehen haben, hat WordPress tonnenweise Hooks zur Verfügung, aber nicht jeder Hook feuert auf jeder Seite. Wenn du herausfinden kannst, in welche Aktionen und Filter du dich auf einer bestimmten Seite einklinken kannst, dann hast du die halbe Schlacht gewonnen.

Während du fortgeschrittene PHP-Debugging-Werkzeuge wie xdebug und PHPCS nutzen kannst, um dir dabei zu helfen, gibt es einfachere Entwicklungswerkzeuge wie Debug Bar und Query Monitor, die du innerhalb von WordPress laufen lassen kannst.

Debug Bar mit Aktionen und Filter Add-On

Debug Bar ist ein offizielles WordPress-Plugin, das ein Debug-Menü zu deiner Admin-Leiste hinzufügt. Es zeigt PHP-Warnungen und Hinweise, Cache-Anfragen, MySQL-Abfragen und andere hilfreiche Debugging-Informationen an.

Info

Dieses Plugging wurde weder kürzlich aktualisiert, noch mit den neuesten Hauptversionen von WordPress getestet. Wir erwähnen es als ein praktisches Plugin, um mehr über WordPress Hooks zu lernen. Benutze es in einer Staging-Umgebung.

Das WordPress Debug Bar WordPress-Plugin

Das WordPress Debug Bar WordPress-Plugin

Nachdem du das Plugin installiert hast, benötigst du den untenstehenden Code-Schnipsel in der wp-config.php-Datei deiner Webseite, um die Debugging-Funktionen zu aktivieren.

define( 'WP_DEBUG', true ); // tracks PHP Warnings and Notices
define( 'SAVEQUERIES', true ); // tracks and displays MySQL queries

Du solltest jetzt die Debug-Menüoption in deiner Admin-Leiste sehen. Wenn du darauf klickst, gelangst du zu ihrem Dashboard, wo du verschiedene Abfragen und Caches sehen kannst, die an die Seite angehängt sind, von der aus du sie aufgerufen hast.

Das 'Debug'-Menü in der WordPress-Administrationsleiste

Das ‚Debug‘-Menü in der WordPress-Administrationsleiste

Als nächstes brauchst du das Debug Bar Actions and Filters Addon Plugin zu installieren. Es ist eine praktische Erweiterung, die zwei weitere Tabs zu deinem Debug Bar Dashboard hinzufügt, um Aktionen und Filter anzuzeigen, die bei der aktuellen Anfrage ausgelöst wurden.

Aktionen in der Reihenfolge, in der sie für die aktuelle Seite geladen wurden

Aktionen in der Reihenfolge, in der sie für die aktuelle Seite geladen wurden

Außerdem werden alle Funktionen mit ihrer Priorität aufgelistet, die an sie angeschlossen sind.

Filter aufgelistet mit ihrer Priorität und registrierten Callback-Funktionen

Filter aufgelistet mit ihrer Priorität und registrierten Callback-Funktionen

Du kannst von jeder Seite deiner Webseite aus auf das Debug-Menü klicken, um alle Aktionen und Filter zu kennen, die du auf dieser Seite ausführen kannst.

Query Monitor

Query Monitor ist ein leistungsstarkes Entwicklerwerkzeug-Panel für WordPress. Du kannst es benutzen, um die auf einer Seite verfügbaren Hooks und ihre Ladereihenfolge zu ermitteln.

Query Monitor WordPress Plugin

Query Monitor WordPress Plugin

Anders als bei der Debug Bar musst du keine Addons installieren, um die Aktionen und Filter zu sehen, die auf einer bestimmten Seite ausgelöst werden.

Du kannst den Query Monitor von der Admin Bar aus aufrufen

Du kannst den Query Monitor von der Admin Bar aus aufrufen

Query Monitor gibt dir auch mehr Informationen darüber, von wo genau ein Hook abgefeuert wird.

Das Hooks & Actions Panel im Query Monitor

Das Hooks & Actions Panel im Query Monitor

In der Komponenten-Spalte siehst du, dass die meisten Hooks vom Core registriert werden. Aber einige Hooks werden von einem Theme oder Plugin registriert. Einige wenige Hooks können von mehr als einer Komponente registriert werden.

Du kannst die Dropdown-Menüs für Hooks und Komponenten verwenden, um nur die Hooks anzuzeigen, die du benötigst.

Hinweis: Query Monitor verwendet „Hooks“ als Sammelbegriff sowohl für Aktionen als auch für Filter, ruft aber die registrierten Callback-Funktionen als „Actions“ auf. Dies ist technisch gesehen eine falsche Definition und kann dich verwirren, also behalte das im Hinterkopf.

Mit Query Monitor kannst du mehr tun, als nur alle Anfragen und Wünsche überprüfen. Er enthält auch fortgeschrittene Funktionen wie Listenstile, Skripte, Sprachen, Ajax-Aufrufe, Überprüfung der Benutzerfähigkeiten und REST API-Aufrufe.

Der „all“ Hook

WordPress hat einen speziellen Hook namens ‚all‘, in den du dich einklinken kannst, um eine Callback-Funktion für jeden einzelnen Hook auszuführen, unabhängig davon, ob er bei allen registriert ist. Er ist nützlich, um Seitenabstürze zu debuggen oder wenn du wissen willst, wann ein bestimmtes Ereignis stattfindet.

Zum Beispiel kannst du den all-Hook wie im Beispiel unten verwenden, um alle Aktionen, die gerade ausgeführt werden, zu echoen.

// echo all the actions being run
function debug_helper_function(){
    echo '<p>' . current_action() . '</p>';
}
add_action( 'all', 'debug_helper_function' );

Die oben definierte debug_helper_function() wird ausgeführt, wenn eine Aktion ausgelöst wird. Wenn du weißt, was die letzte ausgeführte Aktion war, kannst du dir besser vorstellen, wo du nachschauen musst.

Wo werden WordPress Hooks gelagert?

WordPress benutzt die WP_Hook Klasse, um die Funktionsweise von Hooks zu implementieren. Diese Kernklasse wird verwendet, um alle eingebauten WordPress-Aktionen und Filter zu handhaben. Du kannst fast den gesamten Code zu dieser Klasse in der wp-includes/class-wp-hook.php Datei finden.

Technisch gesehen ist die WP_Hook-Klasse ein Array von Objekten mit Eigenschaften wie Callbacks, Iterationen, current_priority, nesting_level und doing_action. Sie definiert auch eine Menge nützlicher Hook-Funktionen, die mit den WP_Hook-Methoden aufgerufen werden können.

Die meisten WordPress-Entwickler müssen sich nicht viel Gedanken darüber machen, wo WordPress Hooks speichert, solange sie sich an die Richtlinien der Plugin-API halten.

Es gibt zwei Arten von WordPress Hooks: Aktionen und Filter, und diese Anleitung schlüsselt genau auf, wann (und wie!) jeder dieser Hooks zu benutzen ist 💥Click to Tweet

Wie du deine eigenen WordPress Hooks erstellst

Du hast die verschiedenen Hooks gesehen, die WordPress dir über seine Plugin-API bietet. Du hast dir auch angeschaut, wie du die Standard-Hooks benutzen kannst, um deinen eigenen Code in die WordPress Runtime einzufügen.

Wenn du ein Plugin- oder Theme-Entwickler bist, ist es eine gute Idee, anderen Entwicklern eine Möglichkeit zu bieten, auf die gleiche Weise mit deinem Code zu interagieren. Mit benutzerdefinierten Hooks kannst du genau das tun. Sie ermöglichen es anderen Entwicklern, die Funktionalität deiner Plugins und Themes zu erweitern und zu verändern.

Eigene Aktionen und Filter zu erstellen ist ziemlich einfach. Du benutzt die gleichen Funktionen, die WordPress Core zum Erstellen von Hooks verwendet. Schauen wir uns ein paar Beispiele an.

Wie man benutzerdefinierte Aktionen in WordPress erstellt

Benutze die do_action()-Funktion, um einen eigenen Action Hook zu erstellen. Hier siehst du, wie du es machst:

// the position where you insert your action is where it'll run when called
do_action( ' my_unique_custom_action' );
// continue with the rest of your code

Jetzt können sich andere Entwickler in dein Plugin oder Theme einklinken, ohne den Quellcode zu verändern. Alles was sie tun müssen, ist ihre Callback-Funktionen mit der add_action()-Funktion in der benutzerdefinierten Aktion deines Plugins zu registrieren.

add_action( 'my_unique_custom_action', 'some_callback_function' );

// define the callback function you mentioned in the above action function
some_callback_function() {
     // this code will run wherever your custom action hook is 
}

Stelle sicher, dass du deine Custom Hooks gründlich dokumentierst und erklärst, was sie im Detail tun. Schließlich dient das Erstellen von benutzerdefinierten Hooks hauptsächlich dazu, anderen Entwicklern bei der Interaktion mit deinem Code zu helfen.

Wie man einen benutzerdefinierten Filter in WordPress erstellt

Benutze die apply_filters()-Funktion, um einen benutzerdefinierten Filter-Hook zu erstellen. Hier siehst du, wie du es machen kannst:

$value_to_filter = "I'm a string, but this can be any PHP data type";

// filters modify a value and are typically tied to a predefined variable
apply_filters( 'my_custom_filter', $value_to_filter );

Die Parameter deines benutzerdefinierten Filters sollten eine eindeutige Kennung und einen zu filternden Wert enthalten. Andere Entwickler können sich mit der add_filter()-Funktion in deinen benutzerdefinierten Filter einklinken und den übergebenen Wert ändern.

add_filter( 'my_custom_filter', 'some_callback_function' );

// define the callback function you mentioned in the above filter function
function some_callback_function( $value_to_filter ) {
    // modify the passed value (or not) 
    return $value_to_filter; // returning a value is a must for filters
}

Wenn du deinen benutzerdefinierten Filter definierst, stelle sicher, dass er nicht vor dem Wert positioniert ist, den er filtern soll. Wenn du den Filter nicht richtig positionierst, wird der gefilterte Wert danach mit dem Standardwert überschrieben.

Konvention zur Benennung von Custom Hooks

Es ist wichtig, einen eindeutigen Namen für alle deine Custom Hooks zu wählen. Da jedes Plugin oder Theme seine eigenen benutzerdefinierten Hooks haben kann es bei identischen Hook-Namen zu Code-Kollisionen mit unerwarteten Ergebnissen kommen.

Wenn du zum Beispiel deiner Aktion send_email einen Namen gibst, ist es sehr wahrscheinlich, dass andere Plugin-Entwickler ebenfalls den gleichen Begriff wählen, da er nicht eindeutig genug ist. Wenn irgendeine Webseite sowohl deine als auch die Plugins der anderen Entwickler installiert, kann es zu Fehlern kommen, die schwer zu verfolgen sind.

Du kannst allen deinen benutzerdefinierten Hooks einen gemeinsamen Bezeichner voranstellen, um sie einfach und einzigartig zu halten. Anstelle von send_email kannst du es also plugin_name_send_email nennen (plugin_name_ ist hier der einzigartige Präfix).

Custom Hooks Demo mit einem erweiterbaren Plugin

Lasst uns ein erweiterbares Plugin (oder ein Pluggable-Plugin) erstellen, das es anderen Entwicklern erlaubt, mit ihm zu interagieren, indem sie seine eigenen Hooks benutzen.

Ich werde dieses Plugin Custom Hooks Demo nennen. Seine Hauptfunktion ist es, eine Zitatbox auszugeben, wo immer du einen Shortcode einfügst. Es wird benutzerdefinierte Aktionen und Filter an den richtigen Stellen enthalten, um es anderen Entwicklern zu ermöglichen, die Funktionalität des Plugins zu verändern oder zu erweitern.

Du kannst in meinem WordPress Shortcodes Guide nachschlagen, um mehr darüber zu erfahren, wie Shortcodes funktionieren.

Lasst uns mit dem erweiterbaren Plugin anfangen.

<?php

/*
Plugin Name :  Custom Hooks Demo
Description :  Demonstrating how to create an extensible WordPress plugin using custom hooks.
Author      :  Salman Ravoof
Author URI  :  https://salmanravoof.com/
License     :  GPLv2 or later
License URI :  https://www.gnu.org/licenses/gpl-2.0.html
Text Domain :  custom-hooks-demo
*/

/** 
 * the [custom_hooks_demo] shortcode returns the HTML code for a quote box.
 * @return string HTML code for a quote box
*/
add_shortcode( 'custom_hooks_demo', 'my_shortcode_callback' );

function my_shortcode_callback ( $arguments ) {
    ob_start(); // start object buffering to collect all output before sending it to the browser
    
    // set an action hook to run before you output anything
    do_action( 'the_topmost_custom_action' );
    
    // define your variables which you want to allow to be filtered
    $quote_content = "Z.E.R.O. That's the number of people who'd like to have any website autoplay music on their browsers.";
    $quote_author = "John Doenuts";
    
    // create your custom filters after you've set the variables
    $quote_content = apply_filters( 'custom_quote_content', $quote_content );
    $quote_author = apply_filters( 'custom_quote_author', $quote_author );
    
    // build the shortcode output template
    echo "<div style=\"border:3px solid #5333ed;\"><blockquote style=\"margin:20px;border-color:#5333ed;\">";
    echo $quote_content;
    echo "<br><br>";
    echo "― <strong>" . $quote_author . "</strong>";
    echo "</blockquote></div>";
    
    // set an action hook to run after you output everything
    do_action( 'the_ending_custom_action' );
    
    return ob_get_clean(); // get buffer contents, delete the buffer, and then stop buffering
}

Sobald sie gespeichert und aktiviert ist, wird beim Hinzufügen des [custom_hooks_demo] Shortcodes zu deinem Post-Inhalt eine Zitatbox mit den Standardwerten ausgegeben.

Die originale Zitat-Box mit dem Custom Hooks Demo-Plugin

Nun lasst uns ein weiteres Plugin namens Custom Hooks Demo Extension erstellen. Es wird sich in alle benutzerdefinierten Hooks einklinken, die vom vorherigen Plugin erstellt wurden, und etwas tun oder ändern.

<?php

/*
Plugin Name :  Custom Hooks Demo Extension
Description :  Demonstrating how you can extend WordPress plugin functionality with its custom hooks.
Author      :  Salman Ravoof
Author URI  :  https://salmanravoof.com/
License     :  GPLv2 or later
License URI :  https://www.gnu.org/licenses/gpl-2.0.html
Text Domain :  custom-hooks-demo-extension
*/

/**
 * replace the quote content by hooking into the 'custom_quote_content' filter
*/
add_filter( 'custom_quote_content', 'new_quote_content_callback' );
function new_quote_content_callback( $content ) {
    $content = "There are no bugs in programming. Only unexpected features.";
    return $content;
}

/**
 * replace the quote author by hooking into the 'custom_quote_author'
*/
add_filter( 'custom_quote_author', 'new_quote_author_callback' );
function new_quote_author_callback( $author ) {
    $author = "Jane Doodle";
    return $author;
}

/**
 * add an image to the top of the shortcode output by hooking into the 'the_topmost_custom_action'
*/
add_action( 'the_topmost_custom_action', 'quote_image_callback' );
function quote_image_callback() {
    $url = "https://upload.wikimedia.org/wikipedia/commons/thumb/f/f9/Quote-right-cs.svg/75px-Quote-right-cs.svg.png";
    echo '<div><img class="aligncenter" src="'.$url.'"></div>';
}

/**
 * add a button below the shortcut output by hooking into the 'the_ending_custom_action'
*/
add_action( 'the_ending_custom_action', 'add_button_callback' );
function add_button_callback() {
    echo '<div style="text-align:center;"><button name="nice">Nice Quote!</button></div>';
}

Wie ihr sehen könnt, enthält dieses Erweiterungsplugin nichts anderes als Action- und Filterfunktionen, die sich an den richtigen Stellen in das Originalplugin einklinken, um Modifikationen vorzunehmen.

Es benutzt die add_action() und add_filter() Funktionen, um seine Callback-Funktionen mit den benutzerdefinierten Aktionen und Filtern zu registrieren, die vom Original-Plugin erstellt wurden (z.B. the_topmost_custom_action, custom_quote_author).

Das Erweiterungs-Plugin modifiziert die originale Zitat-Box

Benutzerdefinierte Action-Hooks erlauben es dir, deinen Code in den richtigen Intervallen in das Original-Plugin einzufügen und deine eigenen Skripte auszuführen. Hier fügen wir oben ein Bild und unten einen Button ein.

Ebenso lassen sich mit benutzerdefinierten Filterhooks die Werte des Zitatinhalts und der Name des Autors ändern. Das ultimative Ergebnis ist ein Plugin, das von jedem vollständig erweiterbar ist, ohne seinen Quellcode zu verändern.

Arbeiten mit Custom Hooks von Third-Party-Entwicklern

Benutzerdefinierte Hooks ermöglichen es den einzelnen WordPress Plugins und Themes ein reichhaltiges Ökosystem von erweiterbaren Plugins zu haben. Betrachte das WooCommerce-Plugin. Es fügt E-Commerce-Funktionalität zu WordPress hinzu, aber es enthält auch Tonnen von Hooks in seinem Code.

WooCommerce Aktion und Filter Hook Referenz

WooCommerce hat hunderte von Erweiterungen und Plugins die seine Hooks nutzen, um auf seiner Kernfunktionalität aufzubauen und sie noch besser zu machen.

Du kannst diese Erweiterungen verwenden, um WooCommerce mit Stripe, MailChimp, Salesforce, Zapier und vielem mehr zu integrieren.

Erweiterungen erweitern die Funktionalität von WooCommerce

Eine gute Praxis ist es, in der Dokumentations-Sektion der populären WordPress-Plugins nachzuschauen, wie sie benutzerdefinierte Hooks implementieren. Ein paar meiner Top-Vorschläge sind Easy Digital Downloads, BuddyPress, Quiz and Survey Master, und Gravity Forms.

Wann benutzt man Custom Hooks?

Je nachdem, welches Theme oder Plugin ihr erstellt, und für wen es bestimmt ist, werdet ihr euch fragen, ob ihr irgendwelche benutzerdefinierten Hooks benötigt.

Eine gute Faustregel bei der Entscheidung, ob du benutzerdefinierte Hooks hinzufügst oder nicht, ist es zu prüfen, ob sie anderen Entwicklern Vorteile bei der Erweiterbarkeit bieten. Wenn nicht, dann ist es besser, sich zurückzuhalten, bis andere Entwickler dich bitten, sie hinzuzufügen.

Du brauchst eine hohe Sicherheit, wenn du benutzerdefinierte Hooks zu deinem Plugin oder Theme hinzufügst. Sobald es veröffentlicht ist, und wenn andere Entwickler es bereits benutzt haben, kannst du es nicht mehr ändern, ohne die Rückwärtskompatibilität zu brechen.

Entfernen von Callback-Funktionen aus WordPress Hooks

Du hast bereits Beispiele gesehen, wie man Callback-Funktionen, die für bestimmte Hooks registriert sind, entfernen kann. Diese Callbacks könnten von Plugins, Themes oder sogar vom WordPress Core selbst registriert werden. Schauen wir uns das Entfernen von Hook-Callback-Funktionen mit weiteren Beispielen an.

Um eine Callback-Funktion von einem Hook zu entfernen, je nachdem, ob sie für eine Aktion oder einen Filter registriert ist, benötigt ihr die remove_action() oder remove_filter() Functionen.

Ein Vorbehalt ist, dass du diese Funktionen mit den identischen Parametern aufrufen musst, die für die Registrierung der Callback-Funktion verwendet werden. Grundsätzlich musst du die Parameter aus ihren add_action() oder add_filter() Functionen.

Außerdem kannst du Callback-Funktionen erst entfernen, wenn sie registriert sind. Wenn du versuchst, sie zu entfernen, bevor sie registriert sind, wird der Entfernungsprozess fehlschlagen. Du brauchst die richtige Ausführungsreihenfolge der Hooks..

Nehmen wir an, du möchtest eine Callback-Funktion entfernen, die von einem Theme registriert wurde und deine Webseite aufbläht (du möchtest eine schnelle Webseite, nicht wahr?).

function wp_bloated_callback_function() {    
// some code that adds a lot of bloat to the site
}
add_action( 'template_redirect', 'wp_bloated_callback_function', 5 );

Zum Beispiel könnte die obige Callback-Funktion viele unnötige Skripte und Stylesheets laden. Wenn du sie entfernst, wird deine Webseite einen enormen Leistungsschub erhalten.

Du musst jedoch sicherstellen, dass die remove_action()-Funktion erst nach der remove_action() -Aktion ausgeführt wird. Eine Möglichkeit, dies zu erreichen, ist, sich in die template_redirect-Aktion einzuklinken, wenn sie nach der after_setup_theme action as it’s triggered after the template_redirect-Aktion ausgelöst wird.

function wp_remove_bloat() {
    // ensure all parameters are identical to the original add_action() function
    remove_action( 'template_redirect', 'wp_bloated_callback_function', 5 );
}

// ensure that remove_action() is called only after add_action()
add_action( 'after_setup_theme', 'wp_remove_bloat' );

Die wp_bloated_callback_function() wird sich nun von der template_redirect-Aktion abkoppeln.

Spezialfälle für das Entfernen von Callback-Funktionen

Es gehört mehr dazu, Callback-Funktionen zu entfernen, als sie einfach nur komplett zu deaktivieren. Manchmal benötigst du sie vielleicht vorübergehend zu entfernen, deinen Code auszuführen und sie dann wieder hinzuzufügen.

Zum Beispiel feuert die save_post-Aktion jedes Mal, wenn die wp_insert_post() und wp_publish_post()-Funktionen aufgerufen werden. Du kannst sie beide in der wp-includes/post.php-Datei definiert finden.

Wenn du also eine Callback-Funktion hast, die mit der save_post-Aktion verbunden ist, und wenn du die wp_insert_post() oder wp_publish_post()-Funktionen innerhalb deiner Callback-Funktion aufrufst, wird diesave_post-Aktion mehrfach ausgelöst.

function some_callback_function( $post_id, $post ) {
    // do something here
    wp_insert_post( [some_array] ); // this function also calls the 'save_post' action
    // maybe do something more
}
add_action( 'save_post', 'some_callback_function', 10, 2 );

Eine Funktion, die die Aktion aufruft, die sie auch aufruft, kann zu unerwarteten Ergebnissen führen. Eine Möglichkeit, dieses Problem zu umgehen, ist, die remove_action() -Funktion innerhalb deiner Callback-Funktion zu verwenden, bevor du wp_insert_post() aufrufst.

function some_callback_function( $post_id, $post ) {
    // do something here
    
    // remove the callback function from the ‘save_post’ action
    remove_action( 'save_post', 'some_callback_function', 10, 2 );
    
    // now run the wp_insert_post() function
    wp_insert_post( [some_array] );
    
    // add the callback function back to the ‘save_post’ action
    add_action( 'save_post', 'some_callback_function', 10, 2 );
    
    // maybe do something more
}
add_action( 'save_post', 'some_callback_function', 10, 2 );

Das ist eine weitere praktische Anwendung der remove_action() oder remove_filter()-Funktionen. Wenn du tiefer in den WordPress-Kern gräbst, wirst du verstehen, wie du solche Situationen besser vermeiden kannst.

Bonus WordPress Hooks Tutorials

WordPress Hooks sind eines der wichtigsten Werkzeuge, die man im Arsenal eines WordPress Entwicklers haben sollte. 💪 Lerne in diesem Leitfaden den Unterschied zwischen Aktionen und Filtern (und wie man sie benutzt)!Click to Tweet

Zusammenfassung

Es gibt mehrere Vorteile, WordPress Hooks zu benutzen, wenn du ein WordPress Entwickler bist.

Mit den Hooks kannst du nicht nur die Kernfunktionalität von WordPress verändern oder erweitern, sondern auch Plugins und Themes modifizieren und andere Entwickler mit deinen Plugins oder Themes interagieren lassen.

Es ist an der Zeit, süchtig nach WordPress Hooks zu werden!


Wenn Dir dieser Artikel gefallen hat, dann wirst du Kinsta’s WordPress Hosting-Plattform lieben. Beschleunige deine Webseite und erhalte 24/7 Support von unserem erfahrenen WordPress-Team. Unsere Google Cloud basierte Infrastruktur konzentriert sich auf die Bereiche Auto-Scaling, Performance und Sicherheit. Lass uns dir den Kinsta-Unterschied zeigen! Schau Dir hier unsere Pakete an