Genaue PHP-Aktion ausführen. PHP und Formulare

„Verwenden Sie nicht die goto-Anweisung“- Das haben uns die Lehrer der Akademie gesagt, und tatsächlich bringt dieser Operator den Code völlig durcheinander. Die PHP-Entwickler haben das Problem radikal gelöst – es existiert einfach nicht in PHP3 und PHP4. Was war ihre ursprüngliche Motivation? Vielleicht wollten sie uns allen den richtigen Programmierstil vermitteln? Nun, wir können sagen, dass es ihnen völlig gelungen ist - wir sind alle bereits daran gewöhnt, das heißt, wir haben die Gewohnheit dieses Operators vollständig verloren, vielleicht ist es das Beste, weil ich einmal eine logische Konstruktion so vollständig finden musste entschädigte für dieses höchst bedauerliche gehe zu.
Ich weiß nicht, wie es bei irgendjemandem ist, aber bei mir hatte ich besonders oft den Wunsch, goto beim Erstellen eines HTML-Formularhandlers zu verwenden, wenn viele Daten vom Benutzer an den Server gesendet werden, was das PHP-Skript tun muss Überprüfen Sie Schritt für Schritt. Dieser Vorgang erfolgt in der Regel in mehreren Schritten: Drucken des Formulars selbst, Prüfung der empfangenen Daten, Voranzeige und beispielsweise Speichern. Darüber hinaus können sich einige Schritte wiederholen: Wenn die Datenüberprüfung nicht erfolgreich war, drucken wir das Formular aus, oder wenn die vorläufige Anzeige dem Benutzer nicht zusagt, kann er zur Dateneingabe zurückkehren. Kurz gesagt, einige Codeteile können mehrfach verwendet werden. Auch die Verwendung von Funktionen unter diesen Bedingungen ist nicht sehr praktisch – es gibt viele Eingabe- und Ausgabevariablen, die Funktion muss zu komplexe Aktionen ausführen, sie fällt im Allgemeinen ungeschickt aus und die Lesbarkeit des Codes nimmt stark ab.
Und ich habe mir dieses Design ausgedacht.

