Pontosan végezze el a php műveletet. PHP és űrlapok

„Ne használja a goto utasítást”- ezt mondták nekünk a tanárok az akadémián, és valóban, ez az operátor teljes káoszba forgatja a kódot. A PHP fejlesztői radikálisan megoldották a problémát – egyszerűen nem létezik PHP3-ban és PHP4-ben. Mi motiválta őket kezdetben? Talán mindannyiunkba akarták belenevelni a helyes programozási stílust? Nos, azt mondhatjuk, hogy teljesen sikerült nekik - már mind megszoktuk, vagyis teljesen elvesztettük az operátor szokását, talán ez a legjobb, mert egy időben olyan logikus konstrukciót kellett kitalálnom, amely teljesen kárpótolta ezt a legszerencsétlenebbet menj.
Nem tudom, hogy van ez senkinek, de nekem különösen gyakran volt kedvem a goto használatához html űrlapkezelő készítésekor, amikor rengeteg adat kerül a felhasználótól a szerverre, amit a php szkriptnek kell lépésről lépésre ellenőrizze. Ez a folyamat általában több lépésben zajlik: magának az űrlapnak a kinyomtatása, a kapott adatok ellenőrzése, előzetes megjelenítés, és például mentés. Sőt, egyes szakaszok megismétlődhetnek: ha nem sikerült az adatellenőrzés, akkor áttérünk az űrlap nyomtatására, vagy ha az előzetes megjelenítés nem felel meg a felhasználónak, akkor visszatérhet az adatbevitelhez. Röviden, néhány kódrészlet többször is felhasználható. A függvények használata ilyen körülmények között szintén nem túl kényelmes - sok bemeneti és kimeneti változó van, a funkciónak túl bonyolult műveleteket kell végrehajtania, általában ügyetlenül derül ki, és a kód olvashatósága meredeken csökken.
És én találtam ki ezt a dizájnt.

