I den tidigare delen av vår serie Vi skapade basen för ett WordPress-plugin som kan identifieras av kärnan. Idag ska vi lära oss att faktiskt ändra kärnans standardfunktionalitet.

Begreppet krokar, handlingar och filter är ansvariga för det; vara det verkliga hjärtat av hela WordPress pluginsystemet.

Allt börjar från "krokarna" som själva kärnan ger.

Vad är en "krok"? Det är en speciellt märkt plats i koden (av ett manus), där vissa medvetet registrerade - "hooked in" - funktioner kan utföras i den ordning som definieras vid registrering.

WordPress har två typer av krokar som skiljer sig åt i deras syfte:

  • Åtgärdskrok: markerar platsen för att utföra en åtgärd, till exempel processinmatning och lagra resultat i en databas
  • Filterkrok: markerar platsen för att tillämpa en ändring av ett värde (normalt tillhandahållet som variabel), så att följande kod kommer att använda det justerade värdet

Låt oss dyka in i detaljerna ...

Arbeta med åtgärder

Den gemensamma logiken för WordPress-åtgärder är väldigt enkel:

  1. Markera platsen där den anpassade koden ska gå, med en "action hook" och dess parametrar
  2. Skapa handlingsfunktionen som kör den nya koden med (om det behövs) parametrar som tillhandahålls av kroken
  3. Registrera åtgärden (# 2) som ska utföras när kroken (# 1) avfyras med viss prioritet
  4. När WordPress laddar in den begärda sidan och hittar kroken, kommer den att leta efter alla funktioner "inkopplade" och utföra dem en efter en i enlighet med deras prioritet

För att utföra uppgift # 1 har vi funktionen "do_action":

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

Den accepterar följande parametrar: $ tag - kroken "namn" som hjälper till att identifiera den särskilda kroken och särskilja den bland andra; $ arg_1, $ arg_2, ..., $ arg_n - värden för åtgärder som ska accepteras som parametrar. Det kan finnas så många argument som behövs - från noll till en rimlig mängd.

WordPress själv har många fördefinierade krokar att använda:

do_action( 'init' );

Detta är väldigt enkelt utan några extra parametrar. Den här kroken avfyras när det mesta av WordPress är upprättat och det är dags att registrera anpassade objekt, till exempel anpassad posttyp.

do_action('save_post', $post_id, $post);

I det här exemplet slås kroken när posten sparas och ger ytterligare två parametrar för att fungera med - post_id och postobjekt som innehåller all data från det sparade inlägget.

Men att skapa krokar är inte bara ett privilegium i kärnteamet. Varje utvecklare kan göra en anpassad krok för plugin (eller tema). Tack vare det här har vi mycket makt, till exempel temaramar tillåter barnteman att ändra inte bara stilar utan även uppmärkning av föräldrar utan att skriva över hela filer.

do_action( 'my_truly_custom_hook' );

När vi har hittat (eller skapat) en riktig krok och skapat en anpassad funktion för det borde vi registrera det senaste för utförandet med 'add_action'.

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

Som det kan förväntas accepterar metoden "add_action" två obligatoriska parametrar: $ tagg: namnet på den lämpliga kroken och $ function_to_add: namnet på den funktion som ska utföras. De andra två parametrarna är valfria: $ prioritet: ett heltal för att ange ordningen i vilken de registrerade funktionerna exekveras (som standard 10), $ accepted_args_number: antal argument som den registrerade funktionen kommer att acceptera (som standard 1) .

Låt oss titta på ett exempel för att illustrera hela processen. Antag att vi skulle vilja lägga till ett litet meddelande längst ner på vår sida. Vi skulle kunna använda "wp_footer" -kroken för detta eftersom det är en del av obligatorisk footer-kod som varje tema bör inkludera.

function msp_helloworld_footer_notice(){echo "
Hello, I'm your custom notice
";}add_action('wp_footer', 'msp_helloworld_footer_notice');

I det här exemplet skapar vi en prefixad funktion som helt enkelt matar ut meddelandet (betydelsen av prefixen vi har diskuterat i föregående artikel , så snälla hänvisa till det för detaljer) och sedan hakat det i "wp_footer". När vi har tagit med den här koden i vår plugin-fil (även diskuterad i föregående artikel) så ser vi resultatet på webbplatsen.

cnotice

Arbeta med filter

Filter fungerar med samma logik som åtgärder. Den enda skillnaden är att de inte bara exekverar en bit kod på en viss plats. De utför denna kod för att ändra något värde som ges till dem genom kroken. Det betyder att varje filterkrok har det tillhörande värdet (i de flesta fall bärs av en variabel).

Funktionen som utför filtrering ska ta det här värdet, ändra det på något sätt och sedan returnera det för vidare användning. Så att syntaxen för funktioner som är ansvariga för krokar och filter är lite annorlunda.

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

Funktionen 'apply_filter' skapar en filterkrok med $ tagnamn och den obligatoriska parametern $ value_to_filter (den kan vara tom, men bör vara närvarande för bästa praxis). Andra argument är valfria och fungerar på samma sätt som för åtgärder.

filter_function($value_to_filter, $arg_1, $arg_2, ... , $arg_n){//filtering code goes herereturn $value_to_filter; //value has to be returned back}

Detta är ett skelett med filterfunktion som visar att det ska a) acceptera minst ett argument, värdet för modifiering; och b) returnera värdet i slutet.

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

Funktionen "add_filter" registrerar en funktion med ett namn som anges som $ function_to_add argumentet för $ taggar filterkroken. De valfria argumenten - $ prioritet och $ accepted_args - fungerar på samma sätt som för åtgärdshooks.

Låt oss visa hela processen i åtgärd: en vanlig plugin-uppgift är att lägga till lite innehåll i slutet av ett inlägg. Om vi ​​tittar närmare på mallen "the_content" mallen ( queryposts.com/function/the_content ), som normalt används för att utmata ett inläggets innehåll i ett tema, kommer vi att finna att den innehåller följande filterkrok:

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

Med denna krok kan vi enkelt lägga till något i slutet av inlägget på följande sätt:

function msp_helloworld_post_footer($content) {$content .= "";return $content;}  add_filter ('the_content', 'msp_helloworld_post_footer', 100); 

Observera att vi använder ganska stort antal som prioritet här för att säkerställa att alla standardfilter har tillämpats före vår "msp_helloworld_post_footer". Efter att ha inkluderat koden i pluginfilen borde vi se resultatet på webbplatsen:

pfooter

Så här hittar du krokar

Det borde vara uppenbart nu att för att genomföra åtgärd och filterfunktionalitet måste vi veta vilka krokar som finns tillgängliga.

WordPress Codex tillhandahåller en Handlingsreferens med de flesta handtagskrokar avfyrade på typiska sidlast och a Filterreferens med en lista över vanliga filter. Dessa referenser är användbara för att förstå handlingsordning och logik för filter så att du kan välja var och när funktionalitet kan och ska injiceras.

Därefter är du redo för resan till källkoden. Du kan bara utföra en sökning genom WordPress-filerna för sökorden 'do_action' och 'apply_filter' för att hitta den krok du behöver.

Förståelse WordPress-frågelogik kan också hjälpa dig att träna ut där några krokar kan letas efter.

Slutligen kan du hänvisa till WordPress Hooks Database som innehåller fullständig information om krokarna i kärnfilerna.

Avancerad operation med krokar

Förutom att läggas till i plugin kan åtgärder och filter också tas bort med en liknande syntax.

Åtgärder kan tas bort på följande sätt:

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

Som du antagligen har gett "remove_action" tar du bort en viss åtgärd som är registrerad för en viss krok (du måste ange rätt prioritet och antal argument som de användes vid registrering) och "remove_all_actions" hjälper till att ta bort alla åtgärder registrerade med en viss koppla med en viss prioritet (om prioritetsargumentet utelämnas kommer funktionen att ta bort alla åtgärder).

Du har nog hört talas om en populär säkerhetsanbefaling för att dölja WordPress-versionen från huvuddelen av webbplatsen. Detta är ett jobb för 'remove_action'.

Låt oss först och främst hitta koden som hakar funktionen "wp_generator" för att skriva ut versionsinformationen genom att bläddra /wp-includes/default-filters.php . Koden som gör det här ser ut som följer:

add_action('wp_head', 'wp_generator');

För att eliminera effekten av denna kod borde vi någonstans i vårt plugin, inkludera den motsatta funktionen:

remove_action('wp_head', 'wp_generator');

Filter kan avlägsnas på liknande sätt:

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

De Plugin API ger också utvecklare ett sätt att upptäcka om den särskilda kroken har registrerade funktioner att utföra:

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

Båda funktionerna kontrollerar om en viss åtgärd eller ett filter är registrerat för en krok och returnerar: sant på framgång, felaktigt vid fel. Inuti den krokade funktionen har vi möjlighet att kontrollera vilken krok som har utlöst sin utförande på följande sätt:

if('hook_to_check_name' === current_filter()){//do stuff related to 'hook_to_check_name' hook}

Trots namnet fungerar "current_filter" inte bara med filter utan även med åtgärder. För den fullständiga uppsättningen Plugin API-funktioner, hänvisas till Kodex .

Real-world fall

Låt oss gräva upp det pluginskelett som vi förberett oss den tidigare delen av serien , och andas lite liv i det.

Vi ska fylla i filen "core.php" (den centrala delen av vårt plugin som är avsedd att göra det mesta av funktionalitet) med koden som löser en verklig uppgift med hjälp av åtgärder och filter.

Vad ska vi göra? Antag att din WordPress-webbplats accepterar gästinlägg från olika författare, men ger dem inte tillåtelse att skapa egna konton för inlägg. Det betyder att användaren, som har publicerat artikeln, och den verkliga författaren av det (gästen) är olika människor. Du måste se till att den faktiska författaren får kredit. Detta kan göras med anpassad taxonomi.

Låt oss skapa en anpassad taxonomi att hantera gästförfattarens namn (som en term) och kortfattad författares bio (som en beskrivning). Vi skulle kunna tilldela författarens namn som alla andra taxonomi villkor (som taggar) till inlägg. Därefter blir det möjligt att skriva ut en författares ruta direkt efter postens text. Här är koden:

/** Hook plugin's action and filters **/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');/** Register custom taxonomy **/function msp_helloworld_taxonomies(){$args = array('labels' => array('name'          => 'Guest authors','singular_name' => 'Guest author'),'show_in_nav_menus' => false);register_taxonomy('gauthor', array('post'), $args);}  / ** Skapa författarens boxmärkning ** / funktion msp_helloworld_author_block () {global $ post; $ author_terms = wp_get_object_terms ($ post-> ID, 'gauthor'); om (tomt ($ author_terms)) returneras; $ name = stripslashes $ author_terms [0] -> name); $ url = esc_url (get_term_link ($ author_terms [0]); $ desc = wp_filter_post_kses ($ author_terms [0] -> beskrivning); $ out = " 
"; $ ut. ="
Detta är ett gästpost av {$name}
"; $ ut. ="
{$desc}
"; return $ out;} / ** Lägg till författarens ruta till slutet av posten ** / funktion msp_helloworld_author_block_filter ($ content) {om (is_single ()) $ content. = msp_helloworld_author_block (); returnera $ content;} / * * Lägg till anpassad CSS-klass i postens behållare ** / funktion msp_helloworld_post_class ($ post_class) {global $ post; $ author_terms = wp_get_object_terms ($ post-> ID, 'gauthor'); om (! Tom ($ author_terms)) {$post_class[] = 'gauthor';} returnera $ post_class;}

Som du kan se har vi skapat en åtgärd för att registrera en anpassad taxonomi och tillämpat den på init-kroken - det här är en rekommenderad praxis. Därefter har vi skapat malltaggen som är ansvarig för författarkassens uppställning med inbyggda WordPress-funktioner som "wp_get_object_terms". Därefter fästade vi den här rutan till slutet av inlägget med hjälp av filterkroken "the_content". Och äntligen har vi lagt till den anpassade CSS-klassen för gästpostens behållare för stilflexibilitet i temat. Efter att ha tillämpat några stilar kan vi se resultatet:

gauthor

Slutsats

Åtgärder och filter är den viktigaste delen av varje WordPress-utveckling. Nu när du förstår deras logik och beteende är du förberedd för dina egna experiment.

Klicka här för att ladda ner vårt utökade "Hello World" -plugin exempel för att använda som skelett för din egen utveckling.

Vilka användningsområden har du hittat för WordPress-åtgärder och filter? Vad vill du se täckt i nästa del av denna serie? Låt oss veta i kommentarerna.

Utvald bild, Modulbild via Shutterstock