Tun ( switch ($action) ( Standard: brechen ; Fall „PRINT_FORM“ : Drucken des Hauptformulars brechen ; Fall „CHECK_FORM“: Überprüfung der Richtigkeit der Daten brechen ; Fall „PREVIEW_FORM“: Vorschau brechen ; Fall „SAVE_FORM“: Daten speichern brechen ; ) while (true) ;

Hier ist der grundlegende Mehrfachauswahloperator schalten gefangen in einer Endlosschleife tun-während– Auf diese Weise gruppieren wir die erforderlichen Aktionen in Abschnitte Fall: Pause; und wir können unbegrenzt von einem Abschnitt zum anderen wechseln. Im Abschnitt Standard: Es ist praktisch, eine vorläufige Analyse der Daten durchzuführen, wenn beispielsweise keine Eingabedaten vorhanden sind $action = 'PRINT_FORM' Drucken Sie das Formular beispielsweise aus, falls verfügbar $_POST ['submit'] Anschließend senden wir die empfangenen Daten zur Verarbeitung $action = 'CHECK_FORM'. Die Übertragung der Steuerung zwischen Schalterblöcken erfolgt durch Ändern einer Variablen $Aktion, nun ja, verlassen Sie die Schleife mit Pause 2; oder beenden;
Sie können es beispielsweise sicher in den Druckblock des Hauptformulars einfügen Pause 2; weil die Formularausgabe das Ende des Skripts voraussetzt.
Das Design ist sehr flexibel und lesbar. Es gibt jedoch einen Nachteil: Wenn die Daten falsch verarbeitet werden, kann es zu einer Endlosschleife kommen und das Skript friert ein. Es ist unangenehm, bis zu 30 Sekunden warten zu müssen.
Lassen Sie uns eine Grenze für die Anzahl der Bedienerzyklen festlegen tun-während, 20 ist genug. Wenn wir nun etwas aufpumpen, dreht das Skript 20 Umdrehungen, stoppt und gibt eine Notstopp-Warnung aus.
Es ist sehr praktisch, eine solche Konstruktion direkt nach dem Operator zu debuggen wechseln Drucken Sie die Variable $action aus und wir erhalten die vollständige Sequenz der Blockausführung.

DO ( // am Anfang jeder Schleife geben wir den Namen // des ausgeführten Abschnitts aus, sehr praktisch zum Debuggen echo $action." "; SWITCH ($action) ( Standard: break; case "PRINT_FORM": /* Hauptformular drucken */ break; case "CHECK_FORM": /* Überprüfen Sie, ob die Daten korrekt sind */ break; case "PREVIEW_FORM": /* Vorschau * / break ; case "SAVE_FORM": /* Daten speichern */ break )// end switch ) WHILE ((($i++)< 20) or die("Принудительный останов цикла"));

TUN( // Am Anfang jeder Schleife geben wir den Namen aus // Der ausgeführte Abschnitt ist sehr praktisch zum Debuggen echo $action . " " ;< / strong > SWITCH ($action) ( Standard: brechen ; Fall „PRINT_FORM“ : Drucken Sie das Hauptformular aus brechen ;

RxGroovy hat mehrere Do-Varianten.

• Javadoc:
• Javadoc:

• Javadoc:

Der doOnRequest-Operator (neu in RxGroovy 1.1) registriert eine Aktion, die immer dann aufgerufen wird, wenn ein Beobachter zusätzliche Elemente vom resultierenden Observable anfordert. Diese Aktion erhält als Parameter die Anzahl der Elemente, die der Beobachter anfordert.

• Javadoc:

• Javadoc:

• Javadoc:

• Javadoc:

• Javadoc:

Vor

• Javadoc:

nach Das resultierende Observable wird beendet, egal ob normal oder mit einem Fehler.

Beispielcode

def zahlen = Observable.from(); zahlen.finallyDo(( println("Endlich"); )).subscribe(( println(it); ), // onNext ( println("Error: " + it.getMessage()); ), // onError ( println ("Sequenz abgeschlossen") // onCompleted);

1 2 3 4 5 Sequenz abgeschlossen Endlich

• Javadoc:

RxJava verfügt über mehrere Do-Varianten.

Mit dem doOnEach-Operator können Sie einen Rückruf einrichten, den das resultierende Observable jedes Mal aufruft, wenn es ein Element ausgibt. Sie können diesen Rückruf entweder in Form einer Aktion übergeben, die eine onNext-Benachrichtigung als einzigen Parameter verwendet, oder Sie können einen Observer übergeben, dessen onNext-Methode aufgerufen wird, als ob sie das Observable abonniert hätte.

• Javadoc:
• Javadoc:

Der doOnNext-Operator ähnelt doOnEach(Action1), außer dass die Aktion, die Sie als Parameter übergeben, keine Benachrichtigung, sondern einfach das ausgegebene Element akzeptiert.

Beispielcode

Observable.just(1, 2, 3).doOnNext(new Action1 () ( @Override public void call(Integer item) ( if(item > 1) ( throw new RuntimeException("Item überschreitet maximalen Wert"); ) ) )).subscribe(new Subscriber () ( @Override public void onNext(Integer item) ( System.out.println("Next: " + item); ) @Override public void onError(Throwable error) ( System.err.println("Error: " + error .getMessage()); ) @Override public void onCompleted() ( System.out.println("Sequence Complete."); ) ));

Weiter: 1 Fehler: Artikel überschreitet den Maximalwert

• Javadoc:

Der doOnRequest-Operator (neu in RxJava 1.1) registriert eine Aktion, die immer dann aufgerufen wird, wenn ein Beobachter zusätzliche Elemente vom resultierenden Observable anfordert. Diese Aktion erhält als Parameter die Anzahl der Elemente, die der Beobachter anfordert.

• Javadoc:

Der doOnSubscribe-Operator registriert eine Aktion, die immer dann aufgerufen wird, wenn ein Beobachter das resultierende Observable abonniert.

• Javadoc:

Der doOnUnsubscribe-Operator registriert eine Aktion, die immer dann aufgerufen wird, wenn sich ein Beobachter vom resultierenden Observable abmeldet.

• Javadoc:

Der doOnCompleted-Operator registriert eine Aktion, die aufgerufen wird, wenn das resultierende Observable normal beendet wird und onCompleted aufruft.

• Javadoc:

Der doOnError-Operator registriert eine Aktion, die aufgerufen wird, wenn das resultierende Observable abnormal beendet wird, und ruft onError auf. Dieser Aktion wird das Throwable übergeben, das den Fehler darstellt.

• Javadoc:

Der doOnTerminate-Operator registriert eine Aktion, die gerade aufgerufen wird Vor Das resultierende Observable wird beendet, egal ob normal oder mit einem Fehler.

• Javadoc:

„finallyDo“ ist seit RxJava 1.1.1 veraltet, zugunsten von „doAfterTerminate“ mit demselben Verhalten.

Der „finalDo“-Operator registriert eine Aktion, die gerade aufgerufen wird nach Das resultierende Observable wird beendet, egal ob normal oder mit einem Fehler.

• Javadoc:

Der doAfterTerminate-Operator registriert eine Aktion, die gerade aufgerufen wird nach Das resultierende Observable wird beendet, egal ob normal oder mit einem Fehler.

• Javadoc:

RxJS implementiert den grundlegenden Do-Operator als do oder tap (zwei Namen für denselben Operator). Sie haben zwei Möglichkeiten, diesen Operator zu verwenden:

1. Sie können ihm einen Observer übergeben. In diesem Fall ruft do / tap die Methoden dieses Observers auf, als ob dieser Observer das resultierende Observable abonniert hätte.
2. Sie können einen Satz von 1–3 einzelnen Funktionen (onNext, onError und onCompleted) übergeben, die do / tap zusammen mit den gleichnamigen Funktionen aller ihrer Beobachter aufruft.

Beispielcode

/* Verwenden eines Beobachters */ var Observer = Rx.Observer.create(function (x) ( console.log("Do Next: %s", x); ), function (err) ( console.log("Do Error : %s", err); ), function () ( console.log("Do Completed"); )); var source = Rx.Observable.range(0, 3) .do(observer); var subscription = source.subscribe(function (x) ( console.log("Next: %s", x); ), function (err) ( console.log("Error: %s", err); ), function () ( console.log("Completed"); ));

/* Eine Funktion verwenden */ var source = Rx.Observable.range(0, 3) .do(function (x) ( console.log("Do Next:", x); ), function (err) ( console. log("Do Error:", err); ), function () ( console.log("Do Completed"); )); var subscription = source.subscribe(function (x) ( console.log("Next: %s", x); ), function (err) ( console.log("Error: %s", err); ), function () ( console.log("Completed"); ));

Nächstes tun: 0 Nächstes: 0 Nächstes tun: 1 Nächstes: 1 Nächstes tun: 2 Nächstes: 2 Abgeschlossen Abgeschlossen

RxJS implementiert auch doOnNext oder tapOnNext (zwei Namen für denselben Operator). Es handelt sich um eine spezielle Form von Do, die nur auf den onNext-Fall reagiert, indem sie eine Rückruffunktion aufruft, die Sie als Parameter angeben. Sie können optional auch einen zweiten Parameter übergeben, der aus Sicht Ihrer Callback-Funktion bei der Ausführung das „this“-Objekt ist.

Beispielcode

var source = Rx.Observable.range(0, 3) .doOnNext(function () ( this.log("Do Next: %s", x); ), console); var subscription = source.subscribe(function (x) ( console.log("Next: %s", x); ), function (err) ( console.log("Error: %s", err); ), function () ( console.log("Completed"); ));

Nächstes tun: 0 Nächstes: 0 Nächstes tun: 1 Nächstes: 1 Nächstes tun: 2 Nächstes: 2 Abgeschlossen

RxJS implementiert auch doOnError oder tapOnError (zwei Namen für denselben Operator). Es handelt sich um eine spezielle Form von Do, die nur auf den onError-Fall reagiert, indem sie eine Rückruffunktion aufruft, die Sie als Parameter angeben. Sie können optional auch einen zweiten Parameter übergeben, der aus Sicht Ihrer Callback-Funktion bei der Ausführung das „this“-Objekt ist.

Beispielcode

var source = Rx.Observable.throw(new Error()); .doOnError(function (err) ( this.log("Do Error: %s", err); ), console); var subscription = source.subscribe(function (x) ( console.log("Next: %s", x); ), function (err) ( console.log("Error: %s", err); ), function () ( console.log("Completed"); ));

Fehler machen: Fehler Fehler: Fehler

RxJS implementiert auch doOnCompleted oder tapOnCompleted (zwei Namen für denselben Operator). Es handelt sich um eine spezielle Form von Do, die nur auf den onCompleted-Fall reagiert, indem sie eine Rückruffunktion aufruft, die Sie als Parameter angeben. Sie können optional auch einen zweiten Parameter übergeben, der aus Sicht Ihrer Callback-Funktion bei der Ausführung das „this“-Objekt ist.

Beispielcode

var source = Rx.Observable.range(0, 3) .doOnCompleted(function () ( this.log("Do Completed"); ), console); var subscription = source.subscribe(function (x) ( console.log("Next: %s", x); ), function (err) ( console.log("Error: %s", err); ), function () ( console.log("Completed"); ));

Weiter: 0 Weiter: 1 Weiter: 2 Do Abgeschlossen Abgeschlossen

RxJS implementiert auch einen Final-Operator. Es benötigt eine Funktion, die aufgerufen wird, nachdem das resultierende Observable beendet wurde, sei es normal (onCompleted) oder abnormal (onError).

Beispielcode

var source = Rx.Observable.throw(new Error()) .finally(function () ( console.log("Finally"); )); var subscription = source.subscribe(function (x) ( console.log("Next: " + x); ), function (err) ( console.log("Error: " + err);), function () ( console .log("Abgeschlossen");

Fehler: Fehler endlich

do / tap , doOnNext / tapOnNext , doOnError / tapOnError , doOnCompleted / tapOnCompleted und schließlich sind in jeder der folgenden Distributionen zu finden:

• rx.js
• rx.all.js
• rx.all.compat.js
• rx.compat.js
• rx.lite.js
• rx.lite.compat.js

RxPHP implementiert diesen Operator wie do .

Ruft eine Aktion für jedes Element in der beobachtbaren Sequenz auf und ruft eine Aktion bei ordnungsgemäßer oder außergewöhnlicher Beendigung der beobachtbaren Sequenz auf. Diese Methode kann zum Debuggen, Protokollieren usw. verwendet werden. des Abfrageverhaltens durch Abfangen des Nachrichtenstroms, um beliebige Aktionen für Nachrichten in der Pipeline auszuführen. Bei der Verwendung von do ist zu beachten, dass der Observer möglicherweise zusätzliche Ereignisse empfängt, nachdem ein Stream abgeschlossen wurde oder ein Fehler aufgetreten ist (z. B. bei Verwendung einer Wiederholung oder eines erneuten Abonnements). Wenn Sie ein Observable verwenden, das das AbstractObservable erweitert, erhalten Sie diese Ereignisse nicht. Verwenden Sie für diesen Sonderfall den DoObserver. doOnNext, doOnError und doOnCompleted nutzen intern den DoObserver und empfangen diese zusätzlichen Ereignisse.

Beispielcode

//von https://github.com/ReactiveX/RxPHP/blob/master/demo/do/do.php $source = \Rx\Observable::range(0, 3) ->do(function ($x) ( echo „Do Next:“, $x, PHP_EOL; ), function (Throwable $err) ( echo „Do Error:“, $err->getMessage(), PHP_EOL; ), function () ( echo „Do Completed“ , PHP_EOL; )); $subscription = $source->subscribe($stdoutObserver);

Do Next:0 Nächster Wert: 0 Do Next:1 Nächster Wert: 1 Do Next:2 Nächster Wert: 2 Do Completed Complete!

RxPHP hat auch einen Operator doOnError .

Beispielcode

//von https://github.com/ReactiveX/RxPHP/blob/master/demo/do/doOnError.php $source = \Rx\Observable::error(new Exception("Ups")) ->doOnError(function (Throwable $err) ( echo "Do Error:", $err->getMessage(), PHP_EOL; )); $subscription = $source->subscribe($stdoutObserver);

Führen Sie Fehler aus: Hoppla. Ausnahme: Hoppla

RxPHP hat auch einen Operator doOnCompleted .

Beispielcode

//von https://github.com/ReactiveX/RxPHP/blob/master/demo/do/doOnCompleted.php $source = \Rx\Observable::empty() ->doOnCompleted(function () ( echo „Do Completed ", PHP_EOL; )); $subscription = $source->subscribe($stdoutObserver);

Fertig Abgeschlossen!

RxPHP hat endlich auch einen Operator.

Ruft eine angegebene Funktion auf, wenn die Quelle bei Abschluss oder Fehler beendet wird.

Beispielcode

//von https://github.com/ReactiveX/RxPHP/blob/master/demo/finally/finally.php Rx\Observable::range(1, 3) ->finally(function() ( echo „Finally\n "; )) ->subscribe($stdoutObserver);

Nächster Wert: 1 Nächster Wert: 2 Nächster Wert: 3 Fertig! Endlich

//von https://github.com/ReactiveX/RxPHP/blob/master/demo/finally/finally-error.php Rx\Observable::range(1, 3) ->map(function($value) ( ​​​​if ($value == 2) ( throw new \Exception("error"); ) return $value )) ->finally(function() ( echo "Finally\n"; )) ->subscribe($stdoutObserver) ;

Nächster Wert: 1 Ausnahme: Fehler Endlich

Hängt die angegebene PHP-Funktion an den angegebenen Hook an. Die angegebene Funktion wird im Moment des Ereignisses ausgelöst, das wiederum mit do_action() ausgelöst wird.

Der Hook, an den sich die Funktion anhängt, wird mithilfe der Funktion do_action() erstellt (initialisiert).

Aktionen sind im Gegensatz zu Filtern (add_filter()) erforderlich, um eine Aktion zum richtigen Zeitpunkt auszuführen, während Filter Daten übertragen und zurückempfangen, die dann verwendet werden.

Inoffiziell: Filter sind die gleichen Ereignisse, sie funktionieren genauso und können als Ereignisse verwendet werden (anstelle von add_filter() können Sie die Funktion add_action() verwenden und umgekehrt). Sie können beispielsweise die empfangenen Daten zurückgeben, ohne sie zu ändern, aber zusätzlich einen Vorgang ausführen (z. B. in eine Datenbank schreiben). Dies wird zwar sehr selten benötigt. An allen Stellen, an denen es notwendig ist, in den Motorcode einzugreifen, versuchen die Entwickler vorherzusehen und an dieser Stelle ein Ereignis einzufügen.

✈ 1 Mal = 0,000018s = sehr schnell| 50000 Mal = 0,07 s = Lichtgeschwindigkeit| PHP 7.0.8, WP 4.7

Es gibt keine Haken.

Kehrt zurück

Immer wahr.

Verwendung

add_action($tag, $function_to_add, $priority, $accepted_args); $tag (Zeichenfolge) (erforderlich) Der Name der Aktion, an die wir die Funktion anhängen. $function_to_add (Zeichenfolge/Abschluss) (erforderlich) Der Name der Funktion, die aufgerufen werden soll, wenn die Aktion ausgelöst wird, d. h. eine Funktion, die wir an einen Haken anhängen. Das Funktionsübergabeformat ist normalerweise eine Zeichenfolge. $Priorität (Nummer) Priorität der Funktionsausführung. Wenn mehrere Funktionen an denselben Hook „angehängt“ werden, wird die Priorität durch die Reihenfolge ihrer Ausführung bestimmt. Eine kleinere Zahl bedeutet, dass die Ausführung früher erfolgt, d. h. 10 wird vor 20 ausgeführt.
Standard: 10$accepted_args (Nummer) Die Anzahl der Argumente, die die Funktion benötigt. Natürlich muss die Aktion diese Anzahl an Argumenten übergeben.
Standard: 1

Beispiele

#1 Normaler Haken

Wir werden einen Brief an Freunde senden, wenn ein neuer Beitrag veröffentlicht wird:

Add_action("publish_post", "email_friends"); Funktion email_friends($post_ID)( $friends = " [email protected], [email protected]"; wp_mail($friends, „sally“s Blog aktualisiert", „Ich habe gerade etwas in meinen Blog eingefügt: http://blog.example.com“); return $post_ID; )

Ebenso können Sie diesen Hook über add_filter() registrieren:

Add_filter("publish_post", "email_friends");

#2 Ein Argument finden

do_action() übergibt ein Argument an die Funktion und es kann verwendet werden. Im vorherigen Beispiel war es die Beitrags-ID, aber wir haben sie nicht verwendet, also brauchten wir sie nicht. Nun ein Beispiel für die Verwendung des übergebenen Arguments:

Add_action("comment_id_not_found", "echo_comment_id", 10, 1); function echo_comment_id($comment_ID)( echo „Ich habe gerade erhalten“. $comment_ID; )

#3 Anonyme Funktion

Sie können eine anonyme Funktion als Rückruffunktion übergeben, zum Beispiel:

Add_action("wp_head", function())( echo "something"; ));

Solche anonymen Funktionen funktionieren nicht mit PHP-Beschleunigern.

#4 Ein Ereignis aus einer PHP-Klasse hinzufügen

Wenn Sie eine PHP-Klassenmethode für ein Ereignis verwenden müssen, müssen Sie im zweiten Argument anstelle des Funktionsnamens ein Array angeben, wobei das erste Argument der Name der Klasse (für eine statische Methode) oder ein ist Instanz der Klasse (für eine öffentliche Methode) und die zweite ist der Name der Methode dieser Klasse.

Die Klasseninstanz befindet sich in der Variablen $this:

// Eine Klassenmethode außerhalb der Klasse verbinden add_action("wp_head", array("My_Class", "my_static_method")); class My_Class ( public function __construct() ( // Eine Klassenmethode innerhalb der Klasse verbinden add_action("save_post", array($this, "my_public_method")); add_action("save_post", array(__CLASS__, "my_static_method")) ; ) öffentliche Funktion my_public_method($post_id) ( // Funktionscode ) statische Funktion my_static_method($post_id) ( // Funktionscode ) )

Anmerkungen

Um herauszufinden, wie viele Argumente eine Aktion übergibt, suchen Sie sie im Code und schauen Sie nach. Hier werden beispielsweise 2 Argumente übergeben:

Do_action("save_post", $post_ID, $post);

und für einen solchen Hook sieht der Hook-Code so aus:

Add_action("save_post", "my_save_post", 10, 2);

und die Funktion wird 2 Argumente haben:

Funktion my_save_post($post_ID, $post)( // Funktionscode hier)

Erstellt ein Ereignis (einen Hook für eine beliebige Funktion). Damit eine Funktion zum Zeitpunkt eines Ereignisses funktioniert, muss sie über die Funktion add_action() mit diesem Ereignis verbunden werden.

Neben Ereignissen verfügt WP auch über Filter, das Funktionsprinzip ist das gleiche. Der einzige Unterschied besteht darin, dass der Filter die resultierende Variable zurückgeben muss, d. h. Es filtert (ändert) die Daten und das Ereignis ermöglicht es Ihnen, eine benutzerdefinierte Funktion auszuführen, wenn das Ereignis ausgelöst wird. Filter werden mit der Funktion apply_filters() gestartet

✈ 1 Mal = 0,00007s = sehr schnell| 50000 Mal = 0,03 s = Lichtgeschwindigkeit

Es gibt keine Haken.

Kehrt zurück

Gibt nichts zurück.

Verwendung

do_action($tag, $arg_a, $arg_b, ...); $tag (Zeichenfolge) (erforderlich) Der Name des zu erstellenden Hooks. $arg_a Der Wert des Arguments, das übergeben wird.
$arg_b (Zeichenfolge/Array/Zahl/Objekt/boolescher Wert) Die Bedeutung eines weiteren Arguments ...
Standard: Argument existiert nicht$arg_с (Zeichenfolge/Array/Zahl/Objekt/boolescher Wert) Sie können einer Funktion unendlich viele Argumente übergeben ...

Beispiele

#1. Anwendungsbeispiel

Diese Funktion kann in Plugins, Themes usw. verwendet werden, wenn Sie sich von irgendwo anders in den Codeausführungsprozess einbinden müssen. Wir haben zum Beispiel einen „Hook“ (do_action) im Plugin installiert und werden ihn in dem Moment, in dem unser „Hook“ ausgelöst wird, aus der Datei „functions.php“ „abfangen“.

Nehmen wir an, wir haben diesen Code im Plugin verwendet:

Jetzt können wir in dem Moment, in dem die Funktion do_action ausgelöst wird, eine Aktion ausführen und gleichzeitig unsere Aktion beispielsweise aus der Datei „functions.php“ beschreiben, indem wir den folgenden Code darin einfügen:

Funktion do_my_hook($a, $b)( // wenn die übergebene Variable $a wahr ist, // dann zum Beispiel Beitrag 10 löschen if($a===true) wp_delete_post(10); // und dann einfach Zeigen Sie die Variable auf dem Bildschirm an echo "
".$b; // zeigt den Wert der zweiten Variablen an ) // Registrieren Sie den Hook über // add_action($tag, $function_to_add, $priority, $accepted_args); add_action("my_hook", "do_my_hook", 10 , 2);

Aktionen unterscheiden sich von Filtern dadurch, dass die von der Aktion übergebenen Daten nicht an die Funktion zurückgegeben und dort in Zukunft nicht verwendet werden, sondern einfach zur Verwendung in der Hook-Funktion übergeben werden.

Code Aktion ausführen: wp-includes/plugin.php WP 5.2.2

do_action($args); array_pop($wp_current_filter); )

Wir haben die Grundlage für ein zukünftiges Plugin geschaffen, das vom WordPress-System erkannt wird. Heute werden wir direkt die Grundfunktionalität des Systems ändern.

Dabei hilft uns ein System aus „Hooks“, „Events“ (Aktionen) und Filtern (Filtern). Diese drei Konzepte sind die Grundlage jedes WordPress-Plugins.

Haken

Es gibt zwei Arten von Hooks in WordPress:

• Aktionshaken: markiert eine Stelle im Code, die eine bestimmte Aktion ausführt. Beispielsweise müssen einige Daten eingegeben und in der Datenbank gespeichert werden.
• Filterhaken: markiert einen Filter, der einen Wert (Variable) ändert, sodass der Code in Zukunft den geänderten Wert verwenden wird.

Aktionen

Arbeiten mit Ereignissen (Aktionen)

Die allgemeine Logik zum Verwalten von Ereignissen in WordPress ist einfach:

1. Markieren Sie den Ort, an dem die Aktion ausgeführt werden soll, mithilfe eines Aktionshakens mit den erforderlichen Parametern.
2. Erstellen Sie eine Funktion, die mithilfe der vom Hook übergebenen Parameter die gewünschten Aktionen ausführt.
3. Registrieren Sie ein Ereignis mit einer bestimmten Priorität, das beim Auslösen des Hooks ausgeführt wird.
4. Wenn WordPress eine Seite lädt und einen Hook findet, führt das System alle Funktionen aus, die für diesen Hook registriert sind.

Um den ersten Punkt zu erreichen, stellt das System die Funktion „do_action“ bereit:

Do_action($tag, $arg_1, $arg_2, ... , $arg_n);

Es benötigt die folgenden Argumente: $tag – der Name des „Hooks“, $arg_1, $arg_2, ..., $arg_n – Parameter, mit denen die Funktion aufgerufen wird. Es kann eine beliebige Anzahl von Argumenten oder 0 geben.

Das System selbst hat bereits viele Hooks definiert:

Do_action("init");

Dies ist ein sehr einfaches Beispiel ohne zusätzliche Argumente. Dieser Hook wird ausgelöst, wenn der Großteil des Systems bereits konfiguriert ist und es an der Zeit ist, eigene Objekte, Kategorien, Beiträge usw. zu erstellen.

Do_action("save_post", $post_id, $post);

In diesem Beispiel wird der Hook ausgelöst, wenn ein Beitrag mit zwei Argumenten gespeichert wird: post_id – die Kennung des Beitrags und post – der Beitrag selbst.

Das Erstellen von Hooks steht jedem Entwickler zur Verfügung, um sein eigenes Plugin (oder Theme) zu erstellen. Dadurch verfügen wir über ein leistungsstarkes Tool zur Steuerung des Systemverhaltens.

Do_action("my_truly_custom_hook");

Nachdem wir den Hook erstellt und die Funktion geschrieben haben, müssen wir die Funktion mit „add_action“ registrieren.

Add_action($tag, $function_to_add, $priority, $accepted_args_number);

Die Funktion „add_action“ benötigt zwei erforderliche Parameter: $tag: den Namen des entsprechenden Hooks und $function_to_add: den Namen der aufzurufenden Funktion. Die anderen beiden Parameter sind optional: $priority: eine Ganzzahlvariable, die die Reihenfolge bestimmt, in der die Funktion ausgeführt wird (Standard ist 10), $accepted_args_number: die Anzahl der Argumente, die die Funktion akzeptiert (Standard ist 1).

Schauen wir uns ein Beispiel an, um den gesamten Prozess zu verstehen. Nehmen wir an, wir möchten unten auf unserer Website einen kleinen Hinweis hinzufügen. Wir können hierfür den Hook „wp_footer“ verwenden, da er ein erforderlicher Teil des Codes ist, den jedes Theme verwendet.

Funktion msp_helloworld_footer_notice())( echo "

"; ) add_action("wp_footer", "msp_helloworld_footer_notice");

In diesem Beispiel haben wir eine Funktion erstellt, die einfach das Markup für die Warnung rendert und es bei „wp_footer“ registriert. Sobald wir diesen Code zu unserer Plugin-Datei hinzufügen (siehe oben), sehen wir das Ergebnis auf der Seite:

WordPress-Plugin-Benachrichtigung

Arbeiten mit Filtern

Filter funktionieren auf die gleiche Weise wie Ereignisse. Filter führen jedoch nicht nur einen bestimmten Codeabschnitt aus, sondern ändern auch die vom Hook an sie übergebenen Werte. Das bedeutet, dass jedem Filter ein Wert (Variable) zugeordnet ist, auf den er einwirkt.

Die Filterfunktion übernimmt diesen Wert und wandelt ihn zur weiteren Verwendung um. Filter-Hooks unterscheiden sich geringfügig von Action-Hooks.

Apply_filters($tag, $value_to_filter, $arg_1, $arg_2, ... , $arg_n);

Die Funktion „apply_filter“ erstellt einen Filter-Hook namens $tag und einen erforderlichen Parameter $value_to_filter (dieser kann leer sein, muss aber deklariert werden). Die übrigen optionalen Argumente funktionieren genauso wie für Ereignisse.

Filter_function($value_to_filter, $arg_1, $arg_2, ... , $arg_n)( //filter return $value_to_filter; //Wert muss zurückgegeben werden)

Dies ist das „Skelett“ des Filters, das zeigt, dass der Filter:

1. akzeptiere mindestens 1 Argument;
2. Geänderten Wert zurückgeben.

add_filter($tag, $function_to_add, $priority, $accepted_args);

Die Funktion „add_filter“ registriert eine Funktion mit dem in $function_to_add enthaltenen Namen für den $tag-Hook. Die übrigen Argumente – $priority und $accepted_args – funktionieren genauso wie für Event-Hooks.

Schauen wir uns ein Beispiel an: Eine häufige Aufgabe eines Plugins besteht darin, am Ende eines Beitrags etwas hinzuzufügen. Wenn wir uns die Funktion „the_content“, mit der der Inhalt eines Beitrags angezeigt wird, genauer ansehen, finden wir folgenden Hook:

$content = apply_filters("the_content", $content);

Damit können wir am Ende des Beitrags ganz einfach etwas hinzufügen.

Funktion msp_helloworld_post_footer($content) ( $content .= "

"; return $content; ) add_filter("the_content", "msp_helloworld_post_footer", 100);

Beachten Sie, dass wir eine große Prioritätszahl verwenden, um sicherzustellen, dass alle Standardfilter ausgeführt werden, bevor „msp_helloworld_post_footer“ ausgeführt wird. Nachdem wir den Code in unser Plugin eingefügt haben, sehen wir das Ergebnis:

So finden Sie einen Haken

Jetzt verstehen wir, dass wir zum Ausführen bestimmter Aktionen die vorhandenen Hooks kennen müssen.

Der WordPress-Codex stellt Listen mit Hooks für Filter und Action Reference- und Filter Reference-Ereignisse bereit.

Zusätzliche Aktionen mit Haken

Genau wie beim Hinzufügen kann ein Hook mit einer ähnlichen Syntax entfernt werden.

Sie können Ereignisse wie folgt löschen:

Remove_action($tag, $function_to_remove, $priority, $accepted_args); remove_all_actions($tag, $priority);

Wie Sie vielleicht schon erraten haben, entfernt „remove_action“ ein bestimmtes Ereignis, das für einen bestimmten Hook registriert ist (die Priorität und Anzahl der Argumente müssen korrekt angegeben werden, wie bei der Registrierung angegeben wurde), und „remove_all_actions“ hilft dabei, alle für einen Hook registrierten Ereignisse zu entfernen ( wenn die Priorität weggelassen wird, löscht die Funktion alle Ereignisse).

Filter können auf die gleiche Weise gelöscht werden:

Remove_filter($tag, $function_to_remove, $priority, $accepted_args); remove_all_filters($tag, $priority);

Die WordPress-Plugin-API bietet auch Funktionen, um zu überprüfen, ob eine Funktion für einen bestimmten Hook registriert ist:

Has_action($tag, $function_to_check); has_filter($tag, $function_to_check);

Beide Funktionen prüfen, ob die angegebene Funktion für den Hook registriert ist und geben bei Erfolg true zurück, andernfalls flase. Innerhalb der Funktion haben wir die Möglichkeit zu überprüfen, ob der Hook sie aufgerufen hat:

If("hook_to_check_name" === current_filter())()

Trotz des Namens funktioniert „current_filter“ nicht nur mit Filtern, sondern auch mit Ereignissen.

Nicht triviales Beispiel

Lassen Sie uns das „Skelett“ unseres Plugins wiederbeleben, das wir in der letzten Lektion vorbereitet haben.

Füllen wir die Datei „core.php“ (den Hauptteil unseres Plugins, der den Großteil der Funktionen enthält) mit Code, der ein Problem löst, das tatsächlich während der Arbeit auftreten kann. Um dieses Problem zu lösen, verwenden wir Aktionen und Filter.

Lassen Sie zu, dass Ihre WordPress-Site Beiträge verschiedener Autoren von Gästen akzeptiert, erlaubt Ihnen jedoch nicht, Konten zu erstellen. Das bedeutet, dass der Benutzer, der den Beitrag veröffentlicht hat, und der tatsächliche Autor unterschiedliche Personen sind und wir sicherstellen müssen, dass der Autor im Beitrag aufgeführt ist. Wir können dies mithilfe der Taxonomie tun.

Lassen Sie uns unsere eigene Taxonomie erstellen, um den Namen und die Kurzbiografie des Autors zu verarbeiten. Wir können den Namen des Autors als andere Taxonomiebegriffe (z. B. Tags) im Beitrag verwenden. Code:

/** Filter und Ereignisse registrieren **/ function msp_helloworld_init())( add_action("init", "msp_helloworld_taxonomies"); add_filter("the_content", "msp_helloworld_author_block_filter"); add_filter("post_class", "msp_helloworld_post_class"); ) add_action ("plugins_loaded", "msp_helloworld_init"); /** Taxonomie **/ function msp_helloworld_taxonomies())( $args = array("labels" => array("name" => "Gastautoren", "singular_name" => "Gastautor"), "show_in_nav_menus" = > false); register_taxonomy("gauthor", array("post"), $args ) /** Autorenblock-Markup **/ function msp_helloworld_author_block())( global $post; $author_terms = wp_get_object_terms($post->ID, "gauthor"); if(empty($author_terms)) return; $name = stripes($author_terms->name); $url = esc_url(get_term_link($author_terms)); ; $out = "

"; return $out; ) /** Markup am Ende des Beitrags hinzufügen **/ function msp_helloworld_author_block_filter($content)( if(is_single()) $content .= msp_helloworld_author_block(); return $content; ) /** CSS-Klasse zum Beitrag hinzufügen **/ function msp_helloworld_post_class($post_class)( global $post; $author_terms = wp_get_object_terms($post->ID, "gauthor"); if(!empty($author_terms))( $post_class = "gauthor "; ) return $post_class)

Wie Sie sehen, haben wir eine Funktion zum Registrieren unserer eigenen Taxonomie erstellt und sie an den „init“-Hook gebunden. Als nächstes haben wir mithilfe der WordPress-Funktion „wp_get_object_terms“ eine Vorlage erstellt, die für die Anzeige des Autorenblocks verantwortlich ist. Dann haben wir am Ende des Beitrags mithilfe des Filters „the_content“ einen Block mit Informationen zum Autor eingefügt. Und schließlich haben wir unsere eigene CSS-Klasse hinzugefügt. Ergebnis: