“Neizmantojiet goto paziņojumu”- tā mums stāstīja akadēmijas pasniedzēji, un tiešām šis operators kodu pārvērš pilnīgā putrā. PHP izstrādātāji šo problēmu atrisināja radikāli - PHP3 un PHP4 tā vienkārši nepastāv. Kas viņus sākotnēji motivēja? Varbūt viņi vēlējās mums visiem ieaudzināt pareizo programmēšanas stilu? Nu var teikt, ka viņiem tas pilnībā izdevās - mēs visi jau esam pieraduši, tas ir, esam pilnībā zaudējuši šī operatora ieradumu, varbūt tas ir labākais, jo man savulaik bija jāizdomā loģiska konstrukcija, kas pilnībā kompensēja šo visneveiksmīgāko iet uz.
Nezinu kā kādam ir, bet man īpaši bieži radās vēlme lietot goto veidojot html formu apdarinātāju, kad no lietotāja uz serveri tiek sūtīti daudz datu, kuriem php skriptam ir jābūt pārbaudiet soli pa solim. Šis process, kā likums, notiek vairākos posmos: pašas veidlapas izdrukāšana, saņemto datu pārbaude, sākotnējā attēlošana un, piemēram, saglabāšana. Turklāt daži posmi var atkārtoties: ja datu pārbaude nav veiksmīga, mēs pārejam pie veidlapas drukāšanas, vai arī, ja iepriekšējais attēlojums lietotājam neatbilst, viņš var atgriezties pie datu ievadīšanas. Īsāk sakot, dažas koda daļas var izmantot vairākas reizes. Funkciju izmantošana šādos apstākļos arī nav īpaši ērta - ir daudz ievades un izvades mainīgo, funkcijai jāveic pārāk sarežģītas darbības, tas kopumā izrādās neveikli un koda lasāmība strauji krītas.
Un es izdomāju šo dizainu.
darīt ( slēdzis ($action) ( noklusējuma: pārtraukums ; lieta "PRINT_FORM": Galvenās veidlapas drukāšana pārtraukums ; gadījums "CHECK_FORM": Datu pareizības pārbaude pārtraukums ; gadījums "PREVIEW_FORM": Priekšskatījums pārtraukums ; gadījums "SAVE_FORM": Datu saglabāšana pārtraukums ; ) kamēr (patiess) ; |
Šeit ir pamata vairākkārtējas atlases operators slēdzis iesprostots nebeidzamā cilpā darīt kamēr– tādā veidā sagrupējam nepieciešamās darbības sadaļās gadījums: pārtraukums; un mēs varam neierobežoti pārvietoties no vienas sadaļas uz otru. Sadaļā noklusējuma: Ir ērti veikt datu provizorisku analīzi, piemēram, ja tad nav ievades datu $action = 'PRINT_FORM' piemēram, izdrukājiet veidlapu, ja tā ir pieejama $_POST ['iesniegt'] tad saņemtos datus nosūtām apstrādei $action = 'CHECK_FORM'. Vadības nodošana starp slēdžu blokiem notiek, mainot mainīgo $darbība, izejiet no cilpas, izmantojot pārtraukums 2; vai iziet;
Piemēram, galvenās veidlapas drukas blokā varat droši ievietot pārtraukums 2; jo formas izvade uzņemas skripta beigas.
Dizains ir ļoti elastīgs un lasāms. Bet ir viens trūkums - ja dati tiek apstrādāti nepareizi, jūs varat nonākt nebeidzamā cilpā un skripts sasalst - ir nepatīkami gaidīt pat 30 sekundes.
Noteiksim operatora ciklu skaita ierobežojumu darīt kamēr, pietiek ar 20. Tagad, ja mēs kaut ko uzpumpēsim, skripts apgriezīs 20 apgriezienus, apstāsies un izdos avārijas apstāšanās brīdinājumu.
Ir ļoti ērti atkļūdot šādu konstrukciju - tūlīt pēc operatora swith izdrukājiet $action mainīgo, un mēs iegūsim pilnu bloka izpildes secību.
DO ( // katras cilpas sākumā mēs izdrukājam izpildītās sadaļas nosaukumu //, ļoti ērti atkļūdošanai echo $action." "; SWITCH ($action) (noklusējums: pārtraukums; reģistrs "PRINT_FORM": /* izdrukāt galveno formu */ pārtraukums; reģistrs "CHECK_FORM": /* pārbaudiet, vai dati ir pareizi */ pārtraukums; reģistrs "PREVIEW_FORM": /* priekšskatījums * / break ; case "SAVE_FORM": /* saglabāt datus */ break; )// beigu slēdzis ) WHILE ((($i++)< 20) or die("Принудительный останов цикла"));
DO( // katras cilpas sākumā izdrukājam nosaukumu // izpildītā sadaļa ir ļoti ērta atkļūdošanai atbalss $darbība . " " ;< / strong > SLĒDZI ($action) ( noklusējuma: pārtraukums ; lieta "PRINT_FORM": izdrukājiet galveno veidlapu pārtraukums ; |
RxGroovy ir vairāki Do varianti.
- Javadoc:
- Javadoc:
- Javadoc:
Operators doOnRequest (jauns RxGroovy 1.1) reģistrē darbību, kas tiks izsaukta ikreiz, kad novērotājs pieprasīs papildu vienumus no iegūtā novērojamā objekta. Šī darbība kā parametru saņem novērotāja pieprasīto vienumu skaitu.
- Javadoc:
- Javadoc:
- Javadoc:
- Javadoc:
- Javadoc:
pirms tam
- Javadoc:
pēc iegūtais Novērojamais beidzas neatkarīgi no tā, vai tas ir normāli vai ar kļūdu.
Koda paraugs
def skaitļi = Novērojams.no(); numbers.finallyDo(( println("Beidzot"); )).subscribe(( println(it); ), // onNext ( println("Kļūda: " + it.getMessage()); ), // onError ( println ("Secība pabeigta"); ) // onCompleted);
1 2 3 4 5 Secība pabeigta Visbeidzot
- Javadoc:
RxJava ir vairāki Do varianti.
Operators doOnEach ļauj izveidot atzvanīšanu, ko iegūtais Observable izsauks katru reizi, kad tas izstaro vienumu. Varat nodot šo atzvanīšanu vai nu kā darbību, kas kā vienīgo parametru izmanto paziņojumu onNext, vai arī varat nodot novērotāju, kura onNext metode tiks izsaukta tā, it kā tas būtu abonējis Observable.
- Javadoc:
- Javadoc:
Operators doOnNext ir līdzīgs doOnEach(Action1), izņemot to, ka darbība, kuru jūs to nododat kā parametru, nepieņem paziņojumu, bet tā vietā vienkārši pieņem izstaroto vienumu.
Koda paraugs
Observable.just(1, 2, 3).doOnNext(new Action1
Nākamais: 1 Kļūda: vienums pārsniedz maksimālo vērtību
- Javadoc:
Operators doOnRequest (jauns RxJava 1.1) reģistrē darbību, kas tiks izsaukta ikreiz, kad novērotājs pieprasīs papildu vienumus no iegūtā novērojamā objekta. Šī darbība kā parametru saņem novērotāja pieprasīto vienumu skaitu.
- Javadoc:
DoOnSubscribe operators reģistrē darbību, kas tiks izsaukta ikreiz, kad novērotājs abonēs iegūto novērojamo.
- Javadoc:
DoOnUnsubscribe operators reģistrē darbību, kas tiks izsaukta ikreiz, kad novērotājs atteiksies no iegūtā novērojamā objekta.
- Javadoc:
Operators doOnCompleted reģistrē darbību, kas tiks izsaukta, ja iegūtais Observable beidzas normāli, izsaucot onCompleted.
- Javadoc:
Operators doOnError reģistrē darbību, kas tiks izsaukta, ja iegūtais Observable beigsies neparasti, izsaucot onError . Šī darbība tiks nodota izmešanai, kas apzīmē kļūdu.
- Javadoc:
Operators doOnTerminate reģistrē darbību, kas tiks saukta par taisnīgu pirms tam iegūtais Novērojamais beidzas neatkarīgi no tā, vai tas ir normāli vai ar kļūdu.
- Javadoc:
FinalDo ir novecojis kopš RxJava 1.1.1, par labu doAfterTerminate ar tādu pašu darbību.
Operators finalDo reģistrē darbību, kas tiks saukta par taisnīgu pēc iegūtais Novērojamais beidzas neatkarīgi no tā, vai tas ir normāli vai ar kļūdu.
- Javadoc:
Operators doAfterTerminate reģistrē darbību, kas tiks saukta par taisnīgu pēc iegūtais Novērojamais beidzas neatkarīgi no tā, vai tas ir normāli vai ar kļūdu.
- Javadoc:
RxJS ievieš pamata operatoru Do kā do vai tap (vienam operatoram divi nosaukumi). Jums ir divas iespējas, kā izmantot šo operatoru:
- Varat nodot to novērotājam, un tādā gadījumā do / pieskarieties izsauks šī novērotāja metodes tā, it kā novērotājs būtu abonējis iegūto Observable.
- Varat nodot 1–3 atsevišķu funkciju kopu (onNext , onError un onCompleted), kuras izsauks / pieskaras kopā ar jebkura novērotāja līdzīgi nosauktajām funkcijām.
Koda paraugs
/* Izmantojot novērotāju */ var novērotājs = Rx.Observer.create(function (x) ( console.log("Do Next: %s", x); ), funkcija (err) ( console.log("Do Error : %s", err); ), funkcija () ( console.log("Do Completed"); )); var avots = Rx.Novērojams.diapazons(0, 3) .do(novērotājs); var abonements = source.subscribe(function (x) ( console.log("Nākamais: %s", x); ), funkcija (err) ( console.log("Kļūda: %s", err); ), funkcija () ( console.log("Pabeigts"); ));
/* Izmantojot funkciju */ var avots = Rx.Observable.range(0, 3) .do(function (x) ( console.log("Do Next:", x); ), funkcija (err) ( konsole. log("Do Error:", err); ), function () ( console.log("Do Completed"); )); var abonements = source.subscribe(function (x) ( console.log("Nākamais: %s", x); ), funkcija (err) ( console.log("Kļūda: %s", err); ), funkcija () ( console.log("Pabeigts"); ));
Darīt tālāk: 0 Nākamais: 0 Darīt nākamo: 1 Nākamais: 1 Darīt nākamo: 2 Nākamais: 2 Vai Pabeigts Pabeigts
RxJS ievieš arī doOnNext vai tapOnNext (divi nosaukumi vienam operatoram). Tā ir specializēta Do forma, kas reaģē tikai uz onNext gadījumu, izsaucot atzvanīšanas funkciju, kuru norādījāt kā parametru. Varat arī pēc izvēles nodot otru parametru, kas būs “šis” objekts no jūsu atzvanīšanas funkcijas viedokļa, kad tā tiek izpildīta.
Koda paraugs
var avots = Rx.Observable.range(0, 3) .doOnNext(function () ( this.log("Do Next: %s", x); ), konsole); var abonements = source.subscribe(function (x) ( console.log("Nākamais: %s", x); ), funkcija (err) ( console.log("Kļūda: %s", err); ), funkcija () ( console.log("Pabeigts"); ));
Darīt tālāk: 0 Nākamais: 0 Darīt nākamo: 1 Nākamais: 1 Darīt nākamo: 2 Nākamais: 2 Pabeigts
RxJS ievieš arī doOnError vai tapOnError (divi nosaukumi vienam operatoram). Tā ir specializēta Do forma, kas reaģē tikai uz onError gadījumu, izsaucot atzvanīšanas funkciju, kuru norādījāt kā parametru. Varat arī pēc izvēles nodot otru parametru, kas būs “šis” objekts no jūsu atzvanīšanas funkcijas viedokļa, kad tā tiek izpildīta.
Koda paraugs
var avots = Rx.Observable.throw(new Error()); .doOnError(function (err) ( this.log("Do Error: %s", err); ), konsole); var abonements = source.subscribe(function (x) ( console.log("Nākamais: %s", x); ), funkcija (err) ( console.log("Kļūda: %s", err); ), funkcija () ( console.log("Pabeigts"); ));
Do Error: Error Error: Error
RxJS ievieš arī doOnCompleted vai tapOnCompleted (divi nosaukumi vienam operatoram). Tā ir specializēta Do forma, kas reaģē tikai uz onCompleted gadījumu, izsaucot atzvanīšanas funkciju, kuru norādījāt kā parametru. Varat arī pēc izvēles nodot otru parametru, kas būs “šis” objekts no jūsu atzvanīšanas funkcijas viedokļa, kad tā tiek izpildīta.
Koda paraugs
var avots = Rx.Observable.range(0, 3) .doOnCompleted(function () ( this.log("Do Completed"); ), konsole); var abonements = source.subscribe(function (x) ( console.log("Nākamais: %s", x); ), funkcija (err) ( console.log("Kļūda: %s", err); ), funkcija () ( console.log("Pabeigts"); ));
Nākamais: 0 Nākamais: 1 Nākamais: 2 Vai Pabeigts Pabeigts
RxJS ievieš arī beidzot operatoru. Tam ir nepieciešama funkcija, kas tiks izsaukta pēc tam, kad iegūtais Observable beigsies, neatkarīgi no tā, vai tas ir normāli (onCompleted) vai neparasti (onError).
Koda paraugs
var avots = Rx.Observable.throw(new Error()) .finally(function () ( console.log("Beidzot"); )); var abonements = source.subscribe(function (x) ( console.log("Nākamais: " + x); ), funkcija (err) ( console.log("Kļūda: " + err);), funkcija () ( konsole .log("Pabeigts"); ));
Kļūda: Beidzot kļūda
do / tap , doOnNext / tapOnNext , doOnError / tapOnError , doOnCompleted / tapOnCompleted un visbeidzot ir atrodami katrā no šiem izplatījumiem:
- rx.js
- rx.all.js
- rx.all.compat.js
- rx.compat.js
- rx.lite.js
- rx.lite.compat.js
RxPHP ievieš šo operatoru tāpat kā .
Izsauc darbību katram elementam novērojamajā secībā un izsauc darbību, kad novērojamā secība tiek graciozā vai izņēmuma kārtā pārtraukta. Šo metodi var izmantot atkļūdošanai, reģistrēšanai utt. vaicājuma darbību, pārtverot ziņojumu straumi, lai palaistu patvaļīgas darbības ziņojumiem konveijerā. Lietojot do, ir svarīgi ņemt vērā, ka novērotājs var saņemt papildu notikumus pēc straumes pabeigšanas vai kļūdas (piemēram, izmantojot atkārtošanu vai atkārtotu abonēšanu). Ja izmantojat Observable, kas paplašina AbstractObservable, jūs nesaņemsit šos notikumus. Šajā īpašajā gadījumā izmantojiet DoObserver. doOnNext, doOnError un doOnCompleted iekšēji izmanto DoObserver un saņems šos papildu notikumus.
Koda paraugs
//no https://github.com/ReactiveX/RxPHP/blob/master/demo/do/do.php $source = \Rx\Observable::range(0, 3) ->do(funkcija ($x) ( atbalss "Do Next:", $x, PHP_EOL; ), funkcija (Throwable $err) ( echo "Do Error:", $err->getMessage(), PHP_EOL; ), funkcija () ( atbalss "Do Completed" , PHP_EOL; )); $abonements = $avots->abonēt($stdoutObserver);
Do Next:0 Nākamā vērtība: 0 Do Next:1 Nākamā vērtība: 1 Do Next:2 Nākamā vērtība: 2 Do Completed Pabeigta!
RxPHP ir arī operators doOnError .
Koda paraugs
//no https://github.com/ReactiveX/RxPHP/blob/master/demo/do/doOnError.php $source = \Rx\Novērojams::error(new Exception("Hmm")) ->doOnError(funkcija (Throwable $err) ( atbalss "Do Error:", $err->getMessage(), PHP_EOL; )); $abonements = $avots->abonēt($stdoutObserver);
Vai kļūda:Hmm Izņēmums:Hmm
RxPHP ir arī operators doOnCompleted .
Koda paraugs
//no https://github.com/ReactiveX/RxPHP/blob/master/demo/do/doOnCompleted.php $source = \Rx\Observable::empty() ->doOnCompleted(function () ( atbalss "Do Completed ", PHP_EOL; )); $abonements = $avots->abonēt($stdoutObserver);
Vai Pabeigts Pabeigts!
Visbeidzot, RxPHP ir arī operators.
Izsauks norādīto funkciju, kad avota darbība tiks pabeigta vai rodas kļūda.
Koda paraugs
//no https://github.com/ReactiveX/RxPHP/blob/master/demo/finally/finally.php Rx\Observable::range(1, 3) ->finally(function() ( echo "Beidzot\n "; )) ->abonēt($stdoutObserver);
Nākamā vērtība: 1 Nākamā vērtība: 2 Nākamā vērtība: 3 Pabeigta! Beidzot
//no https://github.com/ReactiveX/RxPHP/blob/master/demo/finally/finally-error.php Rx\Observable::range(1, 3) ->map(function($value) ( if ($vērtība == 2) (izmest jaunu \Exception("kļūda"); ) atgriež $vērtību; )) ->finally(function() ( atbalss "Beidzot\n"; )) ->abonēt($stdoutObserver );
Nākamā vērtība: 1 Izņēmums: kļūda Visbeidzot
Piestiprina norādīto PHP funkciju norādītajam āķim. Norādītā funkcija tiks aktivizēta notikuma brīdī, kas savukārt tiek aktivizēts, izmantojot do_action() .
Āķis, kuram funkcija piesaista, tiek izveidots (inicializēts), izmantojot funkciju do_action().
Darbības, atšķirībā no filtriem (add_filter()), ir nepieciešamas, lai veiktu kādu darbību īstajā laikā, savukārt filtri pārsūta un saņem atpakaļ datus, kas pēc tam tiek izmantoti.
Neoficiāli: filtri ir tie paši notikumi, tie darbojas tieši tāpat un tos var izmantot kā notikumus (add_filter() vietā var izmantot funkciju add_action() un otrādi). Piemēram, var atgriezt saņemtos datus, tos nemainot, bet papildus veikt kādu darbību (piemēram, rakstīt datu bāzē). Tiesa, tas ir vajadzīgs ļoti reti. Visas vietas, kur nepieciešams iejaukties dzinēja kodā, izstrādātāji cenšas paredzēt un ievietot notikumu šajā vietā.
✈ 1 reize = 0,000018 s = ļoti ātri| 50 000 reizes = 0,07 s = gaismas ātrums| PHP 7.0.8, WP 4.7
Āķu nav.
Atgriežas
Vienmēr taisnība.
Lietošana
add_action($tag, $funkcija_pievienošanai, $prioritāte, $accepted_args); $tag (virkne) (obligāti) Tās darbības nosaukums, kurai pievienosim funkciju. $funkcija_pievienošanai (virkne/aizslēgšana) (obligāti) Funkcijas nosaukums, kas jāizsauc, kad darbība tiek aktivizēta, t.i. funkcija, ko pievienojam āķim. Funkcijas nodošanas formāts parasti ir virkne, . $prioritāte (skaitlis) Funkcijas izpildes prioritāte. Ja vienam un tam pašam āķim ir “pieslēgtas” vairākas funkcijas, tad prioritāti noteiks to izpildes secība. Mazāks skaitlis nozīmē, ka tas tiek izpildīts agrāk, t.i. 10 tiks izpildīts līdz 20.Noklusējums: 10$accepted_args (skaitlis) Funkcijas argumentu skaits. Protams, darbībai ir jāiztur šis argumentu skaits.
Noklusējums: 1
Piemēri
#1 Parasts āķis
Mēs nosūtīsim vēstuli draugiem, kad tiks publicēts jauns ieraksts:
Add_action("public_post", "email_friends"); funkcija email_friends($post_ID)($friends = " [aizsargāts ar e-pastu], [aizsargāts ar e-pastu]"; wp_mail($friends, "sally" emuārs atjaunināts", "Es tikko ievietoju kaut ko savā emuārā: http://blog.example.com"); atgriezt $post_ID; )
Līdzīgi varat reģistrēt šo āķi, izmantojot add_filter():
Add_filter("public_post", "email_friends");
# 2 Argumenta iegūšana
do_action() nodod funkcijai argumentu, un to var izmantot. Iepriekšējā piemērā tas bija ziņas ID, bet mēs to neizmantojām, tāpēc mums tas nebija vajadzīgs. Tagad piemērs, kā izmantot nodoto argumentu:
Add_action("komenta_id_nav_atrasts", "echo_comment_id", 10, 1); funkcija echo_comment_id($comment_ID)( echo "Es tikko saņēmu". $comment_ID; )
#3 Anonīma funkcija
Jūs varat nodot anonīmu funkciju kā atzvanīšanas funkciju, piemēram:
Add_action("wp_head", function())( echo "kaut kas"; ));
Šādas anonīmas funkcijas nedarbojas ar PHP paātrinātājiem.
#4 Notikuma pievienošana no PHP klases
Ja notikumam ir jāizmanto PHP klases metode, tad otrajā argumentā funkcijas nosaukuma vietā ir jānorāda masīvs, kur pirmais arguments ir klases nosaukums (statiskajai metodei) vai klases gadījums (publiskajai metodei), un otrais ir šīs klases metodes nosaukums.
Klases gadījums atrodas mainīgajā $this:
// Klases metodes pievienošana ārpus klases add_action("wp_head", array("My_Class", "my_static_method")); class My_Class (publiskā funkcija __construct() ( // Klases metodes savienošana klasē add_action("save_post", array($this, "my_public_method")); add_action("save_post", array(__CLASS__, "my_static_method")) ; ) publiskā funkcija my_public_method($post_id) ( // funkcijas kods ) statiskā funkcija my_static_method($post_id) ( // funkcijas kods ) )
Piezīmes
Lai uzzinātu, cik argumentu darbība iztur, atrodiet to kodā un apskatiet. Piemēram, šeit tiek nodoti 2 argumenti:
Do_action("save_post", $post_ID, $post);
un šādam āķim āķa kods izskatīsies šādi:
Add_action("save_post", "my_save_post", 10, 2);
un funkcijai būs 2 argumenti:
Funkcija my_save_post($post_ID, $post)( // funkcijas kods šeit)
Izveido notikumu (āķis patvaļīgai funkcijai). Lai funkcija darbotos notikuma laikā, tai jābūt savienotai ar šo notikumu, izmantojot funkciju add_action().
Papildus notikumiem WP ir arī filtri, darbības princips ir vienāds. Vienīgā atšķirība ir tāda, ka filtram ir jāatgriež iegūtais mainīgais, t.i. tas filtrē (pārveido) datus, un notikums ļauj palaist pielāgotu funkciju, kad notikums tiek aktivizēts. Filtri tiek palaisti, izmantojot funkciju apply_filters().
✈ 1 reize = 0,00007 s = ļoti ātri| 50 000 reizes = 0,03 s = gaismas ātrums
Āķu nav.
Atgriežas
Neko neatdod.
Lietošana
do_action($tag, $arg_a, $arg_b, ...); $tag (virkne) (obligāti) Veidojamā āķa nosaukums. $arg_a Argumenta vērtība, kas tiks nodota.$arg_b (virkne/masīvs/skaitlis/objekts/būla) Vēl viena argumenta nozīme...
Noklusējums: arguments neeksistē$arg_с (virkne/masīvs/skaitlis/objekts/būla) Funkcijai var nodot bezgalīgi daudz argumentu...
Piemēri
#1. Lietošanas piemērs
Šo funkciju var izmantot spraudņos, motīvos utt., kad jums ir jāievada koda izpildes procesā no kaut kurienes citur. Piemēram, mēs spraudnī uzstādījām “āķi” (do_action), un mēs to “noķersim” no faila functions.php brīdī, kad tiks aktivizēts mūsu “āķis”.
Pieņemsim, ka spraudnī izmantojām šo kodu:
Tagad mēs varam veikt kādu darbību brīdī, kad tiek aktivizēta funkcija do_action, un tajā pašā laikā mēs varam aprakstīt savu darbību, piemēram, no faila functions.php, ievietojot tajā šādu kodu:
Funkcija do_my_hook($a, $b)( // ja nodotais mainīgais $a ir patiess, // tad, piemēram, izdzēsiet ziņu 10 if($a===true) wp_delete_post(10); // un tad vienkārši parādīt mainīgo uz ekrāna atbalsi "
".$b; // parādīs otrā mainīgā vērtību ) // Reģistrējiet āķi, izmantojot // add_action($tag, $function_to_add, $priority, $accepted_args); add_action("my_hook", "do_my_hook", 10 , 2);
Darbības atšķiras no filtriem ar to, ka darbības nodotie dati netiek atgriezti funkcijā un netiek tur izmantoti turpmāk, bet tiek vienkārši nodoti izmantošanai āķa funkcijā.
Kods veikt darbību: wp-includes/plugin.php WP 5.2.2
do_action($args); masīvs_pop($wp_current_filter); )Mēs esam izveidojuši pamatu nākotnes spraudnim, ko atpazīs WordPress sistēma. Šodien mēs tieši mainīsim sistēmas pamata funkcionalitāti.
Šajā jautājumā mums palīdzēs “āķu”, “notikumu” (darbību) un filtru (filtru) sistēma. Šie trīs jēdzieni ir katra WordPress spraudņa pamatā.
Āķi
WordPress ir divu veidu āķi:
- Darbības āķis: atzīmē vietu kodā, kas veic noteiktu darbību, piemēram, ir nepieciešams ievadīt dažus datus un saglabāt tos datu bāzē.
- Filtra āķis: atzīmē filtru, kas mainīs kādu vērtību (mainīgo), lai turpmāk kods izmantotu modificēto vērtību.
Darbības
Darbs ar notikumiem (darbības)
Vispārējā notikumu pārvaldības loģika programmā WordPress ir vienkārša:
- Atzīmējiet vietu, kur darbība jāveic, izmantojot darbības āķi ar nepieciešamajiem parametriem.
- Izveidojiet funkciju, kas veiks vēlamās darbības, izmantojot āķa nodotos parametrus.
- Reģistrējiet notikumu, kas tiks izpildīts, kad āķis izšaus, ar noteiktu prioritāti.
- Kad WordPress ielādē lapu un atrod āķi, sistēma izpildīs visas šim āķim reģistrētās funkcijas.
Lai izpildītu pirmo punktu, sistēma nodrošina funkciju “do_action”:
Do_action($tag, $arg_1, $arg_2, ... , $arg_n);
Tam nepieciešami šādi argumenti: $tag – “āķa” nosaukums, $arg_1, $arg_2, ..., $arg_n – parametri, ar kuriem funkcija tiks izsaukta. Var būt jebkurš argumentu skaits vai 0.
Pašai sistēmai jau ir definēti daudzi āķi:
Do_action("init");
Šis ir ļoti vienkāršs piemērs bez papildu argumentiem. Šis āķis tiek aktivizēts, kad lielākā daļa sistēmas jau ir konfigurēta un ir pienācis laiks izveidot savus objektus, kategorijas, ziņas utt.
Do_action("save_post", $post_id, $post);
Šajā piemērā āķis tiek aktivizēts, kad ziņa tiek saglabāta ar diviem argumentiem post_id — ziņas identifikators un post — pati ziņa.
Āķu izveide ir pieejama ikvienam izstrādātājam, lai izveidotu savu spraudni (vai motīvu). Pateicoties tam, mums ir spēcīgs rīks sistēmas uzvedības kontrolei.
Do_action("mans_patiesi_pielāgots_āķis");
Kad esam izveidojuši āķi un uzrakstījuši funkciju, funkcija jāreģistrē, izmantojot “add_action”
Add_action($tag, $funkcija_pievienošanai, $prioritāte, $accepted_args_number);
Funkcijai "add_action" ir nepieciešami divi obligātie parametri: $tag: atbilstošā āķa nosaukums un $function_to_add: izsaucamās funkcijas nosaukums. Pārējie divi parametri nav obligāti: $priority: vesels skaitlis mainīgais, kas nosaka secību, kādā funkcija tiek izpildīta (noklusējums ir 10), $accepted_args_number: argumentu skaits, ko funkcija pieņem (noklusējums ir 1).
Apskatīsim piemēru, lai izprastu visu procesu. Pieņemsim, ka mēs vēlamies pievienot nelielu paziņojumu mūsu vietnes apakšā. Šim nolūkam mēs varam izmantot āķi “wp_footer”, jo tā ir obligāta koda daļa, ko izmanto katrs motīvs.
Funkcija msp_helloworld_footer_notice())( echo "
Šajā piemērā mēs izveidojām funkciju, kas vienkārši atveido brīdinājuma marķējumu, un reģistrējām to ar “wp_footer”. Kad mēs pievienosim šo kodu mūsu spraudņa failam (skatiet iepriekšējo), mēs redzēsim rezultātu lapā:
WordPress spraudņa brīdinājums
Darbs ar filtriem
Filtri darbojas tāpat kā notikumi. Taču filtri ne tikai izpilda noteiktu koda daļu, bet arī maina vērtības, ko tiem nodod āķis. Tas nozīmē, ka katram filtram ir saistīta vērtība (mainīgais), ar kuru tas darbojas.
Filtra funkcija ņems šo vērtību un pārveidos to turpmākai lietošanai. Filtru āķi nedaudz atšķiras no darbības āķiem.
Apply_filters($tag, $vērtība_filtram, $arg_1, $arg_2, ... , $arg_n);
Funkcija "apply_filter" izveido filtra āķi ar nosaukumu $tag un nepieciešamo parametru $value_to_filter (tas var būt tukšs, bet tas ir jādeklarē). Pārējie izvēles argumenti darbojas tāpat kā notikumiem.
Filtra_funkcija($vērtība_filtram, $arg_1, $arg_2, ... , $arg_n)( //filtrs return $value_to_filter; //vērtība ir jāatgriež)
Šis ir filtra "skelets", kas parāda, ka filtram:
- pieņemt vismaz 1 argumentu;
- atgriezt modificēto vērtību.
Funkcija 'add_filter' reģistrē funkciju ar nosaukumu, kas ietverts $function_to_add $tag āķim. Pārējie argumenti - $priority un $accepted_args - darbojas tāpat kā notikumu āķiem.
Apskatīsim piemēru: izplatīts spraudņa uzdevums ir kaut ko pievienot ziņas beigām. Ja mēs tuvāk aplūkosim funkciju 'the_content', kas tiek izmantota ziņas satura attēlošanai, mēs atradīsim šādu āķi:
$saturs = pieteikties_filtri("saturs", $saturs);
Izmantojot to, mēs varam viegli pievienot kaut ko ziņas beigām.
Funkcija msp_helloworld_post_footer($content) ( $content .= "
"; return $content; ) add_filter("saturs", "msp_helloworld_post_footer", 100);Ņemiet vērā, ka prioritātei mēs izmantojam lielu skaitu, lai nodrošinātu, ka visi standarta filtri tiek izpildīti pirms 'msp_helloworld_post_footer' izpildes. Pēc koda ievietošanas mūsu spraudnī mēs redzēsim rezultātu:
Kā atrast āķi
Tagad mēs saprotam, ka, lai veiktu noteiktas darbības, mums ir jāzina par esošajiem āķiem.
WordPress kodekss nodrošina filtru un darbību atsauces un filtru atsauces notikumu sarakstus.
Papildu darbības ar āķiem
Tāpat kā pievienošanu, āķi var noņemt, izmantojot līdzīgu sintaksi.
Varat dzēst šādus notikumus:
Remove_action($tag, $function_to_remove, $priority, $accepted_args); noņemt_visas_darbības($tag, $prioritāte);
Kā jau varēja nojaust, 'remove_action' noņem konkrētu notikumu, kas reģistrēts konkrētajam āķim (pareizi jānorāda prioritāte un argumentu skaits, kā tas tika norādīts reģistrācijas laikā), un 'remove_all_actions' palīdz noņemt visus āķim reģistrētos notikumus ( ja prioritāte ir izlaista, funkcija dzēsīs visus notikumus).
Filtrus var dzēst tādā pašā veidā:
Remove_filter($tag, $function_to_remove, $priority, $accepted_args); noņemt_visus_filtrus($tag, $prioritāte);
WordPress spraudņa API nodrošina arī funkcijas, lai pārbaudītu, vai funkcija ir reģistrēta konkrētam āķim:
Has_action($tag, $funkcija_pārbaudīt); has_filter($tag, $function_to_check);
Abas funkcijas pārbauda, vai dotā funkcija ir reģistrēta āķim, un atgriež patiesu, ja tas ir veiksmīgs, pretējā gadījumā flase. Funkcijā mums ir iespēja pārbaudīt, vai āķis to sauca:
If("hook_to_check_name" === pašreizējais_filtrs())()
Neskatoties uz nosaukumu 'current_filter', tas darbojas ne tikai ar filtriem, bet arī ar notikumiem.
Netriviāls piemērs
Atdzīvināsim mūsu spraudņa “skeletu”, kuru sagatavojām pēdējā nodarbībā.
Aizpildīsim failu “core.php” (mūsu spraudņa galvenā daļa, kas satur lielāko daļu funkciju) ar kodu, kas atrisina problēmu, kas var rasties darba laikā. Lai to atrisinātu, mēs izmantosim darbības un filtrus.
Ļaujiet savai WordPress vietnei pieņemt dažādu autoru ziņas no viesiem, taču neļauj jums izveidot kontus. Tas nozīmē, ka lietotājs, kurš publicēja ierakstu, un patiesais autors ir dažādi cilvēki un mums ir jāpārliecinās, ka ierakstā ir norādīts autors. Mēs to varam izdarīt, izmantojot taksonomiju.
Veidosim savu taksonomiju, lai apstrādātu autora vārdu un īso biogrāfiju. Rakstā varēsim izmantot autora vārdu kā citus taksonomijas terminus (tagus, piemēram). Kods:
/** reģistrēt filtrus un notikumus **/ funkcija 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"); /** taksonomija **/ funkcija msp_helloworld_taxonomies())( $args = array("labels" => array("name" => "Viesautori", "singular_name" => "Viesautors"), "show_in_nav_menus" = > false); register_taxonomy("gauthor", array("post"), $args); ) /** autora bloka iezīmēšana **/ funkcija msp_helloworld_author_block())(globāls $post; $author_terms = wp_get_object_terms($post-> ID, "gauthor"); if(empty($author_terms)) return; $name = svītras svītras($autora_nosaukums->nosaukums); $url = esc_url(get_term_link($author_terms)); $desc = wp_filter_post_kses($author_terms-> apraksts) ; $out = "
"; return $out; ) /** pievienot marķējumu ziņas beigām **/ funkcija msp_helloworld_author_block_filter($content)( if(is_single()) $content .= msp_helloworld_author_block(); atgriezties $content; ) /** pievienot publicēšanai CSS klasi **/ funkcija msp_helloworld_post_class($post_class)(globāls $post; $author_terms = wp_get_object_terms($post->ID, "gauthor"); if(!empty($author_terms))( $post_class = "gauthor "; ) atgriezt $post_class;)Kā redzat, mēs esam izveidojuši funkciju, lai reģistrētu savu taksonomiju un piesaistītu to 'init' āķim. Pēc tam mēs izveidojām veidni, kas ir atbildīga par autora bloka parādīšanu, izmantojot WordPress funkciju “wp_get_object_terms”. Pēc tam ziņojuma beigās ievietojām bloku ar informāciju par autoru, izmantojot filtru “the_content”. Visbeidzot, mēs pievienojām savu CSS klasi. Rezultāts:
