Exact acțiunea php. PHP și formulare

„Nu folosiți declarația goto”- așa ne-au spus profesorii de la academie și, într-adevăr, acest operator transformă codul într-o mizerie completă. Dezvoltatorii PHP au rezolvat problema în mod radical - pur și simplu nu există în PHP3 și PHP4. De ce au fost motivați inițial? Poate că au vrut să ne insufle tuturor stilul de programare corect? Ei bine, putem spune că au reușit complet - suntem cu toții deja obișnuiți, adică ne-am pierdut complet obiceiul acestui operator, poate că e mai bine, pentru că la un moment dat a trebuit să vin cu o construcție logică care să fie pe deplin compensat pentru aceasta cea mai nefericită mergi la.
Nu știu cum este pentru nimeni, dar pentru mine, în special, am avut deseori dorința de a folosi goto atunci când creez un handler de formulare html, când sunt trimise multe date de la utilizator la server, ceea ce trebuie script-ul php. verifica pas cu pas. Acest proces, de regulă, are loc în mai multe etape: imprimarea formularului în sine, verificarea datelor primite, afișarea preliminară și, de exemplu, salvarea. Mai mult, unele etape pot fi repetate: dacă verificarea datelor nu a decurs bine, trecem la tipărirea formularului, sau dacă afișarea preliminară nu convine utilizatorului, acesta poate reveni la introducerea datelor. Pe scurt, unele bucăți de cod pot fi folosite de mai multe ori. Utilizarea funcțiilor în aceste condiții nu este, de asemenea, foarte convenabilă - există o mulțime de variabile de intrare și de ieșire, funcția trebuie să efectueze acțiuni prea complexe, se dovedește, în general, stângace, iar lizibilitatea codului scade brusc.
Și am venit cu acest design.

face ( comutați ($acțiune) ( Mod implicit: pauză ; cazul „PRINT_FORM”: Tipărirea formularului principal pauză ; cazul „CHECK_FORM”: Verificarea corectitudinii datelor pauză ; cazul „PREVIEW_FORM” : previzualizare pauză ; cazul „SAVE_FORM”: Salvarea datelor pauză ; ) în timp ce (adevărat);

Iată operatorul de bază de selecție multiplă intrerupator prins într-o buclă nesfârșită face în timp ce– astfel grupăm acțiunile necesare pe secțiuni caz: rupere;și ne putem deplasa nelimitat de la o secțiune la alta. In sectiune Mod implicit: Este convenabil să faceți o analiză preliminară a datelor, de exemplu, dacă nu există date de intrare atunci $action = 'PRINT_FORM' tipăriți formularul dacă este disponibil, de exemplu $_POST ['trimite'] apoi trimitem datele primite spre prelucrare $action = 'VERIFICARE_FORMULUI'. Transferul controlului între blocurile comutatoare are loc prin schimbarea unei variabile $actiune, bine, ieși din buclă folosind pauză 2; sau ieșire;
De exemplu, în blocul de imprimare al formularului principal puteți pune în siguranță pauză 2; deoarece ieșirea formularului presupune sfârșitul scriptului.
Designul este foarte flexibil și ușor de citit. Dar există un dezavantaj - dacă datele sunt procesate incorect, puteți ajunge într-o buclă nesfârșită și scriptul se blochează - este neplăcut să așteptați până la 30 de secunde.
Să stabilim o limită pentru numărul de cicluri de operare face în timp ce, 20 este suficient. Acum, dacă am pompat ceva, scenariul va face 20 de revoluții, se va opri și va emite un avertisment de oprire de urgență.
Este foarte convenabil să depanați o astfel de construcție - imediat după operator swith tipăriți variabila $action și vom obține secvența completă de execuție a blocului.

DO ( // la începutul fiecărei bucle tipărim numele // secțiunii executate, foarte convenabil pentru depanarea echo $acțiune." "; SWITCH ($acțiune) ( implicit: break; case "PRINT_FORM": /* tipăriți formularul principal */ break; case "CHECK_FORM": /* verificați că datele sunt corecte */ break; case "PREVIEW_FORM": /* previzualizare * / break ; case "SAVE_FORM": /* salvează datele */ break )// switch final ) WHILE (($i++)< 20) or die("Принудительный останов цикла"));

DO( // la începutul fiecărei bucle tipărim numele // secțiunea executată este foarte convenabilă pentru depanare echo $actiune . " " ;< / strong > SWITCH ($acțiune) ( Mod implicit: pauză ; cazul „PRINT_FORM”: tipăriți formularul principal pauză ;

RxGroovy are mai multe variante Do.

• Javadoc:
• Javadoc:

• Javadoc:

Operatorul doOnRequest (nou în RxGroovy 1.1) înregistrează o Acțiune care va fi apelată ori de câte ori un observator solicită elemente suplimentare de la Observatorul rezultat. Acțiunea respectivă primește ca parametru numărul de articole pe care observatorul le solicită.

• Javadoc:

• Javadoc:

• Javadoc:

• Javadoc:

• Javadoc:

inainte de

• Javadoc:

după observabilul rezultat se termină, fie în mod normal, fie cu o eroare.

Cod simplu

def numere = Observable.from(); numere.finallyDo(( println("În sfârșit"); )).subscribe(( println(it); ), // onNext ( println("Eroare: " + it.getMessage()); ), // onError ( println („Secvență completă”) // onCompleted);

1 2 3 4 5 Secvență completă În sfârșit

• Javadoc:

RxJava are mai multe variante Do.

Operatorul doOnEach vă permite să stabiliți un apel invers pe care observatorul rezultat îl va apela de fiecare dată când emite un articol. Puteți transmite acest apel invers fie sub forma unei acțiuni care ia ca unic parametru o varietate onNext de Notificare, fie puteți trece într-un Observator a cărui metodă onNext va fi apelată ca și cum s-ar fi abonat la Observable.

• Javadoc:
• Javadoc:

Operatorul doOnNext seamănă mult cu doOnEach(Action1), cu excepția faptului că Acțiunea pe care o transmiteți ca parametru nu acceptă o Notificare, ci pur și simplu acceptă elementul emis.

Cod simplu

Observabil.just(1, 2, 3).doOnNext(nouă Acțiune1 () ( @Override public void call(articol întreg) ( if(articol > 1) ( aruncă o nouă excepție RuntimeException(„Elementul depășește valoarea maximă”); ) ) )).subscribe(abonat nou () ( @Override public void onNext(Integer item) ( System.out.println("Next: " + item); ) @Override public void onError(Throwable error) ( System.err.println("Eroare: " + eroare) .getMessage());

Următorul: 1 Eroare: Elementul depășește valoarea maximă

• Javadoc:

Operatorul doOnRequest (nou în RxJava 1.1) înregistrează o Acțiune care va fi apelată ori de câte ori un observator solicită elemente suplimentare de la Observatorul rezultat. Acțiunea respectivă primește ca parametru numărul de articole pe care observatorul le solicită.

• Javadoc:

Operatorul doOnSubscribe înregistrează o Acțiune care va fi apelată ori de câte ori un observator se abonează la observabilul rezultat.

• Javadoc:

Operatorul doOnUnsubscribe înregistrează o Acțiune care va fi apelată ori de câte ori un observator se dezabonează de la Observatorul rezultat.

• Javadoc:

Operatorul doOnCompleted înregistrează o Acțiune care va fi apelată dacă observabilul rezultat se termină normal, apelând onCompleted .

• Javadoc:

Operatorul doOnError înregistrează o Acțiune care va fi apelată dacă observatorul rezultat se termină anormal, apelând onError . Această acțiune i se va trece Throwable reprezentând eroarea.

• Javadoc:

Operatorul doOnTerminate înregistrează o Acțiune care va fi numită just inainte de observabilul rezultat se termină, fie în mod normal, fie cu o eroare.

• Javadoc:

finallyDo este depreciat din RxJava 1.1.1, în favoarea doAfterTerminate cu același comportament.

Operatorul finallyDo înregistrează o Acțiune care va fi numită just după observabilul rezultat se termină, fie în mod normal, fie cu o eroare.

• Javadoc:

Operatorul doAfterTerminate înregistrează o Acțiune care va fi numită just după observabilul rezultat se termină, fie în mod normal, fie cu o eroare.

• Javadoc:

RxJS implementează operatorul Do de bază ca do sau tap (două nume pentru același operator). Aveți două opțiuni pentru a utiliza acest operator:

1. Îi puteți transmite un Observator, caz în care do / atingeți va apela metodele acelui Observator ca și cum acel Observator s-ar fi abonat la Observatorul rezultat.
2. Puteți trece un set de 1-3 funcții individuale (onNext , onError și onCompleted) care apelează / tap vor apela împreună cu funcțiile cu nume similar ale oricăruia dintre observatorii săi.

Cod simplu

/* Folosind un observator */ var observer = Rx.Observer.create(function (x) ( console.log("Do Next: %s", x); ), function (err) ( console.log("Do Error) : %s”, err); ), funcția () ( console.log(„Fă finalizat”); )); var source = Rx.Observable.range(0, 3) .do(observer); var subscription = source.subscribe(funcție (x) ( console.log("Următorul: %s", x); ), funcție (err) ( console.log ("Eroare: %s", err); ), funcția () ( console.log ("Finalizat"); ));

/* Folosind o funcție */ var source = Rx.Observable.range(0, 3) .do(function (x) ( console.log("Do Next:", x); ), function (err) ( console. log("Efectuați Eroare:", err ), funcția () ( console.log("Efectuați finalizat"); )); var subscription = source.subscribe(funcție (x) ( console.log("Următorul: %s", x); ), funcție (err) ( console.log ("Eroare: %s", err); ), funcția () ( console.log ("Finalizat"); ));

Faceți Următorul: 0 Următorul: 0 Faceți Următorul: 1 Următorul: 1 Faceți Următorul: 2 Următorul: 2 Faceți Terminat Terminat

RxJS implementează și doOnNext sau tapOnNext (două nume pentru același operator). Este o formă specializată de Do care răspunde doar la cazul onNext, apelând o funcție de apel invers pe care o furnizați ca parametru. De asemenea, puteți trece opțional un al doilea parametru care va fi obiectul „this” din punctul de vedere al funcției de apel invers atunci când se execută.

Cod simplu

var source = Rx.Observable.range(0, 3) .doOnNext(function () ( this.log("Do Next: %s", x); ), console); var subscription = source.subscribe(funcție (x) ( console.log("Următorul: %s", x); ), funcție (err) ( console.log ("Eroare: %s", err); ), funcția () ( console.log ("Finalizat"); ));

Următorul: 0 Următorul: 0 Următorul: 1 Următorul: 1 Următorul: 2 Următorul: 2 Finalizat

RxJS implementează și doOnError sau tapOnError (două nume pentru același operator). Este o formă specializată de Do care răspunde doar la cazul onError, apelând o funcție de apel invers pe care o furnizați ca parametru. De asemenea, puteți trece opțional un al doilea parametru care va fi obiectul „this” din punctul de vedere al funcției de apel invers atunci când se execută.

Cod simplu

var source = Rx.Observable.throw(new Error()); .doOnError(funcție (erre) ( this.log ("Efectuați o eroare: %s", err); ), console); var subscription = source.subscribe(funcție (x) ( console.log("Următorul: %s", x); ), funcție (err) ( console.log ("Eroare: %s", err); ), funcția () ( console.log ("Finalizat"); ));

Do Error: Error Error: Eroare

RxJS implementează și doOnCompleted sau tapOnCompleted (două nume pentru același operator). Este o formă specializată de Do care răspunde doar la cazul onCompleted, apelând o funcție de apel invers pe care o furnizați ca parametru. De asemenea, puteți trece opțional un al doilea parametru care va fi obiectul „this” din punctul de vedere al funcției de apel invers atunci când se execută.

Cod simplu

var source = Rx.Observable.range(0, 3) .doOnCompleted(function () ( this.log("Do Completed"); ), console); var subscription = source.subscribe(funcție (x) ( console.log("Următorul: %s", x); ), funcție (err) ( console.log ("Eroare: %s", err); ), funcția () ( console.log ("Finalizat"); ));

Următorul: 0 Următorul: 1 Următorul: 2 Terminat Terminat

RxJS implementează și un operator finally. Este nevoie de o funcție care va fi apelată după terminarea observabilului rezultat, indiferent dacă este normal (onCompleted) sau anormal (onError).

Cod simplu

var source = Rx.Observable.throw(new Error()) .finally(function () ( console.log("In sfarsit"); )); var subscription = source.subscribe(funcție (x) ( console.log("Următorul: " + x); ), funcția (err) ( console.log ("Eroare: " + err);), function () (consola .log(„Finalizat”);

Eroare: Eroare În sfârșit

do / tap , doOnNext / tapOnNext , doOnError / tapOnError , doOnCompleted / tapOnCompleted și, în final, se găsesc în fiecare dintre următoarele distribuții:

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

RxPHP implementează acest operator la fel ca și .

Invocă o acțiune pentru fiecare element din secvența observabilă și invocă o acțiune la terminarea grațioasă sau excepțională a secvenței observabile. Această metodă poate fi folosită pentru depanare, logare etc. a comportamentului interogării prin interceptarea fluxului de mesaje pentru a rula acțiuni arbitrare pentru mesajele din conductă. Când utilizați do, este important să rețineți că Observatorul poate primi evenimente suplimentare după ce un flux s-a finalizat sau a greșit (cum ar fi atunci când utilizați o repetare sau o reabonare). Dacă utilizați un Observable care extinde AbstractObservable, nu veți primi aceste evenimente. Pentru acest caz special, utilizați DoObserver. doOnNext, doOnError și doOnCompleted utilizează DoObserver intern și vor primi aceste evenimente suplimentare.

Cod simplu

//din 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; ), funcția (Throwable $err) ( echo „Efectuați eroare:”, $err->getMessage(), PHP_EOL; ), funcția () ( echo „Do Completed” , PHP_EOL )); $subscription = $sursa->subscribe($stdoutObserver);

Do Next:0 Următoarea valoare: 0 Do Next:1 Următoarea valoare: 1 Do Next:2 Următoarea valoare: 2 Do Completed Complete!

RxPHP are și un operator doOnError.

Cod simplu

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

Efectuați Eroare: Hopa Excepție: Hopa

RxPHP are, de asemenea, un operator doOnCompleted.

Cod simplu

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

Completați complet!

RxPHP are, de asemenea, un operator în sfârșit.

Va apela o funcție specificată atunci când sursa se termină la finalizare sau eroare.

Cod simplu

//de la https://github.com/ReactiveX/RxPHP/blob/master/demo/finally/finally.php Rx\Observable::range(1, 3) ->finally(function() ( echo „În sfârșit\n "; )) ->subscribe($stdoutObserver);

Următoarea valoare: 1 Următoarea valoare: 2 Următoarea valoare: 3 Complete! In cele din urma

//de la https://github.com/ReactiveX/RxPHP/blob/master/demo/finally/finally-error.php Rx\Observable::range(1, 3) ->map(function($value) ( ​​​​if ($valoare == 2) (aruncă o nouă \Excepție(„eroare”); ) returnează $valoare )) ->finally(function() (echo „În sfârșit\n”; )) ->subscribe($stdoutObserver) ;

Următoarea valoare: 1 Excepție: eroare În sfârșit

Atașează funcția PHP specificată la cârligul specificat. Funcția specificată se va declanșa în momentul evenimentului, care la rândul său este declanșat folosind do_action() .

Hook-ul la care funcția este legată este creat (inițializat) folosind funcția do_action().

Acțiunile, spre deosebire de filtre (add_filter()), sunt necesare pentru a efectua anumite acțiuni la momentul potrivit, în timp ce filtrele transmit și primesc înapoi date, care sunt apoi utilizate.

Neoficial: filtrele sunt aceleași evenimente, funcționează exact la fel și pot fi folosite ca evenimente (în loc de add_filter() poți folosi funcția add_action() și invers). De exemplu, puteți returna datele primite fără a le modifica, dar în plus efectuați o operațiune (de exemplu, scrierea într-o bază de date). Adevărat, acest lucru este necesar foarte rar. Toate locurile în care este necesar să se intervină în codul motorului, dezvoltatorii încearcă să prevadă și să introducă un eveniment în acest loc.

✈ 1 dată = 0,000018s = foarte rapid| 50000 ori = 0,07s = viteza luminii| PHP 7.0.8, WP 4.7

Nu există cârlige.

Se intoarce

Întotdeauna adevărat.

Utilizare

add_action($tag, $function_to_add, $priority, $accepted_args); $tag (șir) (obligatoriu) Numele acțiunii la care vom atașa funcția. $function_to_add (sir/închidere) (obligatoriu) Numele funcției care ar trebui apelată atunci când acțiunea se declanșează, de exemplu. o funcție pe care o atașăm unui cârlig. Formatul de transmitere a funcției este de obicei un șir, . $prioritate (număr) Prioritatea de execuție a funcției. Dacă mai multe funcții sunt „atașate” aceluiași cârlig, atunci prioritatea va fi determinată de succesiunea executării lor. Un număr mai mic înseamnă că este executat mai devreme, adică. 10 va fi executat înainte de 20.
Implicit: 10$accepted_args (număr) Numărul de argumente pe care le ia funcția. Desigur, acțiunea trebuie să treacă acest număr de argumente.
Implicit: 1

Exemple

# 1 Cârlig obișnuit

Vom trimite o scrisoare prietenilor când va fi publicată o nouă postare:

Add_action("publicare_post", "email_prieteni"); funcția email_friends($post_ID)( $prieteni = " [email protected], [email protected]"; wp_mail($prieteni, "sally's blog updated", "Tocmai am pus ceva pe blogul meu: http://blog.example.com"); returnează $post_ID; )

În mod similar, puteți înregistra acest cârlig prin add_filter():

Add_filter("publicare_post", "email_prieteni");

# 2 Obținerea unui argument

do_action() transmite un argument funcției și poate fi folosit. În exemplul anterior a fost ID-ul postării, dar nu l-am folosit, așa că nu am avut nevoie de el. Acum, un exemplu de utilizare a argumentului transmis:

Add_action("coment_id_nu_găsit", "echo_comment_id", 10, 1); function echo_comment_id($comment_ID)( echo "Tocmai am primit". $comment_ID; )

# 3 Funcție anonimă

Puteți transmite o funcție anonimă ca funcție de apel invers, de exemplu:

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

Astfel de funcții anonime nu funcționează cu acceleratoarele PHP.

#4 Adăugarea unui eveniment dintr-o clasă PHP

Dacă trebuie să utilizați o metodă de clasă PHP pentru un eveniment, atunci în al doilea argument, în loc de numele funcției, trebuie să specificați o matrice, unde primul argument este numele clasei (pentru o metodă statică) sau un instanță a clasei (pentru o metodă publică), iar al doilea este numele metodei acestei clase.

Instanța clasei se află în variabila $this:

// Conectarea unei metode de clasă în afara clasei add_action("wp_head", array("My_Class", "my_static_method")); clasa My_Class (funcția publică __construct() ( // Conectarea unei metode de clasă în interiorul clasei add_action("save_post", array($this, "my_public_method")); add_action("save_post", array(__CLASS__, "my_static_method")) ; ) funcția publică my_public_method($post_id) ( // codul funcției ) funcția statică my_static_method($post_id) ( // codul funcției ) )

Note

Pentru a afla câte argumente trece o acțiune, găsiți-o în cod și căutați. De exemplu, aici sunt transmise 2 argumente:

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

și pentru un astfel de cârlig, codul de cârlig va arăta astfel:

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

iar funcția va avea 2 argumente:

Funcția my_save_post($post_ID, $post)( // codul funcției aici)

Creează un eveniment (un cârlig pentru o funcție arbitrară). Pentru ca o funcție să funcționeze în momentul unui eveniment, trebuie să fie conectată la acest eveniment folosind funcția add_action().

Pe lângă evenimente, WP are și filtre, principiul de funcționare este același. Singura diferență este că filtrul trebuie să returneze variabila rezultată, adică. filtrează (modifică) datele, iar evenimentul vă permite să rulați o funcție personalizată atunci când evenimentul se declanșează. Filtrele sunt lansate folosind funcția apply_filters().

✈ 1 dată = 0,00007s = foarte rapid| 50000 de ori = 0,03s = viteza luminii

Nu există cârlige.

Se intoarce

Nu returnează nimic.

Utilizare

do_action($tag, $arg_a, $arg_b, ...); $tag (șir) (obligatoriu) Numele cârligului de creat. $arg_a Valoarea argumentului care va fi transmis.
$arg_b (șir/matrice/număr/obiect/boolean) Sensul încă un argument...
Implicit: argumentul nu există$arg_с (șir/matrice/număr/obiect/boolean) Puteți trece un număr infinit de argumente unei funcții...

Exemple

#1. Exemplu de utilizare

Această funcție poate fi folosită în pluginuri, teme etc. atunci când trebuie să vă injectați în procesul de execuție a codului din altă parte. De exemplu, am instalat un „hook” (do_action) în plugin și îl vom „prinde” din fișierul functions.php în momentul în care „hook”-ul nostru este declanșat.

Să presupunem că am folosit acest cod în plugin:

Acum putem face o anumită acțiune în momentul în care funcția do_action este declanșată și, în același timp, putem descrie acțiunea noastră, de exemplu, din fișierul functions.php, plasând următorul cod în el:

Funcția do_my_hook($a, $b)( // dacă variabila transmisă $a este adevărată, // atunci, de exemplu, ștergeți postarea 10 if($a===true) wp_delete_post(10); // și apoi doar afișează variabila la ecoul ecranului "
".$b; // va afișa valoarea celei de-a doua variabile ) // Înregistrați hook-ul prin // add_action($tag, $function_to_add, $priority, $accepted_args); add_action("my_hook", "do_my_hook", 10 , 2);

Acțiunile diferă de filtre prin faptul că datele transmise de acțiune nu sunt returnate înapoi în funcție și nu sunt folosite acolo în viitor, ci sunt pur și simplu transmise pentru utilizare în funcția de cârlig.

Cod face actiune: wp-includes/plugin.php WP 5.2.2

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

Am creat fundația unui viitor plugin care va fi recunoscut de sistemul WordPress. Astăzi vom schimba direct funcționalitatea de bază a sistemului.

Un sistem de „cârlige”, „evenimente” (acțiuni) și filtre (filtre) ne vor ajuta în acest sens. Aceste trei concepte sunt baza fiecărui plugin WordPress.

Cârlige

Există două tipuri de cârlige în WordPress:

• Cârlig de acțiune: marchează un loc în cod care efectuează o anumită acțiune, de exemplu, este necesar să introduceți niște date și să le salvați în baza de date.
• Cârlig de filtru: marchează un filtru care va schimba o anumită valoare (variabilă), astfel încât în ​​viitor codul să folosească valoarea modificată.

Acțiuni

Lucrul cu evenimente (acțiuni)

Logica generală pentru gestionarea evenimentelor în WordPress este simplă:

1. Marcați locul unde trebuie efectuată acțiunea folosind un cârlig de acțiune cu parametrii necesari.
2. Creați o funcție care va efectua acțiunile dorite folosind parametrii trecuți de cârlig.
3. Înregistrați un eveniment care va fi executat la declanșarea cârligului, cu o anumită prioritate.
4. Când WordPress încarcă o pagină și găsește un hook, sistemul va executa toate funcțiile care sunt înregistrate în acel hook.

Pentru a realiza primul punct, sistemul oferă funcția „do_action”:

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

Ia următoarele argumente: $tag – numele „cârligului”, $arg_1, $arg_2, ..., $arg_n – parametrii cu care va fi apelată funcția. Poate exista orice număr de argumente sau 0.

Sistemul în sine are multe cârlige deja definite:

Do_action("init");

Acesta este un exemplu foarte simplu, fără argumente suplimentare. Acest cârlig este declanșat atunci când majoritatea sistemului este deja configurat și este timpul să vă creați propriile obiecte, categorii, postări etc.

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

În acest exemplu, cârligul este declanșat atunci când o postare este salvată cu două argumente post_id - identificatorul postării și post - postarea în sine.

Crearea de cârlige este disponibilă oricărui dezvoltator pentru a-și crea propriul plugin (sau temă). Datorită acestui fapt, avem un instrument puternic pentru controlul comportamentului sistemului.

Do_action(„cârligul_cu_adevărat_personalizat”);

Odată ce am creat cârligul și am scris funcția, trebuie să înregistrăm funcția folosind „add_action”

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

Funcția „add_action” ia doi parametri necesari: $tag: numele hook-ului corespunzător și $function_to_add: numele funcției care trebuie apelată. Ceilalți doi parametri sunt opționali: $priority: o variabilă întreagă care determină ordinea în care funcția este executată (implicit este 10), $accepted_args_number: numărul de argumente pe care funcția le acceptă (implicit este 1).

Să ne uităm la un exemplu pentru a înțelege întregul proces. Să presupunem că vrem să adăugăm o mică notificare în partea de jos a site-ului nostru. Putem folosi cârligul „wp_footer” pentru aceasta, deoarece este o parte obligatorie a codului pe care o folosește fiecare temă.

Funcția msp_helloworld_footer_notice())( echo "

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

În acest exemplu, am creat o funcție care pur și simplu redă marcajul pentru alertă și am înregistrat-o cu „wp_footer”. Odată ce adăugăm acest cod în fișierul nostru de plugin (vezi anterior), vom vedea rezultatul pe pagină:

Alertă pentru pluginul WordPress

Lucrul cu filtre

Filtrele funcționează în același mod ca și evenimentele. Dar filtrele nu execută doar o anumită bucată de cod, ci schimbă valorile care le sunt transmise de cârlig. Aceasta înseamnă că fiecare filtru are asociată o valoare (variabilă) pe care operează.

Funcția de filtrare va prelua această valoare și o va transforma pentru utilizare ulterioară. Cârligele de filtrare sunt ușor diferite de cârligele de acțiune.

Aplică_filtre($tag, $value_to_filter, $arg_1, $arg_2, ... , $arg_n);

Funcția „apply_filter” creează un cârlig de filtru numit $tag și un parametru necesar $value_to_filter (acesta poate fi gol, dar trebuie declarat). Argumentele opționale rămase funcționează la fel ca pentru evenimente.

Filter_function($value_to_filter, $arg_1, $arg_2, ... , $arg_n)( //filter returnează $value_to_filter; //valoarea trebuie returnată)

Acesta este „scheletul” filtrului, care demonstrează că filtrul ar trebui:

1. accepta cel putin 1 argument;
2. returnează valoarea modificată.

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

Funcția „add_filter” înregistrează o funcție cu numele conținut în $function_to_add pentru cârligul $tag. Argumentele rămase - $priority și $accepted_args - funcționează la fel ca pentru hook-urile de evenimente.

Să ne uităm la un exemplu: o sarcină comună pentru un plugin este să adauge ceva la sfârșitul unei postări. Dacă aruncăm o privire mai atentă la funcția „the_content”, care este folosită pentru a afișa conținutul unei postări, vom găsi următorul cârlig:

$conținut = aplică_filtre(„conținutul”, $conținut);

Folosind-o, putem adăuga cu ușurință ceva la sfârșitul postării.

Funcția msp_helloworld_post_footer($content) ( $content .= "

"; returnează $conținut; ) add_filter("the_conținut", "msp_helloworld_post_footer", 100);

Rețineți că folosim un număr mare pentru prioritate pentru a ne asigura că toate filtrele standard sunt executate înainte de a executa „msp_helloworld_post_footer”. După ce includem codul în pluginul nostru, vom vedea rezultatul:

Cum să găsești un cârlig

Acum înțelegem că, pentru a efectua anumite acțiuni, trebuie să știm despre cârligele existente.

Codexul WordPress oferă liste de cârlige pentru filtre și evenimente de referință pentru acțiuni și referințe pentru filtre.

Acțiuni suplimentare cu cârlige

La fel ca și adăugarea, un cârlig poate fi eliminat folosind o sintaxă similară.

Puteți șterge evenimente ca acesta:

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

După cum probabil ați ghicit, „remove_action” elimină un anumit eveniment înregistrat pentru un anumit hook (prioritatea și numărul de argumente trebuie specificate corect, așa cum a fost specificat în timpul înregistrării), iar „remove_all_actions” ajută la eliminarea tuturor evenimentelor înregistrate pentru un hook ( dacă prioritatea este omisă, funcția va șterge toate evenimentele).

Filtrele pot fi șterse în același mod:

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

API-ul pluginului WordPress oferă, de asemenea, funcții pentru a verifica dacă o funcție este înregistrată pentru un anumit cârlig:

Are_action($tag, $function_to_check); are_filter($tag, $funcție_de_verificat);

Ambele funcții verifică dacă funcția dată este înregistrată pentru hook și returnează true dacă reușește, altfel flase. În interiorul funcției avem capacitatea de a verifica dacă cârligul a numit-o:

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

În ciuda numelui „current_filter” nu funcționează numai cu filtre, ci și cu evenimente.

Exemplu non-trivial

Să reînviam „scheletul” pluginului nostru, pe care l-am pregătit în ultima lecție.

Să umplem fișierul „core.php” (partea principală a pluginului nostru, care conține cea mai mare parte a funcțiilor) cu cod care rezolvă o problemă care poate apărea de fapt în timpul lucrului. Pentru a rezolva acest lucru vom folosi acțiuni și filtre.

Permiteți site-ului dvs. WordPress să accepte postări de la diferiți autori de la oaspeți, dar nu vă permite să creați conturi. Aceasta înseamnă că utilizatorul care a publicat postarea și autorul real sunt persoane diferite și trebuie să ne asigurăm că autorul este listat în postare. Putem face acest lucru folosind taxonomia.

Să ne creăm propria taxonomie pentru a procesa numele autorului și scurta biografie. Vom putea folosi numele autorului ca și alți termeni de taxonomie (etichete, de exemplu) în postare. Cod:

/** înregistrează filtre și evenimente **/ funcția 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" => "Autori invitați", "singular_name" => "Autor invitat"), "show_in_nav_menus" = > false); register_taxonomy("gauthor", array("post"), $args ) /** autor block markup **/ function msp_helloworld_author_block())( global $post; $author_terms = wp_get_object_terms($post->ID, "gauthor"); if(empty($author_terms)) return $name = stripslashes($author_terms->name $url = esc_url(get_term_link($author_terms)) $desc = wp_filter_post_kses($author_terms->de); ; $out = "

"; returnează $out; ) /** adaugă markup la sfârșitul postării **/ function msp_helloworld_author_block_filter($content)( if(is_single()) $content .= msp_helloworld_author_block(); return $content; ) /** adăugați clasa CSS la postare **/ funcția msp_helloworld_post_class($post_class)( global $post; $author_terms = wp_get_object_terms($post->ID, "gauthor"); if(!empty($author_terms))( $post_class = "gauthor "; ) returnează $post_class)

După cum puteți vedea, am creat o funcție pentru a ne înregistra propria taxonomie și a lega-o la cârligul „init”. Apoi, am creat un șablon responsabil pentru afișarea blocului de autor folosind funcția WordPress „wp_get_object_terms”. Apoi am inserat un bloc cu informații despre autor la sfârșitul postării folosind filtrul „the_content”. Și, în cele din urmă, am adăugat propria noastră clasă CSS. Rezultat: