Das WordPress Hooks Bootcamp: Wie man Aktionen, Filter und benutzerdefinierte Hooks verwendet

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.

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.

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.

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.

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.

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.

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.

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

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.

Ä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:

• Plugins: Erstelle dein eigenes Plugin und füge deinen ganzen eigenen Code darin ein.
• Child Themes: Registriere die Hooks und Callback-Funktionen in der php-Datei deines Child Themes.

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.

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.

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).

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.

• has_action()

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.

• do_action()

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.

• do_action_ref_array()

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.

• did_action()

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');

• remove_action()

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 );

• remove_all_actions()

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.

• doing_action()

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:

• get_header ist eine Aktion, die ausgelöst wird, bevor die Header-Template-Datei der Webseite geladen wird. Es ist eine perfekte Aktion, die man sich einklinkt, wenn man das Laden der Hauptseite unterbrechen will.
• Hook dich in die get_header-Aktion ein, indem du die add_action()-Funktion mit der maintenance_message()-Callback-Funktion verwendest.
• Definiere die maintenance_message()-Callback-Funktion.
• current_user_can( 'edit_posts' ) ist eine Benutzerfähigkeitstest-Funktion, die prüft, ob der aktuelle Benutzer eingeloggt ist und Beiträge bearbeiten kann. Jeder Benutzer, der auf einer WordPress Webseite registriert ist, mit Ausnahme derer, die die Rolle eines Abonnenten haben, hat die Fähigkeit, Beiträge zu bearbeiten. Es gibt andere robuste Methoden, um diese Prüfung durchzuführen, aber wir bleiben hier bei dieser einfachen Methode.
• Benutze die Standardfunktion wp_die(), um die Ausführung von WordPress zu beenden und eine HTML-Seite mit einer Fehlermeldung anzuzeigen. Du kannst die HTML-Syntax im Parameter „error message“ verwenden, um sie zu formatieren.

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

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:

• admin_menu ist eine Aktion, die ausgelöst wird, bevor das Admin-Menü im WordPress-Dashboard-Bereich geladen wird.
• Hake dich mit der add_action()-Funktion über die hide_admin_menus()-Callback-Funktion in die admin_menu-Aktion ein.
• Die hide_admin_menus()-Callback-Funktion definiert die Logik des Codes. Sie wird jedes Mal ausgeführt, wenn die Admin_menu-Aktion ausgelöst wird.
• Innerhalb der Callback-Funktion prüft die current_user_can( 'create_users' ) Funktion, ob der eingeloggte Benutzer ein Admin ist. Da nur Webseiten-Administratoren die create_user-Funktion haben, endet die Funktion mit einem Return-Statement, wenn der Benutzer ein Admin ist.
• Die WordPress-Funktion wp_get_current_user() ruft das aktuelle Benutzerobjekt ab. Mit dieser Funktion können wir überprüfen, ob der eingeloggte Benutzer einen bestimmten display_name gesetzt hat. Dies ist eine optionale Zeile, für den Fall, dass du bestimmte Nicht-Admin-Benutzer aufgrund dieser Callback-Funktion nicht aussperren möchtest.
• Die remove_menu_page() WordPress Funktion entfernt die Top-Level Admin-Menüs. Im obigen Codebeispiel entferne ich die folgenden Admin-Menüs: Plugins, Themes, Tools, Benutzer, Seiten und Optionen.

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

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

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.

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.

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.

• has_filter()

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' );
}

• apply_filters()

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.

• apply_filters_ref_array()

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.

• current_filter()

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.

• remove_filter()

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 ); 

• remove_all_filters()

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.

// 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' ) );
}

• doing_filter()

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.

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:

• comment_text ist ein Filter-Hook, mit dem du den Text eines Kommentars ändern kannst, bevor der Browser ihn anzeigt. Du kannst deine Callback-Funktion bei ihm registrieren, um seine Ausgabe zu filtern.
• Mit deradd_filter()-Funktion kannst du dich in den comment_text-Filter einklinken und ihm eine Callback-Funktion anhängen.
• the_profanity_filter() ist der Name der Callback-Funktion. Sie akzeptiert nur einen Parameter, nämlich einen String, der den Kommentartext enthält. Definiere diese benutzerdefinierte Funktion mit der entsprechenden Code-Logik.
• Speichere alle profanen Wörter in einem PHP-Array namens profaneWords. Du kannst diesem Array so viele Wörter hinzufügen, wie du willst. Die Größe dieses Arrays speichere ich mit Hilfe der PHP-Funktion sizeof() in der Variable profaneWordsCount.
• Gehe alle profanen Wörter durch und benutze die PHP-Standardfunktion str_ireplace(), um alle übereinstimmenden Schimpfwörter durch *-Symbole zu ersetzen. Da dies eine Funktion zum Ersetzen von Strings ohne Berücksichtigung der Groß- und Kleinschreibung ist, brauchst du dir keine Gedanken über Groß- und Kleinschreibung zu machen. Sieh dir die verschiedenen Möglichkeiten an, wie du eine Suche und Ersetzung durchführen kannst.
• Benutze return, um den gefilterten Kommentartext auszugeben.

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.

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

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:

• the_content filter Hook hilft dir, den Inhalt des aktuellen Beitrags zu erfassen und ihn anzupassen.
• Benutze die add_filter()-Funktion, um dich mit der insert_content_below()-Callback-Funktion in the_content-Filter einzuklinken.
• Definiere die Callback-Funktion, indem du den Inhalt des aktuellen Beitrags als Parameter übergibst ($content).
• Überprüfe innerhalb der Callback-Funktion, dass du nur den Inhalt der Hauptabfrage filterst, in diesem Fall den Inhalt des Beitrags. Wenn du dies nicht überprüfst, filtert der Code manchmal unbeabsichtigt Inhalte von anderen Stellen wie Seitenleisten und Fußzeilen.
• is_main_query() und in_the_loop() Bedingungen bestimmen, ob die Abfrage eine Hauptabfrage ist und innerhalb der WordPress Hauptschleife stattfindet.
• is_single() conditionals prüft, ob die Abfrage für einen einzelnen Beitrag ist.
• Benutze PHP’s String-Verkettungsoperator ($content . "deine Zusätze"), um zusätzliche Dinge zum Seiteninhalt hinzuzufügen.
• gib den gefilterten Kommentar zurück, wenn alle obigen conditionals zutreffen. Wenn nicht, dann gib einfach den Inhalt ohne Änderungen zurück.

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

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.

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.

• WordPress Plugin Handbook — Hooks

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.

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

• Plugin API — Hooks Funktionreferenz
• Plugin API — Aktionreferenz
• Plugin API — Filter-Refenenz

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.

• WordPress Code-Referenz

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.

• Adam R Browns WordPress Hooks Index

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

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.

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.

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.

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

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.

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.

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

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.

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
}

• Die add_shortcode()-Funktion wird verwendet, um den benutzerdefinierten Shortcode zu erstellen. Und dann definierst du die Callback-Funktion des Shortcodes mit all der Funktionalität dieses Plugins.
• ob_start() ist eine PHP-Funktion, die das Puffern der Ausgabe ermöglicht. Es ist eine superpraktische Funktion, die PHP anweist, jede Ausgabe im Pufferspeicher des Servers zu halten, anstatt sie sofort auszugeben. Du kannst sie benutzen, um komplexen, lesbaren HTML-Code in PHP zu erstellen.
• do_action( 'the_topmost_custom_action' ) definiert deine erste benutzerdefinierte Aktion. Um sie nützlich zu machen, benötigst du sie, bevor das Plugin etwas ausgibt. Andere Entwickler können sich in diese benutzerdefinierte Aktion einklinken, um ihren Code auszuführen, bevor dieser benutzerdefinierte Shortcode etwas ausgibt.
• Erstelle die Variablen, die du filtern möchtest. In diesem Plugin sind diese Variablen $quote_content und $quote_author. In diesem Beispiel sind das beides Strings, aber du kannst sie auf einen beliebigen PHP-Datentyp setzen (z.B. integer, boolean, array).
• Benutze die Funktion apply_filters(), um deine eigenen Filter zu erstellen. Da alle Filter einen Wert zurückgeben, kannst du dem Rückgabewert dieses Filters die zuvor definierten Variablen zuweisen. Andere Entwickler können sich nun in diesen Filter einklinken, um die Standardwerte der vordefinierten Variablen zu ändern.
• Benutze echo-Anweisungen, um die Ausgabe deines Shortcode Zeile für Zeile zu erstellen. Da wir die Ausgabepufferung aktiviert haben, wird keine Ausgabe sofort den Browser erreichen.
• do_action( 'the_ending_custom_action' ) definiert deine letzte benutzerdefinierte Aktion. Du brauchst sie ganz am Ende zu definieren, aber bevor du den ganzen Pufferinhalt zurückgibst.
• ob_get_clean() ist eine standardmäßige 3-in-1 PHP-Funktion. Sie wird den Pufferinhalt abrufen, alle Pufferdaten löschen und dann die Ausgabepufferung stoppen. Sie wird den gesammelten Pufferinhalt als einen einzelnen verketteten String zurückgeben.

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.

<?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>';
}

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 );

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' );

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 );

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 );

Salman Ravoof

Salman Ravoof ist ein autodidaktischer Webentwickler, Autor, Kreativer und ein großer Bewunderer von Free and Open Source Software (FOSS). Neben Technik begeistert er sich für Wissenschaft, Philosophie, Fotografie, Kunst, Katzen und Essen. Erfahre mehr über ihn auf seiner Website und trete mit Salman auf X in Kontakt.

• Webseite
• LinkedIn
• Twitter