csinálni ( kapcsoló ($action) ( alapértelmezett: szünet ; eset "PRINT_FORM" : A főlap nyomtatása szünet ; eset "CHECK_FORM" : Az adatok helyességének ellenőrzése szünet ; eset "PREVIEW_FORM" : Előnézet szünet ; eset "SAVE_FORM" : Adatok mentése szünet ; ) while (igaz) ;

Itt van az alapvető többszörös kijelölési operátor kapcsoló csapdába esett egy végtelen hurokba csinálni, miközben– így szekciókba csoportosítjuk a szükséges műveleteket eset: szünet;és korlátlanul mozoghatunk egyik szakaszról a másikra. Szakaszban alapértelmezett: Kényelmes elvégezni az adatok előzetes elemzését, például ha nincs bemenő adat $action = 'PRINT_FORM' például nyomtassa ki az űrlapot, ha rendelkezésre áll $_POST ['elküldés'] majd a kapott adatokat elküldjük feldolgozásra $action = 'CHECK_FORM'. A vezérlés átadása a kapcsolóblokkok között egy változó megváltoztatásával történik $akció, nos, lépjen ki a ciklusból a használatával szünet 2; vagy kilép;
Például a fő űrlap nyomtatási blokkjában nyugodtan elhelyezheti szünet 2; mert az űrlap kimenete a szkript végét feltételezi.
A design nagyon rugalmas és olvasható. De van egy hátránya - ha az adatokat helytelenül dolgozzák fel, akkor végtelen ciklusba kerülhet, és a szkript lefagy - kellemetlen, ha 30 másodpercet kell várnia.
Határozzuk meg az operátori ciklusok számát csinálni, miközben, 20 is elég. Ha most felpumpáltunk valamit, a forgatókönyv 20 fordulatot fog feltekerni, leáll és vészleállítási figyelmeztetést ad ki.
Nagyon kényelmes egy ilyen konstrukció hibakeresése - közvetlenül az operátor után swith Nyomtassa ki a $action változót, és megkapjuk a blokk végrehajtásának teljes sorrendjét.

DO ( // minden ciklus elejére kiírjuk a végrehajtott szakasz nevét //, ami nagyon kényelmes az echo $action hibakereséséhez." "; SWITCH ($action) ( alapértelmezés: szünet; kis- és nagybetű: "PRINT_FORM": /* a fő űrlap kinyomtatása */ break; kisbetű: "CHECK_FORM": /* ellenőrizze az adatok helyességét */ break; kis- és nagybetű: "PREVIEW_FORM": /* előnézet * / break ; case "SAVE_FORM": /* adat mentése */ break )// vége kapcsoló ) WHILE ((($i++)< 20) or die("Принудительный останов цикла"));

DO( // minden ciklus elejére kiírjuk a nevet // A végrehajtott szakasz nagyon kényelmes a hibakereséshez echo $action . " " ;< / strong > VÁLTÁS ($akció) ( alapértelmezett: szünet ; eset "PRINT_FORM" : nyomtassa ki a fő űrlapot szünet ;

Az RxGroovynak több Do változata van.

• Javadoc:
• Javadoc:

• Javadoc:

A doOnRequest operátor (új az RxGroovy 1.1-ben) egy műveletet regisztrál, amely akkor kerül meghívásra, amikor egy megfigyelő további elemeket kér az eredményül kapott megfigyelhetőből. Ez a művelet paraméterként megkapja a megfigyelő által kért elemek számát.

• Javadoc:

• Javadoc:

• Javadoc:

• Javadoc:

• Javadoc:

előtt

• Javadoc:

után az eredményül kapott Megfigyelhető leáll, akár rendesen, akár hibával.

Minta kód

def számok = Megfigyelhető.from(); numbers.finallyDo(( println("Végre"); )).subscribe(( println(it); ), // onNext ( println("Hiba: " + it.getMessage()); ), // onError ( println ("Sequence kész" ) // onCompleted);

1 2 3 4 5 Sorozat kész Végül

• Javadoc:

Az RxJava-nak több Do-változata van.

A doOnEach operátor lehetővé teszi egy visszahívás létrehozását, amelyet az eredményül kapott Megfigyelhető minden egyes elem kibocsátásakor hívni fog. Ezt a visszahívást vagy olyan művelet formájában adhatja át, amely az onNext értesítési változatot veszi egyedüli paramétereként, vagy átadhat egy megfigyelőt, akinek az onNext metódusa úgy lesz meghívva, mintha feliratkozott volna a Megfigyelhetőre.

• Javadoc:
• Javadoc:

A doOnNext operátor nagyon hasonlít a doOnEach(Action1)-hez, kivéve, hogy a paraméterként átadott művelet nem fogad el értesítést, hanem egyszerűen elfogadja a kibocsátott elemet.

Minta kód

Megfigyelhető.just(1, 2, 3).doOnNext(new Action1 () ( @A public void call(Integer item) felülbírálása ( if(item > 1) ( dob új RuntimeException("Az elem meghaladja a maximális értéket"); ) ) ).subscribe(new Subscriber () ( @Public void onNext(egész számú elem) felülbírálása ( System.out.println("Következő: " + elem); ) @Public void onError(Kidobható hiba) felülbírálása ( System.err.println("Hiba: " + hiba .getMessage()); ) @Override public void onCompleted() ( System.out.println("A sorozat kész."); ) ));

Következő: 1 Hiba: Az elem meghaladja a maximális értéket

• Javadoc:

A doOnRequest operátor (új az RxJava 1.1-ben) egy műveletet regisztrál, amelyet akkor hív meg, amikor egy megfigyelő további elemeket kér a kapott megfigyelhetőből. Ez a művelet paraméterként megkapja a megfigyelő által kért elemek számát.

• Javadoc:

A doOnSubscribe operátor egy műveletet regisztrál, amelyet akkor hív meg, amikor egy megfigyelő feliratkozik az eredményül kapott Megfigyelhetőre.

• Javadoc:

A doOnUnsubscribe operátor egy Műveletet regisztrál, amelyet akkor hív meg, amikor egy megfigyelő leiratkozik az eredményül kapott megfigyelhetőről.

• Javadoc:

A doOnCompleted operátor egy Actiont regisztrál, amely akkor kerül meghívásra, ha az eredményül kapott Megfigyelhető normálisan véget ér, hívva az onCompleted parancsot.

• Javadoc:

A doOnError operátor egy műveletet regisztrál, amelyet akkor hív meg, ha az eredményül kapott Observable rendellenesen fejeződik be, hívva az onError -t. Ezt a műveletet a hibát jelző dobás lesz.

• Javadoc:

A doOnTerminate operátor egy műveletet regisztrál, amelyet igazságosnak neveznek előtt az eredményül kapott Megfigyelhető leáll, akár rendesen, akár hibával.

• Javadoc:

A finalDo az RxJava 1.1.1 óta elavult, a doAfterTerminate javára ugyanazzal a viselkedéssel.

A finalDo operátor egy műveletet regisztrál, amelyet igazságosnak nevezünk után az eredményül kapott Megfigyelhető leáll, akár rendesen, akár hibával.

• Javadoc:

A doAfterTerminate operátor egy műveletet regisztrál, amelyet igazságosnak nevezünk után az eredményül kapott Megfigyelhető leáll, akár rendesen, akár hibával.

• Javadoc:

Az RxJS az alapvető Do operátort do vagy tapként valósítja meg (két név ugyanannak az operátornak). Két lehetőség közül választhat az operátor használatához:

1. Átadhat neki egy Megfigyelőt, ebben az esetben a do / tap meghívja az Observer metódusait, mintha az Observer feliratkozott volna az eredményül kapott Megfigyelőre.
2. Átadhat egy 1-3 egyedi függvényt (onNext , onError és onCompleted), amelyek a / tap meghívja bármelyik megfigyelőjének hasonló nevű függvényeit.

Minta kód

/* Megfigyelő használata */ var megfigyelő = 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(megfigyelő); var előfizetés = source.subscribe(function (x) ( console.log("Next: %s", x); ), function (err) ( console.log("Hiba: %s", err); ), function () ( console.log("Befejezve"); ));

/* Függvény használata */ 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 előfizetés = source.subscribe(function (x) ( console.log("Next: %s", x); ), function (err) ( console.log("Hiba: %s", err); ), function () ( console.log("Befejezve"); ));

Következő: 0 Következő: 0 Következő: 1 Következő: 1 Következő: 2 Következő: 2 Befejezés Befejezve

Az RxJS a doOnNext vagy a tapOnNext funkciót is megvalósítja (ugyanannak az operátornak két neve). Ez a Do speciális formája, amely csak az onNext esetre reagál, egy paraméterként megadott visszahívási függvény meghívásával. Opcionálisan átadhat egy második paramétert is, amely a visszahívási függvény szempontjából a „this” objektum lesz, amikor az végrehajtódik.

Minta kód

var source = Rx.Observable.range(0, 3) .doOnNext(function () ( this.log("Tovább: %s", x); ), konzol); var előfizetés = source.subscribe(function (x) ( console.log("Next: %s", x); ), function (err) ( console.log("Hiba: %s", err); ), function () ( console.log("Befejezve"); ));

Következő: 0 Következő: 0 Következő: 1 Következő: 1 Következő: 2 Következő: 2 Befejezett

Az RxJS a doOnError vagy a tapOnError alkalmazást is megvalósítja (két név ugyanannak az operátornak). Ez a Do speciális formája, amely csak az onError esetre reagál, egy paraméterként megadott visszahívási függvény meghívásával. Opcionálisan átadhat egy második paramétert is, amely a visszahívási függvény szempontjából az „ez” objektum lesz, amikor az végrehajtódik.

Minta kód

var source = Rx.Observable.throw(new Error()); .doOnError(function (err) ( this.log("Do Error: %s", err); ), konzol); var előfizetés = source.subscribe(function (x) ( console.log("Next: %s", x); ), function (err) ( console.log("Hiba: %s", err); ), function () ( console.log("Befejezve"); ));

Do Error: Error Error: Error

Az RxJS a doOnCompleted vagy a tapOnCompleted (ugyanannak az operátornak két neve) is megvalósítja. Ez a Do speciális formája, amely csak az onCompleted esetre reagál, egy paraméterként megadott visszahívási függvény meghívásával. Opcionálisan átadhat egy második paramétert is, amely a visszahívási függvény szempontjából az „ez” objektum lesz, amikor az végrehajtódik.

Minta kód

var source = Rx.Observable.range(0, 3) .doOnCompleted(function () ( this.log("Do Completed"); ), konzol); var előfizetés = source.subscribe(function (x) ( console.log("Next: %s", x); ), function (err) ( console.log("Hiba: %s", err); ), function () ( console.log("Befejezve"); ));

Következő: 0 Következő: 1 Következő: 2 Nem Befejezve Befejezve

Az RxJS egy végleges operátort is megvalósít. Ez egy függvényt vesz igénybe, amelyet a rendszer az eredményül kapott megfigyelhető befejezése után hív meg, akár normál (onCompleted), akár rendellenesen (onError).

Minta kód

var source = Rx.Observable.throw(new Error()) .finally(function () ( console.log("Végül"); )); var előfizetés = source.subscribe(function (x) ( console.log("Next: " + x); ), function (err) ( console.log("Hiba: " + err);), function () ( konzol .log("Befejezve");

Hiba: Error Végül

do / tap , doOnNext / tapOnNext , doOnError / tapOnError , doOnCompleted / tapOnCompleted , és végül megtalálhatók a következő disztribúciók mindegyikében:

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

Az RxPHP ugyanúgy implementálja ezt az operátort .

Meghív egy műveletet a megfigyelhető sorozat minden eleméhez, és a megfigyelhető sorozat kecses vagy kivételes befejezésekor indít műveletet. Ez a módszer használható hibakeresésre, naplózásra stb. a lekérdezés viselkedését az üzenetfolyam elfogásával, hogy tetszőleges műveleteket hajtson végre a folyamatban lévő üzenetekkel. A do használatakor fontos megjegyezni, hogy a Megfigyelő további eseményeket kaphat egy adatfolyam befejeződése vagy hibája után (például ismétlés vagy újrafeliratkozás esetén). Ha olyan megfigyelhetőt használ, amely kiterjeszti az AbstractObservable-t, akkor nem fogja megkapni ezeket az eseményeket. Ebben a speciális esetben használja a DoObservert. A doOnNext, a doOnError és a doOnCompleted belsőleg használja a DoObservert, és megkapja ezeket a további eseményeket.

Minta kód

//a https://github.com/ReactiveX/RxPHP/blob/master/demo/do/do.php $source = \Rx\Observable::range(0, 3) ->do(függvény ($x) ( echo "Do Next:", $x, PHP_EOL; ), function (dobható $err) ( echo "Do Error:", $err->getMessage(), PHP_EOL; ), function () ( echo "Do Completed" , PHP_EOL )); $subscription = $forrás->feliratkozás($stdoutObserver);

Következő lépés:0 Következő érték: 0 Következő:1 Következő érték: 1 Következő:2 Következő érték: 2 Végezve Befejezve!

Az RxPHP-nek van egy doOnError operátora is.

Minta kód

//from https://github.com/ReactiveX/RxPHP/blob/master/demo/do/doOnError.php $source = \Rx\Observable::error(new Exception("Hoppá")) ->doOnError(function (Kidobható $err) ( echo "Do Error:", $err->getMessage(), PHP_EOL; )); $subscription = $forrás->feliratkozás($stdoutObserver);

Hiba: Hoppá Kivétel: Hoppá

Az RxPHP-nek van egy doOnCompleted operátora is.

Minta kód

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

Tedd Completed Complete!

Az RxPHP-nek végre van egy operátora is.

Meghív egy megadott függvényt, ha a forrás befejezése vagy hiba esetén leáll.

Minta kód

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

Következő érték: 1 Következő érték: 2 Következő érték: 3 Kész! Végül

//a https://github.com/ReactiveX/RxPHP/blob/master/demo/finally/finally-error.php Rx\Observable::range(1, 3) ->map(function($value) ( ​​​if ($value == 2) ( dob új \Exception("hiba"); ) return $value )) ->finally(function() ( echo "Végül\n"; )) ->subscribe($stdoutObserver) ;

Következő érték: 1 Kivétel: hiba Végül

A megadott PHP függvényt csatolja a megadott horoghoz. A megadott függvény az esemény pillanatában fog elindulni, ami viszont a do_action() segítségével aktiválódik.

Az a hook, amelyhez a függvény akad, a do_action() függvény segítségével jön létre (inicializálódik).

A műveletek a szűrőkkel ellentétben (add_filter()) szükségesek bizonyos műveletek megfelelő időben történő végrehajtásához, míg a szűrők visszaküldik és fogadják az adatokat, amelyeket aztán felhasználnak.

Nem hivatalosan: a szűrők ugyanazok az események, pontosan ugyanúgy működnek, és eseményként is használhatók (az add_filter() helyett használhatod az add_action() függvényt és fordítva). Például visszaküldheti a kapott adatokat anélkül, hogy megváltoztatná azokat, de emellett végrehajthat valamilyen műveletet (például adatbázisba írást). Igaz, erre nagyon ritkán van szükség. Minden olyan helyen, ahol be kell avatkozni a motorkódba, a fejlesztők megpróbálnak előre látni és beilleszteni egy eseményt erre a helyre.

✈ 1 alkalom = 0,000018s = nagyon gyors| 50 000 alkalommal = 0,07 s = fénysebesség| PHP 7.0.8, WP 4.7

Nincsenek horgok.

Visszatér

Mindig igaz.

Használat

add_action($tag, $add_függvény, $prioritás, $elfogadott_args); $tag (karakterlánc) (kötelező) Annak a műveletnek a neve, amelyhez a függvényt csatoljuk. $hozzáadandó_függvény (zsinór/zárás) (kötelező) A függvény neve, amelyet a művelet indításakor meg kell hívni, pl. függvény, amit a horoghoz csatolunk. A függvényátadási formátum általában egy karakterlánc, . $prioritás (szám) Funkció végrehajtási prioritás. Ha ugyanahhoz a horoghoz több funkció is „csatlakozik”, akkor a prioritást a végrehajtásuk sorrendje határozza meg. A kisebb szám azt jelenti, hogy korábban kerül végrehajtásra, pl. 10-ét 20 előtt hajtják végre.
Alapértelmezett: 10$accepted_args (szám) A függvény által felvett argumentumok száma. Természetesen a műveletnek át kell adnia ezt a számú érvet.
Alapértelmezett: 1

Példák

#1 Normál horog

Levelet küldünk ismerőseinknek, ha új bejegyzés jelenik meg:

Add_action("publish_post", "email_friends"); function email_friends($post_ID)( $friends = " [e-mail védett], [e-mail védett]"; wp_mail($friends, "sally" blogja frissítve", "Most tettem fel valamit a blogomra: http://blog.example.com"); return $post_ID; )

Hasonlóképpen regisztrálhatja ezt a horgot az add_filter() segítségével:

Add_filter("public_post", "email_friends");

# 2 Érv

A do_action() argumentumot ad át a függvénynek, és az használható. Az előző példában a bejegyzés azonosítója volt, de nem használtuk, így nem volt rá szükségünk. Most egy példa az átadott argumentum használatára:

Add_action("comment_id_not_found", "echo_comment_id", 10, 1); function echo_comment_id($comment_ID)( echo "Most kaptam". $comment_ID; )

#3 Névtelen funkció

Egy névtelen függvényt átadhat visszahívási függvényként, például:

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

Az ilyen névtelen függvények nem működnek PHP-gyorsítókkal.

#4 Esemény hozzáadása PHP osztályból

Ha egy eseményhez PHP osztály metódust kell használni, akkor a második argumentumban a függvény neve helyett egy tömböt kell megadni, ahol az első argumentum az osztály neve (statikus metódus esetén) vagy egy osztály példánya (nyilvános metódus esetén), a második pedig az osztály metódusának neve.

Az osztálypéldány a $this változóban található:

// Osztálymetódus csatlakoztatása az osztályon kívül add_action("wp_head", array("My_Class", "my_static_method")); class My_Class ( nyilvános függvény __construct() ( // Osztálymetódus csatlakoztatása az osztályon belül add_action("save_post", array($this, "my_public_method")); add_action("save_post", array(__CLASS__, "my_static_method")) ) public function my_public_method($post_id) ( // függvénykód ) static function my_static_method($post_id) ( // függvénykód ) )

Megjegyzések

Ha meg szeretné tudni, hogy egy művelet hány argumentumot ad át, keresse meg a kódban, és nézze meg. Például itt 2 argumentumot adunk át:

Do_action("bejegyzés mentése", $post_ID, $post);

és egy ilyen horog esetében a hook kód így fog kinézni:

Add_action("bejegyzés mentése", "save_bejegyzésem", 10, 2);

és a függvénynek 2 argumentuma lesz:

Függvény my_save_post($post_ID, $post)( // függvénykód itt)

Eseményt hoz létre (akasztót egy tetszőleges függvényhez). Ahhoz, hogy egy függvény működjön egy esemény időpontjában, ehhez az eseményhez kell kapcsolódnia az add_action() függvénnyel.

A WP-ben az események mellett szűrők is vannak, a működési elv ugyanaz. Az egyetlen különbség az, hogy a szűrőnek vissza kell adnia a kapott változót, pl. szűri (módosítja) az adatokat, és az esemény lehetővé teszi egyéni függvény futtatását az esemény aktiválásakor. A szűrők az apply_filters() függvény segítségével indíthatók el

✈ 1 alkalom = 0,00007 s = nagyon gyors| 50 000 alkalommal = 0,03 s = fénysebesség

Nincsenek horgok.

Visszatér

Semmit sem ad vissza.

Használat

do_action($tag, $arg_a, $arg_b, ...); $tag (karakterlánc) (kötelező) A létrehozandó horog neve. $arg_a Az átadott argumentum értéke.
$arg_b (karakterlánc/tömb/szám/objektum/boolean) Még egy érv értelme...
Alapértelmezés: az argumentum nem létezik$arg_с (karakterlánc/tömb/szám/objektum/boolean) Egy függvénynek végtelen számú argumentumot adhat át...

Példák

#1. Használati példa

Ez a funkció beépülő modulokban, témákban stb. használható, ha valahonnan máshonnan kell beillesztenie magát a kódvégrehajtási folyamatba. Például telepítettünk egy „hook”-ot (do_action) a bővítménybe, és a functions.php fájlból „elkapjuk” a „hook” indításakor.

Tegyük fel, hogy ezt a kódot használtuk a bővítményben:

Most a do_action függvény aktiválásának pillanatában tehetünk valamilyen műveletet, és ezzel egyidejűleg leírhatjuk a műveletünket például a functions.php fájlból, a következő kódot helyezve bele:

A do_my_hook($a, $b)( // függvény, ha az átadott $a változó igaz, // akkor például törölje a 10. bejegyzést if($a===true) wp_delete_post(10); //, majd csak a változó megjelenítése a képernyőn visszhangra "
".$b; // a második változó értékét jeleníti meg , 2);

A műveletek abban különböznek a szűrőktől, hogy a művelet által átadott adatok nem kerülnek vissza a függvénybe, és a jövőben nem használják fel őket, hanem egyszerűen átadják a hook függvényben való használatra.

Kód cselekedj: wp-includes/plugin.php WP 5.2.2

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

Létrehoztuk egy jövőbeli bővítmény alapjait, amelyet a WordPress rendszer felismer. Ma közvetlenül megváltoztatjuk a rendszer alapvető funkcióit.

Ebben segítségünkre lesz a „kampók”, „események” (akciók) és szűrők (szűrők) rendszere. Ez a három fogalom minden WordPress bővítmény alapja.

Horgok

A WordPressben kétféle horog létezik:

• Akció horog: olyan helyet jelöl meg a kódban, amely egy bizonyos műveletet végrehajt, például szükséges néhány adat megadása és mentése az adatbázisba.
• Szűrő horog: szűrőt jelöl, amely megváltoztat valamilyen értéket (változót), így a jövőben a kód a módosított értéket fogja használni.

Műveletek

Munka eseményekkel (akciókkal)

A WordPress eseménykezelésének általános logikája egyszerű:

1. A szükséges paraméterekkel rendelkező akcióhorog segítségével jelölje be a helyet, ahol a műveletet végre kell hajtani.
2. Hozzon létre egy függvényt, amely végrehajtja a kívánt műveleteket a horog által átadott paraméterek segítségével.
3. Regisztráljon egy eseményt, amely akkor kerül végrehajtásra, amikor a horog elsül, meghatározott prioritással.
4. Amikor a WordPress betölt egy oldalt, és talál egy hook-ot, a rendszer végrehajtja az összes olyan funkciót, amely az adott horoghoz van regisztrálva.

Az első pont teljesítéséhez a rendszer biztosítja a „do_action” függvényt:

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

A következő argumentumokat használja: $tag – a „hook” neve, $arg_1, $arg_2, ..., $arg_n – paraméterek, amelyekkel a függvény meghívásra kerül. Tetszőleges számú argumentum lehet, vagy 0.

Magának a rendszernek számos akasztója van már:

Do_action("init");

Ez egy nagyon egyszerű példa, további érvek nélkül. Ez a hook akkor aktiválódik, amikor a rendszer nagy része már be van állítva, és itt az ideje létrehozni saját objektumokat, kategóriákat, bejegyzéseket stb.

Do_action("bejegyzés mentése", $post_id, $post);

Ebben a példában a horog akkor aktiválódik, amikor egy bejegyzést két post_id argumentummal mentenek el - a bejegyzés és a post azonosítója - maga a bejegyzés.

A hook létrehozása bármely fejlesztő számára elérhető saját bővítmény (vagy téma) létrehozásához. Ennek köszönhetően egy hatékony eszköz áll rendelkezésünkre a rendszer viselkedésének szabályozására.

Do_action("saját_igazán_egyéni_hook");

Miután létrehoztuk a horgot és megírtuk a függvényt, regisztrálnunk kell a függvényt az „add_action” segítségével.

Add_action($címke, $hozzáadandó_függvény, $prioritás, $elfogadott_args_szám);

Az 'add_action' függvénynek két kötelező paraméterre van szüksége: $tag: a megfelelő hook neve és $function_to_add: a meghívandó függvény neve. A másik két paraméter nem kötelező: $priority: egész szám változó, amely meghatározza a függvény végrehajtásának sorrendjét (alapértelmezett 10), $accepted_args_number: a függvény által elfogadott argumentumok száma (alapértelmezett 1).

Nézzünk egy példát, hogy megértsük az egész folyamatot. Tegyük fel, hogy szeretnénk egy kis figyelmeztetést elhelyezni weboldalunk alján. Ehhez használhatjuk a 'wp_footer' hook-ot, mert ez a kód kötelező része, amelyet minden téma használ.

msp_helloworld_footer_notice())( echo ") függvény

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

Ebben a példában létrehoztunk egy függvényt, amely egyszerűen megjeleníti a riasztás jelölését, és regisztrálta a „wp_footer” címkével. Miután hozzáadtuk ezt a kódot a bővítményfájlunkhoz (lásd az előzőt), látni fogjuk az eredményt az oldalon:

WordPress beépülő modul figyelmeztetés

Munka szűrőkkel

A szűrők ugyanúgy működnek, mint az események. De a szűrők nem csak egy adott kódrészletet hajtanak végre, hanem megváltoztatják a hook által nekik továbbított értékeket. Ez azt jelenti, hogy minden szűrőhöz tartozik egy érték (változó), amelyen működik.

A szűrő függvény felveszi ezt az értéket, és átalakítja a további felhasználáshoz. A szűrőhorgok kissé eltérnek az akciókampóktól.

Apply_filters($tag, $érték_szűrőhöz, $arg_1, $arg_2, ... , $arg_n);

Az 'apply_filter' függvény létrehoz egy $tag nevű szűrőhookot és egy szükséges $value_to_filter paramétert (ez lehet üres, de deklarálni kell). A többi opcionális argumentum ugyanúgy működik, mint az események esetében.

Filter_function($érték_szűrőhöz, $arg_1, $arg_2, ... , $arg_n)( //szűrő return $érték_szűrőhöz; //értéket kell visszaadni)

Ez a szűrő „csontváza”, amely azt mutatja, hogy a szűrőnek:

1. fogadjon el legalább 1 érvet;
2. módosított értéket ad vissza.

add_filter($tag, $add_függvény, $prioritás, $elfogadott_args);

Az 'add_filter' függvény a $tag hook számára a $function_to_add nevű függvényt regisztrál. A fennmaradó argumentumok - $priority és $accepted_args - ugyanúgy működnek, mint az eseményhorgok esetében.

Nézzünk egy példát: egy beépülő modul gyakori feladata, hogy hozzáadjon valamit a bejegyzés végéhez. Ha közelebbről megvizsgáljuk a 'the_content' függvényt, amely egy bejegyzés tartalmának megjelenítésére szolgál, a következő horogot találjuk:

$tartalom = alkalmaz_szűrők("a_tartalom", $tartalom);

Használatával könnyen hozzátehetünk valamit a bejegyzés végéhez.

Függvény msp_helloworld_post_footer($content) ( $content .= "

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

Ne feledje, hogy nagy számokat használunk prioritásként annak biztosítására, hogy minden szabványos szűrő végrehajtásra kerüljön az 'msp_helloworld_post_footer' végrehajtása előtt. Miután beépítettük a kódot a bővítményünkbe, látni fogjuk az eredményt:

Hogyan találjunk horgot

Most már megértjük, hogy bizonyos műveletek végrehajtásához ismernünk kell a meglévő horgokat.

A WordPress Codex listákat tartalmaz a szűrőkhöz, valamint a műveleti hivatkozásokhoz és a szűrőreferencia eseményekhez.

További műveletek horgokkal

Csakúgy, mint a hozzáadásnál, a horog is eltávolítható hasonló szintaxissal.

Ilyen eseményeket törölhet:

Remove_action($tag, $eltávolítandó_függvény, $prioritás, $elfogadott_args); remove_all_actions($tag, $prioritás);

Ahogy azt sejteni lehetett, a 'remove_action' eltávolít egy adott hook-hoz regisztrált eseményt (az argumentumok prioritását és számát helyesen kell megadni, ahogyan azt a regisztráció során is megadtuk), az 'remove_all_actions' pedig segít eltávolítani a hook-hoz regisztrált összes eseményt ( ha a prioritást kihagyjuk, a funkció törli az összes eseményt).

A szűrőket hasonló módon lehet törölni:

Remove_filter($tag, $eltávolítandó_függvény, $prioritás, $elfogadott_args); Remove_all_filters($tag, $prioritás);

A WordPress plugin API olyan funkciókat is biztosít, amelyekkel ellenőrizhető, hogy egy funkció regisztrálva van-e egy adott hook számára:

Has_action($tag, $ellenőrzendő_függvény); has_filter($tag, $ellenőrzendő_függvény);

Mindkét függvény ellenőrzi, hogy az adott függvény regisztrálva van-e a hook számára, és ha sikeres, true értéket ad vissza, ellenkező esetben flase. A függvényen belül ellenőrizhetjük, hogy a horog hívta-e:

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

A "current_filter" név ellenére nem csak szűrőkkel működik, hanem eseményekkel is.

Nem triviális példa

Elevenítsük fel a legutóbbi leckében elkészített bővítményünk „csontvázát”.

Töltsük fel a 'core.php' fájlt (bővítményünk fő része, amely a függvények nagy részét tartalmazza) kóddal, amely megold egy, a munka közben felmerülő problémát. Ennek megoldására műveleteket és szűrőket fogunk használni.

Engedélyezze, hogy WordPress-webhelye különböző szerzők bejegyzéseit fogadja el a vendégektől, de nem teszi lehetővé fiókok létrehozását. Ez azt jelenti, hogy a bejegyzést közzétevő felhasználó és a valódi szerző különböző személyek, és meg kell győződnünk arról, hogy a szerző fel van tüntetve a bejegyzésben. Ezt taxonómia segítségével tehetjük meg.

Készítsünk saját taxonómiát a szerző nevének és rövid életrajzának feldolgozásához. A szerző nevét más taxonómiai kifejezésként (például címkékként) használhatjuk majd a bejegyzésben. Kód:

/** szűrők és események regisztrálása **/ függvény msp_helloworld_init())( add_action("init", "msp_helloworld_taxonomies"); add_filter("the_content", "msp_helloworld_author_block_filter"); add_filter("post_hellow", "lp)_hellow" add_action ("plugins_loaded", "msp_helloworld_init"); /** taxonómia **/ function msp_helloworld_taxonomies())( $args = array("labels" => array("name" => "Vendégszerzők", "singular_name" => "Vendégszerző"), "show_in_nav_menus" = > false); register_taxonomy("gauthor", array("post"), $args ) /** author block markup **/ function msp_helloworld_author_block())( global $post; $author_terms = wp_get_object_terms($post->ID, "gauthor"); if(üres($author_terms)) return ($author_terms->name); $out = "

"; return $out; ) /** jelölés hozzáadása a bejegyzés végéhez **/ függvény msp_helloworld_author_block_filter($content)( if(is_single()) $content .= msp_helloworld_author_block(); return $content; ) /** CSS osztály hozzáadása a bejegyzéshez **/ 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)

Amint látja, létrehoztunk egy függvényt a saját taxonómiánk regisztrálására, és az 'init' hook-hoz kötjük. Ezután létrehoztunk egy sablont, amely a szerzői blokk megjelenítéséért felelős a WordPress „wp_get_object_terms” függvényével. Ezután a „the_content” szűrő segítségével a bejegyzés végére beszúrtunk egy blokkot a szerzőről szóló információkkal. És végül hozzáadtuk a saját CSS osztályunkat. Eredmény: