Guide: Allt om Hooks i WordPress
Har du någonsin fått höra att lösningen på ditt problem är att du måste "haka på" något för att göra din grej eller användas add_filterutan att riktigt förstå varför det förstör saker? Krokar utgör grunden för WordPress och ger teman och plugins ett sätt att interagera eller ändra kod. I det här inlägget kommer vi att dela upp vad krokar är, hur de fungerar och hur vi kan använda dem.
Vad är krokar?
När WordPress kör igenom sin kod (hela vägen från början av att ladda klasser, ladda plugins, ladda temat, göra frågan för den aktuella begäran och slutligen rendera HTML-koden), går den igenom ett gäng "checkpoints"; krokar. När en krok påträffas kommer WordPress att stoppa vad den gör – och kontrollera om det finns några funktioner (i tema, plugin eller själva WordPress) som är registrerade för att köra på denna krok. Om det finns kommer WordPress att köra alla dessa funktioner och sedan fortsätta där det slutade.
Detta gör det möjligt för plugins, teman och själva WordPress att "haka på" vissa punkter för att lägga till t.ex. stilmallar i temats <head>tagg, modifiera hur WordPress frågar efter inlägg eller helt enkelt ändra inläggets innehåll om så önskas.
Det finns två typer av krokar; åtgärder och filter. De fungerar ganska lika varandra, men med ett undantag som vi kommer att titta närmare på nedan.
Åtgärder och filter
För att ansluta till en åtgärd eller ett filter måste du definiera vilken hook (med dess namn) du vill använda och definiera en återuppringning – vilket är namnet på funktionen du vill köra. I de flesta fall ger krokarna parametrar eller variabler som är relevanta för kroken.
Åtgärder är helt enkelt "kontrollpunkter" i utförandet av WordPress, där du kan utföra en uppgift eller eka något. I vissa sällsynta fall kan du modifiera ett objekt (tillhandahålls i parametrar), så att all efterföljande exekvering fungerar med det ändrade objektet.
Filter är till för att ändra en variabel eller utdata. Alla filterkrokar kommer att tillhandahålla variabeln du kan ändra som första parameter, och låter dig ändra den eller returnera något annat.
WordPress kör många hooks, men du kan skapa din egen i ditt plugin eller tema. Detta tillåter utvecklare att utöka och ändra din kod; till exempel modifiera ett plugin via ett tema, eller modifiera det överordnade temat via det underordnade temat.
Många av WordPress funktioner, som vanligtvis används för att skriva ut inlägg, är också filter eller åtgärder. Funktionen the_title()skriver till exempel ut inläggets titel, men det är också ett filter.
Låt oss titta på hur vi kopplar till dessa i praktiken.
Hakar på handlingar
För att haka på en handling använder du metoden add_action(). Det kräver minst två parametrar; hook-namnet och återuppringningen; namnet på den funktion du vill köra. Alternativt kan du ange prioritet som tredje parameter och definiera antalet argument som kommer att skickas till din återuppringningsfunktion. Vi kommer att undersöka de två valfria parametrarna senare, men för nu är här ett exempel på add_action:
add_action('init', 'my_function_name');
function my_function_name() {
// Do your stuff
}Den första parametern till add_actionär namnet på åtgärden; i det här fallet init, vilket är en ganska vanlig WordPress-hook som händer under initialisering. Den andra parametern är din återuppringning, i detta fall namnet på funktionen vi vill köra. Sedan är allt du behöver göra att definiera en funktion med det namnet och lägga till din kod inuti den.
Du kan också använda anonyma funktioner som är där du definierar funktionen inuti add_actionistället för att ge ett funktionsnamn, som så;
add_action('init', function() {
// Do your stuff
});Många utvecklare föredrar denna metod eftersom detta förhindrar risken att omdefiniera en PHP-funktion med samma namn.
Om du behöver köra en funktion definierad i en PHP-klass, måste du tillhandahålla en array som callback-parametern; där det första elementet är klassobjektet och det andra elementet är funktionsnamnet:
class MyClass {
public function __construct() {
add_action('init', [$this, 'myFunctionName']);
}
public function myFunctionName() {
// Do your stuff
}
}Hakar på filter
För att haka på ett filter använder du funktionen add_filter(). På samma sätt som åtgärderna ovan är första parametrarna filternamnet och den andra är din återuppringning. Alternativt kan du ange prioritet som tredje parameter och antalet argument som fjärde. Här är ett exempel på add_filter:
add_filter('the_title', 'my_function_name');
function my_function_name($title) {
// Do your stuff
return $title;
}I exemplet ovan hakar vi på filtret the_title(som skriver ut posttiteln) och säger åt WordPress att köra vår funktion. Alla filter ger alltid ett argument; variabeln som ska ändras. I min funktion döpte jag det $titlesom jag vet att det innehåller inläggets titel. Inuti funktionen kan jag modifiera den eller helt åsidosätta variabeln. Det är viktigt att komma ihåg att i filter måste du alltid returnera variabeln. Om du inte returnerar något i din callback-funktion töms variabeln. Om jag hoppade över retursatsen i exemplet ovan skulle inga inläggstitlar någonsin eka någonstans.
Variabelargumentet och regeln att returnera något i din callback-funktion är praktiskt taget den enda skillnaden mellan filter och åtgärder. Allt annat fungerar likadant. Du kan följa exemplen för anonyma funktioner och klasser som visas för åtgärder ovan för filter, såväl som de valfria parametrarna prioritet och antal argument; som vi ska titta på härnäst.
Prioritet
Den tredje (valfria) parametern till add_actionoch add_filterär ett heltal som definierar prioritet för din återuppringningsfunktion. Detta är användbart i fall där det finns flera funktioner (inte nödvändigtvis från dig i ditt tema eller plugin, kom ihåg att WordPress själv använder sina egna krokar), och du måste bestämma vilken som ska köras först.
Om ingen prioritet tillhandahålls, är den standard till 10. Ju lägre prioritet, desto tidigare körs det, och ju högre prioritet, desto senare körs det. Du kan inte ge en negativ prioritet.
Föreställ dig flera återuppringningsfunktioner registrerade på init. Om ingen prioritet gavs för flera återuppringningar kommer WordPress att köra dem i den ordning de hittades (till exempel i functions.phpeller din plugin-kod).
add_action('init', 'my_function_name');
add_action('init', 'my_second_function_name');
add_action('init', 'my_third_function_name', 12);
add_action('init', 'my_fourth_function_name', 1);Detta skulle vara den ordning i vilken WordPress kommer att köra ovanstående återuppringningar:
my_fourth_function_name(prioritet 1)my_function_name(prioritet 10)my_second_function_name(prioritet 10, men visas senare i koden)my_third_function_name(prioritet 12)
Antal argument
Vanligtvis ger krokar ytterligare data som är relevanta och användbara för återuppringningsfunktionerna. Till exempel ger åtgärden save_post(körs när ett inlägg uppdateras) två möjliga argument; inläggets ID och postobjektet. Dessa är användbara för operationer som du vanligtvis behöver för att köra på den här kroken (om du till exempel vill spara en inläggsmeta behöver du post-ID).
Om inget antal argument angavs för en åtgärd eller ett filter, är det som standard 1. Det är därför du inte behöver definiera 1 för add_filteratt komma åt variabeln som filtret är kopplat till. Åtgärder kan dock inte skicka några argument även om antalet argument är satt till 1 som standard.
Låt oss titta på ett exempel på hur vi definierar antalet argument och hur vi kommer åt dem i vår callback-funktion:
add_action('save_post', 'my_function_name', 10, 2);
function my_function_name($post_id, $post) {
// Do your stuff
}I exemplet ovan säger vi åt WordPress att skicka två argument till vår callback-funktion. Kom ihåg att vi måste definiera prioritet som tredje parameter, så vanligtvis definierar vi standardvärdet, vilket är 10. När det gäller vår callback-funktion kan vi nu definiera samma antal argument som vi bad om, i exemplet ovan var 2.
Om vi i exemplet ovan hade satt antalet argument till 1, skulle bara det första argumentet i vår callback-funktion fyllas i. Den andra, $post, skulle vara odefinierad.
Vad händer om vi behöver data som inte skickades i kroken?
Det är helt upp till utvecklaren som skapade kroken att definiera vilka argument som kan skickas. Det betyder att du inte bara kan tvinga fram vilka argument du önskar eller behöver i din add_actioneller add_filter. Som tur är har vi i de flesta fall alternativ för att få variabler vi behöver. Om du kopplar in dig på en åtgärd eller ett filter där du vet att vissa globala variabler bör definieras, kan du komma åt dessa globala variabler i din återuppringningsfunktion. Dessutom har WordPress en hel rad villkorliga taggar som du kan använda i dina hakade funktioner (med undantag för de mycket tidiga krokarna som inträffar innan WordPress definierar dessa villkorliga taggar)
Låt oss titta på ett exempel på tillgång till globala variabler. Filtret the_titletillhandahåller post-ID som valfritt argument, som vi kan komma åt genom att definiera det som acceptabelt argument;
add_filter('the_title', 'my_function_name', 10, 2);
function my_function_name($title, $post_id) {
if ($post_id == 1) {
return 'First post ever!';
}
return $title;
}Men vi kan uppnå samma resultat genom att;
Om du vet att en global variabel definieras av den punkt som kroken körs, kan du definiera dem som globala i din återuppringningsfunktion och komma åt data därifrån. Till exempel att definiera global $wp_queryi exemplet ovan skulle också ge dig tillgång till hela wp_query-objektet i din funktionsåteruppringning.
WordPress villkorliga taggar är extremt användbara. Såvida du inte har fastnat i en krok som inträffar mycket tidigt i körningen av WordPress, är de tillgängliga. Det finns villkorade taggar för att kontrollera vilken sida (mall) du befinner dig på, om du är inne i en meny eller en inläggsslinga och mycket mer. Till exempel, när du ändrar inläggsfrågan med hjälp av kroken pre_get_postsär det mycket användbart att se till att din kod bara körs i vissa fall. Till exempel;
add_action('pre_get_posts', 'my_function_name');
function my_function_name($query) {
if (!is_admin()) {
// Do your stuff
}
}Eftersom hooken pre_get_postskörs både i admin och frontend, kan vi använda en villkorlig tagg för att säkerställa att vår kod endast påverkar frontend-frågan.
Skapa dina egna krokar
Du kan definiera dina egna åtgärder och filter. Om du är en tema- eller plugin-utvecklare uppmuntras du att göra det, för att tillåta andra att ändra din kod utan att ändra källkoden.
Registrera en åtgärd med do_action()och registrera ett filter med apply_filters().
Den do_action()kräver minst 1 parameter; krokens namn. Tänk på att hook-namnet måste vara unikt (kalla det inte t.ex. initeftersom detta är en grundläggande WordPress-hook). Placera den do_action()där du vill att kroken ska synas. Till exempel kan du placera kroken i ditt temas header.php, direkt efter brödtexten för att definiera en krok där utvecklare kan mata ut skript eller annat innehåll.
Du kan lägga till så många parametrar do_actionsom du vill efter krokens namn. Försök att tänka på vad datautvecklare skulle behöva i dina krokar, som annars inte är lättillgängliga.
Det apply_filters()kräver minst 2 parametrar; krokens namn och variabeln som du registrerar filtret på. Till exempel kan ditt tema registrera ett filter runt vissa HTML-klasser för att tillåta utvecklare att ändra eller lägga till dessa:
Precis som med åtgärder kan du lägga till så många parametrar apply_filterssom du vill efter de två obligatoriska parametrarna.
Slutsats och användbara resurser
Med detta hoppas jag att du har uppnått en gedigen förståelse för hur WordPress kör det mesta av sin kod, hur du kan modifiera kod och hur du som utvecklare kan tillåta andra utvecklare att göra ändringar i din kod också.