WordPresskrokar är ett av de viktigaste verktygen att ha i en WordPress-utvecklares arsenal. De är grunden för plugin- och temautveckling inom WordPress. Du kan använda WordPress många inbyggda krokar för att ”kroka på” WordPresskärnan med din anpassade kod för att göra eller ändra något.

Det finns två typer av WordPresskrokar: Action (åtgärder) och Filter. Krokar är så vanliga att WordPresskärnan också använder dem i stor utsträckning. WordPress innehåller också ett sätt för dig att definiera dina egna anpassade krokar så att andra utvecklare kan kroka på din kod.

Att lära sig hur åtgärds-, filter- och anpassade krokar fungerar är viktigt för att behärska WordPress-utveckling.

Den första halvan av denna artikel täcker grunderna om WordPresskrokar och förklarar hur de fungerar med flera exempel. Under andra halvan lär du dig hur du kan använda krokar för att anpassa WordPress, skapa egna krokar och använda dem för att bygga dina egna förlängningsbara plugins.

Låter det spännande? Nu börjar vi!

Vad är WordPresskrokar?

En WordPress-sida sätts samman av massor av funktioner och databasförfrågningar. WordPresskärnan, plugins och teman samarbetar för att mata ut sidelement som text, bilder, skript och stilar. När allt är klart sätter webbläsaren ihop dem och renderar sidan.

WordPresskrokar låter dig ”kroka på” denna byggprocess vid vissa punkter och köra din egen kod. Huvudfunktionen hos krokar är att du kan ändra eller lägga till funktioner till WordPress utan att röra kärnfilerna.

Krokar hjälper dig att utöka WordPress med din egen kod
Krokar hjälper dig att utöka WordPress med din egen kod

WordPress Plugin API driver funktionaliteten hos WordPresskrokarna. Du använder krokar genom att anropa vissa WordPressfunktioner som kallas Krokfunktioner vid specifika instanser då WordPress körs.

Med hjälp av krokfunktioner kan du bunta din anpassade kod inom en Callback-funktion och registrera den med vilken krok som helst. När den är registrerad kommer denna callback att köras varhelst kroken är, så att du kan utöka eller ersätta de vanliga WordPress-funktionerna.

Krokens position i kodkörningsprocessen är en viktig faktor. Du lär dig mer om dess betydelse i de kommande avsnitten.

Två typer av WordPresskrokar: åtgärder/actions och filter

WordPress innehåller två typer av krokar som kallas Actions (åtgärder) och Filter. Åtgärder låter dig göra något på vissa fördefinierade punkter då WordPress kör, medan filter låter dig ändra data som behandlas av WordPress och return dem.

Åtgärder/actions definieras i WordPress-koden som:

do_action( 'action_name', [optional_arguments] );

Action_name-strängen är namnet på åtgärden. Du kan ange variabeln [optional_arguments] för att skicka ytterligare argument till callback-funktionen. Om det här fältet inte anges kommer standardvärdet att vara tomt.

Exempel: åtgärden do_action ('wp_head') kan krokas på för att köra anpassad kod varje gång WordPress behandlar webbplatsens header. Denna åtgärd har inga andra argument.

Filter definieras i WordPress-koden som:

apply_filters( 'filter_name', 'value_to_be_filtered', [optional_arguments] );

Strängen filter_name är namnet på filtret, value_to_be_filtered–variabeln är det värde som måste filtreras och returneras, och variabeln [optional_arguments] kan skicka ytterligare argument, precis som med åtgärder.

Exempel: filtret apply_filters ('admin_footer_text', string $text ) kan krokas på för att ändra texten som visas i admin-headern. Från och med WordPress 5.4 kommer dess standardvärde att visa meningen Tack för att du skapar med WordPress. i adminområdets footer.

Du lär dig att kroka på åtgärder och filter senare med många exempel från WordPresskärnan.

När allt är påkrokat kan du styra din kod för att göra eller anpassa något på din webbplats. Du kan till exempel använda krokar för att skicka ett automatiserat e-postmeddelande efter att ha publicerat ett inlägg, eller ladda anpassade stilmallar för att ändra utseendet på din webbplats.

WordPresskrokar hjälper dig att interagera med eller ändra din webbplats
WordPresskrokar hjälper dig att interagera med eller ändra din webbplats

Det enklaste sättet att förstå krokar är att föreställa dig din WordPresswebbplats som att bygga ett hus.

Krokar är som att använda en kran för att flytta byggmaterial fram och tillbaka. Objekten som flyttas är Callback-funktioner som innehåller din anpassade kod. Dessa objekt (eller funktioner) kan hjälpa dig att bygga eller ändra huset.

Exempel på att kroka på
Exempel på att kroka på ”wp_head”-åtgärden i WordPress

Callback-funktioner kan vara vanliga PHP-funktioner, WordPress standardfunktioner eller anpassade funktioner som definieras av dig.

Vi kan bara bära vissa objekt på specifika bärare kopplade till särskilda krokar. Åtgärder kan därför endast krokas på Åtgärdsfunktioner. På samma sätt kan Filter endast krokas på Filterfunktioner.

Även om det är tråkigt att byta krokar och bärare på en kran, gör WordPress det superenkelt genom att inkludera över 2 200 typer av standardkrokar.

WordPress 5.1 har 2200+ inbyggda krokar
WordPress 5.1 har 2200+ inbyggda krokar (källa: Adam Brown)

Du kan hitta krokar utspridda över hela WordPresskärnan, så att du kan utnyttja den exakta position där du vill kroka på och köra din anpassade kod.

Krokar vs åtgärder vs filter

Enligt WordPress Pluginhandbok:

”Krokar är ett sätt för en bit kod att interagera/ändra en annan bit kod… det finns två typer av krokar: Åtgärder och Filter.”

Det finns utbredd inkonsekvens för hur termerna Krok, Åtgärd och Filter används. Några handledningar och guider blandar ihop dem med de funktioner som är förknippade med dem. En viktig orsak till denna förvirring är den komplexa karaktären av hur krokar fungerar.

Även när du tittar noggrant i WordPresskärnan finner du att det inte finns så stor skillnad mellan att lägga till åtgärder och filter. Här är källkoden för add_action()-funktionen från wp-includes/plugin.php-filen:

:

function add_action( $tag, $function_to_add, $priority = 10, $accepted_args = 1 ) {      
    return add_filter( $tag, $function_to_add, $priority, $accepted_args );
}

Add_action()-funktionen anropar bara add_filter()-funktionen och returnerar dess värde. Varför? Eftersom de båda i grunden fungerar likadant, förutom en skillnad.

Funktionen apply_filters() returnerar ett värde som kan ändra befintliga datatyper, medan funktionen do_action() returnerar ingenting (NULL-värde i PHP).

Om du fortfarande är förvirrad, oroa dig inte! När du kommit igenom den första halvan av den här artikeln kommer allt att vara klart och tydligt. Vi håller oss till den officiella WordPress Codex-terminologin eftersom den är tydlig, exakt och universell.

Nu kan du bekanta dig med Krokrutinen enligt hur vi visar den nedan.

Krokrutinen: Krokar, Krokfunktioner och Callbackfunktioner
Krokrutinen: Krokar, Krokfunktioner och Callbackfunktioner

Låt oss gå igenom skillnaderna mellan åtgärder och krokar.

WordPress-krokar
Åtgärder Filters
Åtgärder används för att köra anpassade funktioner vid en viss punkt under exekveringen av WordPresskärnan. Filter används för att ändra eller anpassa data som används av andra funktioner.
Åtgärder definieras/skapas av funktionen do_action ('action_name') i WordPress-koden. Filter definieras/skapas av funktionen apply_filters ('filter_name', 'value_to_be_filtered') i WordPress-koden.
Åtgärder kallas också Åtgärdskrokar. Filter kallas också Filterkrokar.
Åtgärder kan endast krokas på Åtgärdsfunktioner. T.ex. add_action(), remove_action(). Filter kan endast krokas på filterfunktioner. T. ex. add_filter(), remove_filter().
Åtgärdsfunktioner behöver inte skicka några argument till sina callbackfunktioner. Filterfunktioner måste skicka minst ett argument till sina callbackfunktioner.
Åtgärdsfunktioner kan utföra alla möjliga uppgifter, inklusive att ändra hur WordPress fungerar. Filterfunktioner finns bara för att ändra de data som överförs till dem av filtren.
Åtgärdsfunktioner bör inte returnnågonting. De kan dock echoresultatet eller interagera med databasen. Filter functions must return their changes as output. Even if a filter function changes nothing, it must still return the unmodified input.
Åtgärder kan exekvera nästan vad som helst, så länge koden är giltig. Filter bör fungera på ett isolerat sätt, så att de inte får några oavsiktliga biverkningar.
Sammanfattning: en åtgärd avbryter den vanliga kodexekveringsprocessen för att göra något med den information den tar emot, men returnerar ingenting tillbaka. Sammanfattning: ett filter ändrar informationen den tar emot, returnerar den tillbaka till den anropande krok-funktionen och andra funktioner kan använda det värde den returnerar.

 

Ibland kan du använda antingen en åtgärd eller ett filter för att uppnå samma mål. Om du till exempel vill ändra texten i ett inlägg kan du registrera en callback-funktion med publish_post-åtgärden och ändra inläggsinnehållet när det sparas i databasen.

// define the callback function to change the text
function change_text_callback() { 
    // add the code to change text here
}

// hook in to the 'publish_post' action with the add_action() function
add_action( 'publish_post', 'change_text_callback' );

Eller så kan du registrera en annan callback-funktion med the_content-filtret för att ändra inläggsinnehållet innan det visas i webbläsaren.

// define the callback function to modify the text
function change_text_another_callback( $content ) { 
    // add the code to change text here and then return it 
    return $filtered_content;
}

// hook in to 'the_content' filter with the add_filter() function
add_filter( 'the_content', 'change_text_another_callback');

Två olika tillvägagångssätt med samma resultat. Att veta när man ska använda den ena eller den andra är nyckeln till att vara en bra WordPressutvecklare.

Hur fungerar WordPresskrokar?

Husexemplet var enkelt nog för att förstå krokarnas grundläggande funktion, men det beskriver inte komplexiteten i hur de fungerar. Och särskilt inte begreppen krok-position och specificitet.

Ett bättre exempel skulle vara att föreställa sig bearbetningen av en WordPresswebbsida som monteringen av en bil. Till skillnad från tillverkning av en bil, som tar tid, är montering av en webbsida nästan ögonblicklig.

Att montera en webbsida är som att montera en bil
Att montera en webbsida är som att montera en bil

Ungefär som hur en bil sätts ihop del för del i en modern monteringslinje, monteras en WordPresswebbsida element för element av servern och klienten.

WordPresskärnan är som bilmotorn, chassit och andra väsentligheter, som driver webbplatsens grundläggande funktionalitet.

Du kan ha en funktionell hemsida med bara WordPresskärnan, men hur kul är det? Du måste lägga till spännande funktioner på webbplatsen. Det är där WordPress-plugins och teman kommer in, som båda använder krokar i stor utsträckning.

I exemplet ovan är varje numrerad station som en krok inuti WordPresskärnan. Det finns två typer av stationer, precis som åtgärder och filter. Varje station innehåller en specifik typ av plats som endast accepterar vissa verktyg, liknande åtgärdsfunktioner och filterfunktioner.

Alla stationer är placerade med täta intervall för modularitet och effektivitet.

Beroende på en viss positions krav kan vi fästa (eller kroka på det lämpligaste verktyget för den specifika stationens jobb. Dessa verktyg är som callback-funktionerna som vi använde för att interagera med eller ändra WordPress.

Vissa verktyg kan väsentligt förändra bilens funktion, ungefär som callbacks till åtgärder. Andra verktyg används endast för att anpassa utseendet på bilen, som callbacks till filter.

Att använda rätt verktyg på rätt stationer är avgörande för att bygga en förstklassig bil. På samma sätt hjälper krokar oss att anpassa WordPress enligt våra unika behov.

Om du utökar denna analogi är plugins som att lägga till användbara bilfunktioner som krockkuddar, underhållningskonsoller, nyckelfritt fjärrsystem, etc. (som dessa för att förbättra WooCommerce-funktionaliteten). Teman är analoga med att anpassa den visuella delen av bilen, som den övergripande designen, lackering, fälgar etc. (det är så här du anpassar ditt WordPresstema).

Var ska krokar och deras funktioner registreras?

Det finns två rekommenderade sätt att lägga till krokar i WordPress:

  • Plugins: Gör ditt eget plugin och lägg till alla din egen kod i det.
  • Barnteman: Registrera krokarna och callback-funktionerna i ditt barntemas functions.php-fil.

Under denna guide ska vi börja med att skapa ett plugin. För att göra det, skapar du först en ny mapp i din /wp-content/plugins– katalog.

Jag döper mitt plugin salhooks, men du kan kalla det vad du vill. Enligt WordPress riktlinjer måste du skapa en PHP-fil med samma namn (salhooks.php) inuti din pluginkatalog.

Lägg till följande header i din plugin-fil för att registrera pluginet med WordPress. Du kan läsa mer om pluginets header-krav i WordPress Codex.

<?php

/*
Plugin Name:  Salhooks
Version    :  1.0
Description:  Demonstrating WordPress Hooks (Actions and Filters) with multiple examples.
Author     :  Salman Ravoof
Author URI :  https://www.salmanravoof.com/
License    :  GPLv2 or later
License URI:  https://www.gnu.org/licenses/gpl-2.0.html
Text Domain:  salhooks
*/

//=================================================
// Security: Abort if this file is called directly
//=================================================
if ( !defined('ABSPATH') ) { 
    die;
}

Spara den här filen och aktivera sedan pluginet i din WordPresspanel. Jag kommer att använda detta plugin på en lokal WordPressinstallation för att visa hur krokar fungerar.

Du kan också redigera WordPresskärnans filer direkt för att registrera krokar. Det rekommenderas dock inte eftersom all din anpassade kod kommer att skrivas över varje gång du uppdaterar WordPress. Du bör inte lägga till krokar inuti ditt överordnade tema av samma anledning.

Att använda WordPresskrokar

En WordPresskrok i sig gör ingenting. Den sitter bara i koden och väntar på en krokfunktion som ska aktivera den. För att använda en krok måste du anropa minst 2 andra funktioner.

Först måste du registrera kroken med en krokfunktion och referera till en callback-funktion inom den. Och sedan måste du definiera callback-funktionen som du nämnde tidigare i krokfunktionen. WordPress kommer att köra denna callback-funktion varje gång kroken avfyras.

Den ordning i vilken du definierar dessa funktioner spelar ingen roll, men det är en bra idé att lägga dem nära varandra.

Åtgärder och filter har olika krokfunktioner. Från och med nu kommer vi kalla dem Åtgärdsfunktioner och Filterfunktioner. Som du ser har de sina egna syntax-och parameterkrav.

Kroka på en åtgärd

Åtgärder ger dig ett sätt att köra din anpassade kod vid en viss punkt i exekveringen av WordPresskärnan, plugins eller teman.

Åtgärdsfunktionen add_action()

  1. Definiera en callback-funktion som innehåller din anpassade kod. Denna callback-funktion kommer att köras när en åtgärd som den är registrerad till avfyras när WordPresskoden exekveras.
  2. Kroka på din callback-funktion till den åtgärd du vill ha med add_action()-funktionen. Enligt WordPress Codex måste add_action()-funktionen passera minst två parametrar:
    • Namnet på åtgärden att krokas på.
    • Namnet på callback-funktionen som körs när åtgärden aktiveras.
  3. Funktionen add_action() accepterar också två valfria parametrar för att ställa in priority, och number of arguments. Vi diskuterar båda lite senare.

Det är bra att döpa dina callback-funktionsparametrar så likt de parametrar som skickas av krokfunktionen som möjligt.

Låt oss titta på ett exempel på att använda add_action()-funktionen.

// define the callback function, the arguments are optional
function example_callback( $arg1, $arg2 ) {
    // make your code do something with the arguments
}

// hook the callback function to the 'example_action'
add_action( 'example_action', 'example_callback', [priority], [no_of_args] );

// 'priority' and 'number of arguments' are optional parameters

Exempel på att kroka på en åtgärd

WordPress innehåller en inbyggd åtgärd som heter init som avfyras efter att WordPress har laddats och autentiserat användaren, men innan några headers skickas. Många plugins använder den här kroken som utgångspunkt för att instansiera sin kod, eftersom nästan alla de stora WordPress-funktionerna har laddats klart när WordPress kör denna åtgärd.

WordPress har en liknande åtgärd som heter admin_init. Den avfyras medan adminskärmen initieras, medan init-åtgärden först avfyras efter att WordPress har laddats klart.

Låt oss köra en anpassad kod för att echo ett enkelt meddelande under exekveringen av init-åtgärden. Så här gör du det:

function custom_callback_function(){
    // add your custom code here to do something
    echo 'I will be fired on WordPress initialization';
}
add_action( 'init', 'custom_callback_function' );

Du kan se meddelandet ekas i det övre vänstra hörnet av min lokala WordPressinstallation.

Inte så snyggt, men det är en bra start!
Inte så snyggt, men det är en bra start!

Hitta åtgärder som stöds av WordPress

WordPress inkluderar åtgärder varje gång det gör något; som en användare som loggar in eller publicerar ett nytt inlägg. Du kan hitta en omfattande lista över alla åtgärder som drivs av WordPress på sidan över Plugin API/åtgärdsreferenser.

Det finns en åtgärd för nästan vad som helst.
Det finns en åtgärd för nästan vad som helst.

Codexen har delat upp alla åtgärder i olika kategorier och ordnat dem från första till sista i WordPress exekveringsordning.

I de flesta fall kommer många av dessa åtgärder inte att göra något eftersom ingenting har krokats på dem. Men om du behöver dem, finns de där.

Känner du dig lite överväldigad över alla dessa åtgärder? Det vore ganska naturligt. När du får mer erfarenhet och går igenom WordPresskärnans källkod blir det lättare att hitta den perfekta kroken som du behöver. Bara gör en sökning efter termen ”do_action” och du hittar massor av åtgärder som du kan kroka på.

Ytterligare parametrar för add_action()

Funktionen add_action() kan acceptera ytterligare två parametrar: en för att ställa in priority och den andra för att ställa in number of arguments. Medan de är valfria kan de vara riktigt hjälpsamma om de används korrekt.

Priority

Den första ytterligare parametern som stöds av add_action()-funktionen ställer in priority. Denna parameter kan bara vara ett positivt heltal. Ju lägre prioritetsnummer desto tidigare kommer funktionen att köras. Standardvärdet är 10 om du inte ändrar det.

För att se hur det fungerar, låt oss registrera tre callback-funktioner till init-åtgärden, men var och en med olika prioriteringar.

// priority is set to 9, which is lower than 10, hence it ranks higher
add_action( 'init', 'i_am_high_priority', 9 );

// if no priority is set, the default value of 10 will be used
add_action( 'init', 'i_am_default_priority');

// priority is set to 11, which is higher than 11, hence it ranks lower
add_action( 'init', 'i_am_low_priority', 11 );

I exemplen ovan körs callback-funktionen med det lägsta prioritetsnumret först och den med det högsta numret sist. Om de har samma prioritering kommer de att köras i den ordning du registrerat dem.

Prioritet spelar en viktig roll eftersom en enda krok kan ha flera registrerade callback-funktioner. För att undvika oväntade resultat kan du ställa in en prioritet för varje callback-funktion, så att de avfyras i den ordning du vill att de ska.

Number of Arguments

Som standard kommer en callback-funktion som registrerats via add_action()-funktionen endast att få ett argument. Men ibland kan du behöva skicka extra data till callback-funktionen.

Av denna anledning accepterar add_action()-funktionen en valfri parameter för att ställa in antalet argument.

Ett bra exempel på detta är comment_post-åtgärden. Denna åtgärd körs omedelbart efter att WordPress lägger till en kommentar till databasen. Om du inte ställer in parametern number of arguments, kommer det att skicka endast ett enda värde till callback-funktionen, vilket i detta fall kommer att vara comment_ID.

// register the hook with 'priority' and 'number of arguments' parameters
add_action( 'comment_post', 'show_message_function', 10, 3 );

// define the callback function
function show_message_function( $comment_ID, $comment_approved, $commentdata ) {
    // check whether a comment is approved with the second parameter
    if( 1 === $comment_approved ){
        // runs the code only if the comment is approved
    }
}

Om du ställer in parametern number of arguments till 3 som i exemplet ovan, kommer åtgärdsfunktionen att skicka tre värden: comment_ID, comment_approved och commentdata.

WordPress ställer in comment_approved-värdet till 1 för godkända kommentarer, 0 om den inte är godkänd och ”spam” om kommentaren är markerad som spam.

commentdata-variabeln är en array som innehåller alla kommentardata, som kommentarförfattarens namn, e-postadress, webbplats och innehållet i själva kommentaren. Du kan kolla in WordPress Codex för att hitta alla nyckelvärdespar som ingår i ”commentdata”-arrayen.

Du kan ha så många argument som du vill, men callback-funktionen och add_action()-funktionen måste ha samma antal argument.

Genom att skicka ytterligare parametrar till callback-funktionen kan du göra mer med din kod. Du kan till exempel kontrollera om en kommentar är godkänd eller inte och automatiskt mejla kommentartexten till administratören om den är godkänd. Det är inte möjligt att göra detta utan att ange de ytterligare argumenten eftersom din callback-funktion inte har tillgång till comment_content-data.

Om du inte vill ange prioritet, utan bara vill ändra antalet argument, måste du fortfarande ange en prioritet. Använd bara standardvärdet (dvs 10).

Hur WordPresskärnan använder åtgärder

WordPresskärnan använder själv många av sina inbyggda åtgärder för att utföra olika funktioner.

Ta till exempel wp_head-åtgärden. Den avfyras när WordPress matar ut webbsidans header-sektion (koden mellan <head> och </head>).

Du kan hitta de flesta av WordPresskärnans åtgärdsfunktioner relaterade till wp_head-kroken i wp-includes/default-filter.php-fil. Jag kollade genom koden och sammanställde en lista över alla add_action()-funktioner som använder wp_head-åtgärden.

add_action( 'wp_head', 'rest_output_link_wp_head', 10, 0 );
add_action( 'wp_head', '_wp_render_title_tag', 1 );
add_action( 'wp_head', 'wp_enqueue_scripts', 1 );
add_action( 'wp_head', 'wp_resource_hints', 2 );
add_action( 'wp_head', 'feed_links', 2 );
add_action( 'wp_head', 'feed_links_extra', 3 );
add_action( 'wp_head', 'rsd_link' );
add_action( 'wp_head', 'wlwmanifest_link' );
add_action( 'wp_head', 'adjacent_posts_rel_link_wp_head', 10, 0 );
add_action( 'wp_head', 'locale_stylesheet' );
add_action( 'wp_head', 'noindex', 1 );
add_action( 'wp_head', 'print_emoji_detection_script', 7 );
add_action( 'wp_head', 'wp_print_styles', 8 );
add_action( 'wp_head', 'wp_print_head_scripts', 9 );
add_action( 'wp_head', 'wp_generator' );
add_action( 'wp_head', 'rel_canonical' );
add_action( 'wp_head', 'wp_shortlink_wp_head', 10, 0 );
add_action( 'wp_head', 'wp_custom_css_cb', 101 );
add_action( 'wp_head', 'wp_site_icon', 99 );
add_action( 'wp_head', 'wp_no_robots' );

Det där är många callback-funktioner som är krokade på bara en enda åtgärd. Att ställa in priority här är avgörande för att se till att de viktigaste krokfunktionerna körs först.

I ovanstående exempel är det viktigare att ladda scripts med callback-funktionen wp_enqueue_scripts() (prioritet=1) än att ladda metataggarna för webbplatsikonen med callback-funktionen wp_site_icon() (prioritet=99).

Andra åtgärdsfunktioner

Medan add_action() är den mest använda åtgärdsfunktionen finns det många andra som är lika användbara. Låt oss ta en titt på hur de fungerar.

Denna åtgärdsfunktion kontrollerar om en åtgärd har krokats på. Den accepterar två parametrar. Den första är åtgärdens namn. Den andra parametern är valfri och är callback-funktionens namn.

has_action( 'action_name', 'function_to_check' );

Om du bara anger den första parametern returnerar den true om någon funktion är krokad på action_name-parametern.

Men om du också anger den andra parametern kommer den att returnera false om den angivna callback-funktionen inte är registrerad till den åtgärden.

Om den hittar callback-funktionen som är kopplad till åtgärdskroken returneras den priority (ett heltal) som ställts in för den funktionen på den här åtgärdskroken.

Vi har stött på denna åtgärdsfunktion tidigare. WordPress använder den för att definiera alla sina standardåtgärder, vilket gör det möjligt att kroka på andra funktioner. Precis som WordPress kan du också använda funktionen do_action() för att skapa en ny anpassad åtgärd genom att ange ett nytt åtgärdsnamn som parameter.

do_action( 'action_name', [argument1], [argument2] );

Att bara deklarera denna funktion kommer inte att göra något. Men den kommer att sitta kvar i koden och vänta på att andra åtgärdsfunktioner ska aktivera den. Att skicka några extra argument är valfritt, men det är viktigt om du vill att dina callback-funktioner ska använda dem.

Denna åtgärdsfunktion är identisk med do_action(), med ett undantag. Alla eventuella argument som skickas genom den måste vara en array. När du har många argument att skicka eller om dina argument redan finns i en array är denna funktion mycket hjälpsam.

// here's an example array
$arguments_array = array( 'arg_1', 'foo', true, 'arg_4' );

do_action_ref_array( 'example_action', $arguments_array );

Se till att argumenten du skickar kommer i rätt ordning eftersom PHP-arrayer är en ordnad karta.

Ett exempel på den här åtgärdsfunktionens användning är admin_bar_menu-åtgärden. Den kan vara krokad att lägga till, manipulera, eller ta bort de olika objekten i adminfältet. Alla adminfältsobjekt definieras som element i en array.

Om du vill räkna antalet gånger en åtgärd avfyras, kan du anropa denna åtgärdsfunktion.

did_action( 'action_name' );

Denna funktion returnerar ett heltal.

Funktionen did_action() är extremt praktisk när du bara vill köra en callback-funktion första gången en åtgärd körs och aldrig mer.

function example_callback_function() {
    if( did_action( 'example_action' ) === 1 ) {
    // checks if the 'example_action' hook is fired once, and only runs then, and never again!
    }
}
add_action('example_action', 'example_callback_function');

Den här åtgärdsfunktionen tar bort en callback-funktion som är krokad på den angivna åtgärden. Du kan till exempel använda den här funktionen för att ta bort WordPress standardfunktioner som är krokade på inbyggda åtgärder och ersätta dem med din egen.

remove_action( 'action_name', 'function_to_be_removed', [priority] );

Det finns några förutsättningar för att anropa funktionen remove_action():

  1. Parametrarna function_to_be_removed och priority måste vara likadana som de som ursprungligen användes i add_action()-funktionen.
  2. Du kan inte anropa funktionen remove_action() Du måste anropa den inifrån en annan funktion.
  3. Om callback-funktionen är registrerad från en klass finns det andra krav för att ta bort den. Du kan kolla in WordPress Codex-dokumentationen för mer information.
  4. Du kan inte ta bort callback-funktionen innan den är registrerad eller efter att den har körts.

Här är ett exempel på hur WooCommerce använder den här åtgärdsfunktionen för att ta bort den vanliga produktminiatyren på butikssidan.

remove_action( 'woocommerce_before_shop_loop_item_title', 'woocommerce_template_loop_product_thumbnail', 10 );

Denna åtgärdsfunktion tar bort allt som är krokat på en åtgärd. Prioritetsparametern är valfri.

remove_all_actions( 'action_name', [priority] );

Kom ihåg att den här funktionen inte kan anropas från den åtgärd du vill avregistrera callback-funktioner från. Det skulle orsaka en oändlig slinga. Du kan kroka på en åtgärd som har avfyrats tidigare för att köra den här funktionen utan fel.

Denna åtgärdsfunktion kontrollerar om den angivna åtgärden körs eller inte. Det returnerar ett booleskt värde (true eller false).

// check whether the 'action_name' action is being executed
if ( doing_action( 'action_name' ) ) {
    // execute your code here
}

Du kan lämna parametern action_name tom för att kontrollera om någon åtgärd exekveras. Det kommer att vara true varje gång en åtgärd avfyras.

// check if any action is running and do something
if ( doing_action() ) {
    // the code here is run when any action is fired
}

Åtgärdsexempel 1: visa ett underhållsmeddelande för dina besökare

Ibland är det bäst att ta din webbplats offline och skapa en Under Underhålls-sida. Tack och lov ger WordPress oss ett enkelt sätt att göra just det.

// show a maintenance message for all your site visitors
add_action( 'get_header', 'maintenance_message' );
function maintenance_message() {
    if (current_user_can( 'edit_posts' )) return;
    wp_die( '<h1>Stay Pawsitive!</h1><br>Sorry, we\'re temporarily down for maintenance right meow.' );
}

Låt oss bryta ner koden och gå igenom varje steg:

  • get_header är en åtgärd som utlöses innan header-mallfilen på webbplatsen laddas. Det är en perfekt åtgärd att kroka på om du vill hindra huvudsidan från att laddas.
  • Kroka get_header-åtgärden på funktionen add_action() med callback-funktionen maintenance_message().
  • Definiera callback-funktionen maintenance_message().
  • current_user_can ('edit_posts') är en användarkapacitetstestfunktion som kontrollerar om den aktuella användaren är inloggad och kan redigera inlägg. Alla användare som är registrerade på en WordPress-webbplats förutom de med prenumerantroller har möjlighet att redigera inlägg. Det finns andra bra sätt att utföra denna kontroll, men vi kommer att hålla oss till denna enkla metod här.
  • Använd standardfunktionen wp_die() för att döda WordPress-exekveringen snyggt och prydligt och visa en HTML-sida med ett felmeddelande. Du kan använda HTML-syntax i felmeddelandeparametern för att formatera den.

Efter att ha sparat koden i mitt anpassade plugin laddade jag upp min lokala WordPress-installation i privat surfläge. Under Underhåll-sidan är klar!

Visa ett felmeddelande för webbplatsbesökare
Visa ett felmeddelande för webbplatsbesökare

Webbplatsen laddas framgångsrikt om jag är inloggad eftersom den klarar användarkapacitetstestet. Du kan nu fortsätta arbeta med att fixa din webbplats medan den visar vanliga besökare den här sidan.

Åtgärdsexempel 2: Dölj instrumentpanelens menyalternativ från användare som inte har administratörsroller

Om du driver en blogg med flera författare eller hanterar en webbplats åt dina klienter, då kan du behöva dölja vissa adminmenyer från WordPress-panelen för icke-adminanvändare. Du kan göra det genom att kroka på admin_menu-åtgärden.

// remove specific dashboard menus for non-admin users
add_action( 'admin_menu', 'hide_admin_menus' );
function hide_admin_menus() {
    if (current_user_can( 'create_users' )) return;
    if (wp_get_current_user()->display_name == "Salman") return; 
    remove_menu_page( 'plugins.php' ); 
    remove_menu_page( 'themes.php' ); 
    remove_menu_page( 'tools.php' ); 
    remove_menu_page( 'users.php' ); 
    remove_menu_page( 'edit.php?post_type=page' ); 
    remove_menu_page( 'options-general.php' );
}

Här är en genomgång i steg för steg av kodavsnittet ovan:

  • admin_menu är en åtgärd som utlöses innan admin-menyn laddas i WordPresspanelen.
  • Kroka admin_menu-åtgärden på add_action()-funktionen med callback-funktionen hide_admin_menus().
  • Callback-funktionen hide_admin_menus() definierar kodens logik. Den körs varje gång admin_menu-åtgärden avfyras.
  • Inuti callback-funktionen kontrollerar funktionen current_user_can ('create_users') om den inloggade användaren är en administratör. Eftersom endast webbplatsadministratörer har create_user-funktionen avslutas funktionen med ett return-meddelande om användaren är en administratör.
  • WordPressfunktionen wp_get_current_user() hämtar det aktuella användarobjektet. Med den här funktionen kan vi kontrollera om den inloggade användaren har en display_name inställd. Detta är en valfri rad, om du vill utelämna vissa icke-adminanvändare från att utelåsas på grund av denna callback-funktion.
  • WordPressfunktionen remove_menu_page() tar bort adminmenyer på den högsta nivån. I kodexemplet ovan tar jag bort följande adminmenyer: Plugins, teman, verktyg, användare, sidor och alternativ.

Efter att ha sparat plugin-filen ser WordPresspanelen ut så här med en admin inloggad.

WordPress standard-adminpanel
WordPress standard-adminpanel

Och så här ser den ut med en icke-adminanvändare inloggad.

Dölj känsliga adminmenyalternativ från icke-adminanvändare
Dölj känsliga adminmenyalternativ från icke-adminanvändare

Denna lösning döljer bara de angivna adminmenyalternativen från att visas i WordPresspanelen. Alla användare kan fortfarande komma åt dem genom att ange menyadresserna i sina webbläsare.

För att inaktivera vissa användarroller från att komma åt specifika menyer måste du redigera vad de får och inte får göra.

Kroka på ett filter

Filter gör det möjligt för din anpassade kod att ändra data som används av andra WordPressfunktioner. Till skillnad från åtgärder måste funktioner som är krokade på filter returnera ett värde.

Filterfunktionen add_filter()

Du kan kroka en callback-funktion på ett filter genom att följa dessa steg:

  1. Definiera en callback-funktion som kommer att köras när WordPress avfyras filtret. Callback-funktioner för filter måste ha minst ett argument specificerat, eftersom alla filter skickar minst ett värde till sina callback-funktioner.
  2. Registrera callback-funktionen till ett filter med funktionen add_filter(). Filtret tar hand om att anropa callback-funktionen. Enligt WordPress Codex måste add_filter()-funktionen skicka minst två parametrar:
    • Namnet på filtret som ska krokas på.
    • Namnet på den callback-funktion som körs när filtret avfyras.
  3. Funktionen add_filter() accepterar också två ytterligare valfria parametrar för att ställa in priority för och number of arguments. Dessa parametrar fungerar på samma sätt som med add_action()-funktionen.

Här är ett exempel på hur du kan använda funktionen add_filter() för att kroka en callback-funktion till ett filter.

// define the filter callback function with at least one argument passed
// the number of arguments that you can pass depends on how the filter is defined
function filter_callback_function( $arg1, $arg2 ) {
    // make your code do something with the arguments and return something
    return $something;
}

// now hook the callback function to the 'example_filter'
add_filter( 'example_filter', 'filter_callback_function', [priority], [no_of_args] );

// '10' is the default priority set for the callback function
// and '1' is the default number of arguments passed

Exempel på att kroka på ett filter

WordPress tillhandahåller ett filter som heter login_message för att filtrera meddelandet som visas på inloggningssidan ovanför inloggningsformuläret. Värdet som returneras av detta filter kan ha HTML-kod.

Låt oss kroka på login_message-filtret och ändra meddelandet som visas på inloggningsskärmen.

// show a custom login message above the login form
function custom_login_message( $message ) {
    if ( empty( $message ) ) {
        return "<h2>Welcome to Let's Develop by Salman Ravoof! Please log in to start learning.</h2>";
    } 
    else {
        return $message;
    }
}
add_filter( 'login_message', 'custom_login_message' );

If-else-uttrycket i callback-funktionen kontrollerar om inloggningsmeddelandet redan är inställt, oftast av ett annat plugin eller tema. I sådana fall returnerar callback-funktionen det ursprungliga värdet utan att göra några ändringar. Detta är ett sätt att undvika konflikter med andra plugins eller teman.

Du kan se meddelandet ovanför inloggningsformuläret på WordPress-inloggningssidan.

Visa ett eget inloggningsmeddelande ovanför inloggningsformuläret
Visa ett eget inloggningsmeddelande ovanför inloggningsformuläret

Du kan formatera alla element på inloggningssidan genom att köa anpassade formatmallar. Om du gör det kan du helt anpassa din standardinloggningssida för WordPress.

Du lär dig att ladda anpassade formatmallar med hjälp av åtgärder i avsnittet ”Anpassa WordPress-inloggningssidan med krokar”.

Hitta filter som stöds av WordPress

Varhelst WordPress behandlar eller ändrar data kan du nästan säkert hitta ett filter att kroka på och ändra. Tänk på filter som ett gränssnitt mellan WordPress-databasen och webbläsaren.

Du kan hitta en omfattande lista över alla filter som stöds av WordPress på sidan över Plugin API/filterreferenser.

WordPress ger en mängd olika filter att kroka på
WordPress ger en mängd olika filter att kroka på

Alla filter som anges där delas upp i flera kategorier och ordnas från topp till tå i WordPress exekveringsordning.

Om du vill hitta filter att kroka på WordPress källkod, gör en sökning efter termen ”apply_filters” så får du massor av resultat. WordPress Code reference är också ett bra ställe att söka efter allt som ingår i WordPress, inklusive åtgärder och filter.

Hur WordPresskärnan använder filter

Själva WordPresskärnan använder en hel del av sina inbyggda filter för att ändra data som används av dess olika funktioner.

Tänk på the_content-filtret till exempel. Det filtrerar inläggsinnehåll efter att det hämtats från databasen och innan det visas i webbläsaren.

Precis som med åtgärder, kan du hitta de flesta av WordPresskärnans filterfunktioner relaterade till the_content-kroken i wp-includes/default-filter.php-filen.

Här är en lista över alla kärnansadd_filter()-funktioner som kan krokas på the_content-filtret:

add_filter( 'the_content', 'do_blocks', 9 );
add_filter( 'the_content', 'wptexturize' );
add_filter( 'the_content', 'convert_smilies', 20 );
add_filter( 'the_content', 'wpautop' );
add_filter( 'the_content', 'shortcode_unautop' );
add_filter( 'the_content', 'prepend_attachment' );
add_filter( 'the_content', 'wp_make_content_images_responsive' );
add_filter( 'the_content', 'do_shortcode', 11 ); // AFTER wpautop(). 

Notera prioriteten som anges för vissa callback-funktioner.

Till exempel parsar funktionen do_blocks() eventuella dynamiska block i inläggsinnehållet och återparsar dem för att bli kompatibla med WordPress nya blockredigerare. Den har en högre prioritet än standard (10) för att se till att innehållet är blockerat innan de andra funktionerna körs.

Funktionen convert_smilies() är inställd på att köras med lägre prioritet eftersom dess uppgift är att konvertera text-smileys till bild-sprites. Därför är det bra att det körs efter att allt inläggsinnehåll har filtrerats.

Kortkoder är en sorts filter. De tar emot information kortkoden, bearbetar den och returnerar sedan tillbaka resultatet. Läs mer om kortkoder i denna ultimata guide till WordPress-kortkoder.

Andra filterfunktioner

Medan add_filter()är den mest använda filterfunktionen finns det många andra användbara filterfunktioner. Låt oss diskutera dem alla ordentligt.

Denna funktion kontrollerar om det angivna filtret är krokat på en funktion. Den accepterar två parametrar. Den första parametern anger filternamnet. Den andra parametern är valfri och anger namnet på callback-funktionen.

has_filter( 'filter_name', 'function_to_check' );

Om du bara anger den första parametern kommer den att returnera true om filter_name är krokad på vilken funktion som helst.

Men om du anger båda parametrarna kommer den att returnera false om den nämnda callback-funktionen inte är registrerad med det givna filtret. Om den hittar callback-funktionen som är registrerad med filtret returneras den priority (heltal) som ställts in för den funktionen i det här filtret.

En möjlig tillämpning av has_filter()-funktionen är att kontrollera om ett filter redan har krokats på, och baserat på det fortsätta med kodexekveringen.

// check to see if 'the_content' filter has been hooked
if ( ! has_filter( 'the_content' ) {
    // hook the filter if and only if it hasn't been hooked before
    add_filter( 'the_content', 'modify_the_content' );
}

Denna filterfunktion är som åtgärdsfunktionen do_action(). Alla callback-funktioner som är krokade på detta filter kommer köras varhelst den här funktionen finns i WordPresskoden.

Du kan också använda den här funktionen för att skapa ett nytt anpassat filter genom att ange filternamnet och filtervärdet som parametrar.

apply_filters( 'filter_name', 'value_to_filter', [argument1], [argument2] );

Glöm inte att ange ytterligare argument om du vill skicka dem vidare till dina callback-funktioner. De flesta filter använder bara ett argument, så det är lätt att gå miste om att definiera de andra.

Den här funktionen är som apply_filters() -funktionen, förutom att alla argument som den accepterar är kombinerade till en array.

// an example array
$arguments_array = array( 'some_value', 'foo', false, 'another_value' );

apply_filters_ref_array( 'example_filter', $arguments_array );

Denna filterfunktion kan vara praktisk när du har många argument att skicka, eller om alla av dem redan finns i en array. Se till att argumenten i arrayen kommer i rätt ordning.

Denna filterfunktion hämtar namnet på det aktuella filtret eller åtgärden som körs. Du behöver inte ange några parametrar eftersom den körs i callback-funktionen.

Här är ett exempel på hur den kan användas:

function example_callback() {
    echo current_filter(); // 'the_title' will be echoed
    return
}
add_filter( 'the_title', 'example_callback' );

Trots dess namn kan den här funktionen hämta namnet på både åtgärder och filter.

Denna filterfunktion tar bort callback-funktionen som är ansluten till det angivna filtret. Det fungerar precis som funktionen remove_action(). Du kan använda den för att ta bort WordPress standardfunktioner som är registrerade med ett visst filter, och vid behov ersätta dem med dina egna funktioner.

remove_filter( 'filter_name', 'function_to_be_removed', [priority] );

För att koppla ur en callback-funktion som är krokad på ett filter måste parametrarna function_to_be_removed och priority vara identiska med argumenten som används när callback-funktionen krokas på.

Om filtret har lagts till inifrån en klass, vilket vanligtvis är fallet när de läggs till av plugins, måste du komma åt klassvariabeln för att ta bort filtret.

// access the class variable first, and then remove the filter through it
global $some_class;

remove_filter( 'the_content', array($some_class, 'class_filter_callback') );

Låt oss kolla in ett bra praktiskt exempel på remove_filter().

WooCommerce använder anropsfunktionen wc_lostpassword_url() som är krokad på dess lostpassword_url-filter för att omdirigera användares ”Glömt ditt lösenord?”-försök.

Det omdirigerar alla användare som klickar på den länken till en anpassad frontend-sida med webbadressen /my-account/lost-password. Utan detta filter skulle det ta dem till WordPress standard-inloggningsadressen på /wp-login.php.

Säg att du vill återställa den här funktionen och skicka dina användare till standardsidan för lösenordsåterhämtning eller till en helt separat sida. Du kan ta bort den här callback-funktionen så här:

remove_filter( 'lostpassword_url', 'wc_lostpassword_url', 10 ); 

Denna filterfunktion tar bort alla callback-funktioner som är registrerade i ett filter.

remove_all_filters( 'filter_name', [priority] );

Det liknar funktionen remove_all_actions().

Den populära pluginet Advanced Excerpts använder denna funktion för att ta bort alla standardfunktioner som är krokade på filtren the_excerpt och get_the_excerpt. Efter det krokar den sedan på sin egen callback-funktion till filtret.

// Ensure our filter is hooked, regardless of the page type 
if ( ! has_filter( 'get_the_excerpt', array( $advanced_excerpt, 'filter_excerpt' ) ) ) {
    remove_all_filters( 'get_the_excerpt' ); 
    remove_all_filters( 'the_excerpt' ); 
    add_filter( 'get_the_excerpt', array( $advanced_excerpt, 'filter_excerpt' ) );
}

Denna filterfunktion kontrollerar om det angivna filtret körs för tillfället.

if ( doing_filter( 'save_post' ) ) {
    // run your code here
}

Det returnerar ett booleskt värde (trueeller false).

Du bör notera skillnaden mellan den här funktionen och funktionen current_filter(), som returnerar namnet på filtret eller åtgärden som körs (en sträng).

Filterexempel 1: Lägg till ett svordomsfilter för kommentarer

Att hantera alla kommentarer på din WordPresswebbplats kan vara besvärligt. Med comment_text-filtret kan du ställa in regler för att ändra kommentarerna innan de skrivs ut på skärmen.

Ofiltrerade kommentarer med svordomar markerade
Ofiltrerade kommentarer med svordomar markerade

Du kan dirigera WordPress att ta bort eventuella svordomar automatiskt innan de visas för dina besökare. Nu sätter vi igång.

// hook into the 'comment_text' filter with the callback function
add_filter( 'comment_text', 'the_profanity_filter' );

// define a callback function to filter profanities in comments 
function the_profanity_filter( $comment_text ) {
    // define an array of profane words and count how many are there 
    $profaneWords = array('fudge', 'darn', 'pickles', 'blows', 'dangit');
    $profaneWordsCount = sizeof($profaneWords);
    
    // loop through the profanities in $comment_text and replace them with '*'
    for($i=0; $i < $profaneWordsCount; $i++) {
        $comment_text = str_ireplace( $profaneWords[$i], str_repeat('*', strlen( $profaneWords[$i]) ), $comment_text );
    } 
    
    return $comment_text;
}

Det här är koden, rad för rad:

  • comment_text är en filterkrok som låter dig ändra texten i en kommentar innan webbläsaren visar den. Du kan registrera din callback-funktion med den för att filtrera dess utgång.
  • Funktionen add_filter() låter dig kroka på comment_text-filtret och bifoga en callback-funktion.
  • the_profanity_filter() är namnet på callback-funktionen. Den accepterar endast en parameter, en sträng som innehåller kommentartexten. Definiera den här anpassade funktionen med lämplig kodlogik.
  • Lagra alla fula ord i en PHP-array som heter profaneWords. Du kan lägga till så många ord du vill till denna array. Jag lagrar storleken på denna array i profaneWordsCount-variabeln med hjälp av PHP-funktionen sizeof().
  • Det loopar igenom alla fula ord och använder PHP:s standardfunktion str_ireplace() för att ersätta någon av de matchande svordomarna med *-symboler. Eftersom strängutbytesfunktionen inte är känslig för versaler och gemener behöver du inte oroa dig över stora bokstäver. Kolla in olika sätt att utföra en sökning och ersättning.
  • Använd return för att mata ut den filtrerade kommentartexten.

Spara ändringarna i din anpassade plugin-fil och ladda om alla inlägg med kommentarer. Alla ord du har inkluderat i profanewords-arrayen bör nu vara ersatta med *-symboler.

Censurera svordomar i kommentarer med *-symboler
Censurera svordomar i kommentarer med *-symboler

De ursprungliga kommentarerna kommer fortfarande att vara tillgängliga som de är i databasen. Detta filter ändrar bara kommentartexten innan den matas ut till frontenden.

Den ursprungliga kommentaren på webbplatsens backend
Den ursprungliga kommentaren på webbplatsens backend

När du är krokad på rätt filter kan du göra en hel del coola grejer med det.

Till exempel kan du också använda comment_text-filtret för att ta bort eventuella webbadresser från alla kommentarer (se till att läsa den här djupgående guiden om hur du stoppar spamkommentarer i WordPress).

Eller så kan du kroka på pre_comment_approved-filtret, och markera kommentarer som godkända, spam, eller skräp, baserat på fördefinierade kriterier.

Filterexempel 2: infoga innehåll efter ett inlägg

Du har redan sett hur WordPress använder the_content-filtret för att ändra inlägg eller sidinnehåll. Låt oss använda samma filter för att lägga till något i slutet av varje inlägg.

// hook into 'the_content' filter with a callback function
add_filter( 'the_content', 'insert_content_below' );

// define the callback function to insert something below the post
function insert_content_below( $content ) {
    // check to see if we're inside the main loop in a single post
    if ( is_single() && in_the_loop() && is_main_query() ) {
        return $content . "<h3 style=\"text-align: center;\">Let me insert myself here</h3><p style=\"text-align: center;border: 3px solid #5333ed;\">I'll appear after the post. You can insert anything here. Even HTML. Headers, links, images, scripts, I'll take them all and append it to the end of the post content. You can also give me a class, so you can style me easily with CSS style sheets.</p>" ;
    } 
    
    return $content;
}

Förstå kodlogiken i exemplet ovan:

  • Filterkroken the_content hjälper dig att ta tag i innehållet i det aktuella inlägget och anpassa det.
  • Använd funktionen add_filter() för att kroka på the_content-filtret med callback-funktionen insert_content_below().
  • Definiera callback-funktionen genom att skicka det aktuella inläggets innehåll som en parameter ($content).
  • I callback-funktionen kontrollerar du att du bara filtrerar innehållet i huvudförfrågningen, vilket i detta fall är innehållet i inlägget. Om du inte verifierar detta, kommer koden ibland oavsiktligt att filtrera innehåll från andra platser som sidofält och footers.
  • is_main_query() och in_the_loop()-villkoren avgör om förfrågningen är en huvudförfrågan och sker inom WordPress-loopen.
  • is_single()-villkoret kontrollerar om förfrågningen är till för ett enda inlägg.
  • Använd PHPs string concatenation operator ($content."dina tillägg") för att lägga till extra saker i sidinnehållet.
  • return den filtrerade kommentaren om alla ovanstående villkor uppnås. Om det inte gör det, returnera bara innehållet utan ändringar.

Spara din pluginfil, ladda ett inlägg på din webbplats och bläddra ner till slutet.

Infoga något i slutet av inläggets innehåll
Infoga något i slutet av inläggets innehåll

Du kan använda samma logik för att lägga till något i början av alla dina inlägg genom att vända strängkonkateneringsparametrarnas position (“your additions” . $content).

Anpassa WordPress-inloggningssidan med krokar

Låt oss använda både åtgärder och filter för att anpassa WordPress standardinloggningssida. Jag skapar ett nytt plugin som heter Sal Custom Login Page för att göra detta. Du hittar den fullständiga källkoden för detta plugin i slutet av detta avsnitt.

Den slutliga anpassade WordPress-inloggningsskärmen
Den slutliga anpassade WordPress-inloggningsskärmen

Låt oss komma igång genom att lägga till ett plugins standard-headerfält och registrera det med WordPress.

<?php

/*
Plugin Name:  Sal Custom Login Page
Version:  1.0
Description:  Demonstrating WordPress Hooks (Actions and Filters) by customizing the WordPress login page.
Author:  Salman Ravoof
Author URI:  https://www.salmanravoof.com/License: GPLv2 or later
License URI: https://www.gnu.org/licenses/gpl-2.0.html
Text Domain:  sal-custom-login-page
*/

// enqueueing the custom style sheet on WordPress login page
add_action( 'login_enqueue_scripts', 'salhooks_login_stylesheet');
function salhooks_login_stylesheet() {
    // Load the style sheet from the plugin folder
    wp_enqueue_style( 'sal-custom-login-page', plugin_dir_url( __FILE__ ).'sal-custom-login-page-styles.css' );
}

Först krokar du på login_enque_scripts-åtgärden för att köa din anpassade formatmall. Alla skript eller format du köar här ingår i din inloggningssidas header.

Om du vill ladda egna skript och formatmallar på din webbplats frontend (snarare än på admin-backenden eller inloggningsområdet) måste du kroka på wp_enqueue_scripts-åtgärden. Du kan läsa mer om det i WordPress Codex och Kinstas artikel om hur du använder wp_enqueue_scripts.

Inuti callback-funktionen salhooks_login_stylesheet() använder du funktionen wp_enqueue_style() för att ladda den anpassade formatmallen (sal-custom-login-page-styles.css) som finns i samma pluginkatalog. WordPress inbyggda plugin_dir_url (__FILE__)-funktion gör det enkelt att få URL-sökvägen (med ett avslutande snedstreck) för den aktuella pluginkatalogen.

Jag kommer inte att förklara de CSS-stilar vi använt här, men du kan se dem i källkoden i slutet av detta avsnitt.

// Custom login ERROR message to keep the site more secure
add_filter( 'login_errors', 'salhooks_remove_login_errors', 10 );
function salhooks_remove_login_errors() {
    return 'Incorrect credentials. Please try again!';
}

Kroka sedan på login_errors-filtret för att ändra felmeddelandet som visas när någon anger felaktiga uppgifter. Filtrering av felmeddelandet blockerar angripare från att enkelt gissa ditt användarnamn.

// Remove the login form box shake animation for incorrect credentials
add_action( 'login_head', 'remove_login_error_shake' );
function remove_login_error_shake() {
    remove_action( 'login_head', 'wp_shake_js', 12 );
}

Varje gång någon anger felaktiga inloggningsuppgifter, skakar inloggningsformuläret aggressivt. Detta är ett valfritt steg, men jag har inkluderat det för att visa att du också kan ta bort vissa funktioner från inloggningssidan.

Du lär dig mer om funktionerna remove_action() och remove_filter()i det sista avsnittet i den här artikeln.

// Change the logo and header link above the login form
add_filter( 'login_headerurl', 'salhooks_login_headerurl');
function salhooks_login_headerurl( $url ) {
    $url = 'https://salmanravoof.com';
    return $url;
}

add_filter( 'login_headertext', 'salhooks_login_headertext');
function salhooks_login_headertext( $text ) {
    $text = 'Salman Ravoof';
    return $text;
}

Det sista steget är att ändra inloggningsrubrikens URL och text. Du kan kroka på login_headerurl och login_headertext-filtren för att ändra dem båda två.

Om du vill bygga vidare på detta plugin och experimentera vidare kan du ladda ner pluginets källkod och komma igång.

Lista och resurser för WordPresskrokar

Det är svårt att memorera alla de olika krokarna som WordPress har. Det finns tusentals inbyggda åtgärder och filter att kroka på. Därför kan det ibland kännas som en skattjakt att hitta en lämplig krok.

Tack och lov finns det olika resurser som du kan använda för att identifiera den perfekta kroken för dina behov.

Den första platsen att bekanta sig med krokar är WordPress Codex, särskilt dess krokavsnitt i Pluginhandboken. Här hittar du viktig information om krokar och länkar för till komplett dokumentation om alla åtgärder och filter.

Börja lära dig om krokar med WordPress Pluginhandbok
Börja lära dig om krokar med WordPress Pluginhandbok

Bokmärk dessa användbara länkar från Pluginhandboken för att påskynda din sökning:

Både åtgärdsreferens- och filterreferenssidorna ger dig en lista över alla krokar som vanligtvis körs under en specifik WordPress-förfrågan.

Du kan till exempel hitta alla krokar som avfyras när du öppnar en administratörssida, när du har att göra med inläggsbilagor eller med kategorier.

WordPress Codex innehåller också ett praktiskt sökverktyg för att hitta alla dess funktioner, krokar, metoder och klasser. Denna sida listar också nya och uppdaterade komponenter i den senaste versionen av WordPress. Gå hit först om du vill få reda på vad som händer inuti WordPress.

Sök efter vad som helst i WordPress här
Sök efter vad som helst i WordPress här

Detta index över WordPresskrokar sorterar alla krokar efter typ, WordPress-versionen de kom i, och om de är avvecklade.

Adam R Brown's WordPress Hooks Index
Adam R Brown’s WordPress Hooks Index

Att sortera krokarna i ordning efter när de introducerades kommer att visa dig att de äldsta WordPresskrokarna fortfarande är de mest använda. Om du är ny inom WordPressutveckling är det smart att bekanta sig med dessa populära åtgärder och filter, eftersom det är det snabbaste sättet att komma ikapp.

Även om detta index inte har uppdaterats sedan WordPress 5.1, är det fortfarande bra att skumma igenom alla de viktigare krokarna.

Är det fortfarande svårt att hitta kroken du vill ha? En onlinesökning med rätt sökord är alltid ett bra sätt att börja. Om allt annat misslyckas kan du alltid gräva i WordPresskoden.

Hitta krokar registrerade på en WordPress-sida

Som vi har sett har WordPress massor av tillgängliga krokar, men inte varje krok avfyras på varje sida. Om du kan hitta vilka åtgärder och filter du kan kroka på en viss sida, är halva slaget vunnet.

Medan du kan använda avancerade PHP-felsökningsverktyg som xdebug och PHPCS för att hjälpa till med detta, finns det enklare utvecklingsverktyg som Debug Bar och Query Monitor som du kan köra i WordPress.

Debug Bar med tillägget Actions and Filters

Debug Bar är ett officiellt WordPressplugin som lägger till en felsökningsmeny till ditt adminfält. Det visar PHP-varningar och meddelanden, cacheförfrågningar, MySQL-förfrågningar och annan användbar felsökningsinformation.

WordPresspluginet WordPress Debug Bar
WordPresspluginet WordPress Debug Bar

När du har installerat pluginet måste du lägga till kodavsnittet nedan till din webbplats wp-config.php-fil för att aktivera dess felsökningsfunktioner.

define( 'WP_DEBUG', true ); // tracks PHP Warnings and Notices
define( 'SAVEQUERIES', true ); // tracks and displays MySQL queries

Du bör nu se Debug-menyalternativet dyka upp i administratörsfältet. Genom att klicka på det tar du dig till dess instrumentpanel där du kan se olika förfrågningar och cachar som är kopplade till sidan du använde för att komma åt den.

Menyn
Menyn ”Debug” i WordPress adminfält

Därefter måste du installera pluginet Debug Bar Actions and Filters Addon. Det är ett praktiskt tillägg som lägger till ytterligare två flikar i Debug Bar-panelen för att visa åtgärder och filter som utlöstes vid den aktuella begäran.

Åtgärder listade i laddningsordning för den aktuella sidan
Åtgärder listade i laddningsordning för den aktuella sidan

Det kommer också att lista alla funktioner som är krokade på dem, med deras prioritet.

Filter listade med prioritet och registrerade callback-funktioner
Filter listade med prioritet och registrerade callback-funktioner

Du kan klicka på Debug-menyn från vilken sida som helst på din webbplats för att få veta alla åtgärder och filter som du kan kroka på den sidan.

Query Monitor

Query Monitor är en kraftfull utvecklarverktygspanel för WordPress. Du kan använda den för att gräva ner dig i krokarna som finns på en sida, inklusive deras laddningsordning.

WordPresspluginet Query Monitor
WordPresspluginet Query Monitor

Till skillnad från Debug Bar behöver du inte installera några tillägg för att se de åtgärder och filter som utlöses på en viss sida.

Du kan komma åt Query Monitor från administratörsfältet
Du kan komma åt Query Monitor från administratörsfältet

Query Monitor ger dig också mer information om exakt varifrån en krok avfyras.

Krokar & Åtgärdspanelen i Query Monitor
Krokar & Åtgärdspanelen i Query Monitor

I komponentkolumnen kan du se att de flesta krokarna är registrerade från kärnan. Men vissa krokar är registrerade från ett tema eller plugin. Några krokar kan vara registrerade från mer än en komponent.

Du kan använda rullgardinsmenyerna för krokar och komponenter för att endast se de krokar du behöver.

Obs! Query Monitor använder ”Krokar” som en samlingsterm för både åtgärder och filter, men det kallar de registrerade callback-funktionerna för ”Åtgärder.” Detta är tekniskt sett en felaktig definition och kan vara förvirrande, så kom ihåg det.

Du kan göra mer än bara kontrollera alla frågor och förfrågningar med Query Monitor. Det innehåller också avancerade funktioner som stilar, skript, språk, AJAX-anrop, användarkapacitetskontroller, och REST API-anrop.

Kroken ”All”

WordPress har en speciell krok som heter ”all” som du kan kroka på för att köra en callback-funktion för varje enskild krok, oavsett om den är registrerad hos dem alla eller ej. Det är användbart om felsökningssidan kraschar eller om du vill veta när en viss händelse inträffar.

Till exempel kan du använda all-kroken som i exemplet nedan för att echo alla åtgärder som körs.

// echo all the actions being run
function debug_helper_function(){
    echo '<p>' . current_action() . '</p>';
}
add_action( 'all', 'debug_helper_function' );

debug_helper_function()som definieras ovan körs när vilken åtgärd som helst avfyras. Att veta vilken den senaste åtgärden var kommer att ge dig en bättre uppfattning om vad du behöver titta på.

Var lagras WordPresskrokar?

WordPress använder wp_hook-klassen för att implementera hur krokar fungerar. Denna kärnklass används för att hantera alla inbyggda WordPress-åtgärder och filter. Du hittar nästan all kod relaterad till denna klass i wp-includes/class-wp-hook.php-filen.

Tekniskt sett är wp_hook-klassen en array av objekt som innehåller egenskaper som callbacks, iterationer, current_priority, nesting_level och doing_action. Det definierar också en hel del användbara krokfunktioner som kan anropas med hjälp av wp_hook-metoder.

De flesta WordPressutvecklare behöver inte oroa sig mycket över var WordPress lagrar krokar så länge de håller sig till Plugin API:s riktlinjer.

Så skapar du dina egna WordPresskrokar

Du har sett de olika krokarna WordPress tillhandahåller genom sin Plugin API. Du har också tittat på hur du kan använda standardkrokarna för att införliva din egen kod i WordPress-exekveringen.

Om du är en plugin- eller temautvecklare är det bra att ge andra utvecklare ett sätt att interagera med din kod på samma sätt. Anpassade krokar låter dig göra exakt det. De låter andra utvecklare utöka och ändra funktionaliteten i dina plugins och teman.

Att skapa egna åtgärder och filter är ganska enkelt. Du använder samma funktioner som WordPresskärnan använder för att skapa krokar. Låt oss titta på några exempel.

Så här skapar du anpassade åtgärder i WordPress

Använd funktionen do_action() för att skapa en egen åtgärdskrok. Så här gör du det:

// the position where you insert your action is where it'll run when called
do_action( ' my_unique_custom_action' );
// continue with the rest of your code

Andra utvecklare kan nu kroka på ditt plugin eller tema utan att ändra källkoden. Allt de behöver göra är att registrera sina callback-funktioner till ditt plugins anpassade åtgärder med add_action()-funktionen.

add_action( 'my_unique_custom_action', 'some_callback_function' );

// define the callback function you mentioned in the above action function
some_callback_function() {
     // this code will run wherever your custom action hook is 
}

Se till att dokumentera dina egna krokar noggrant och förklara vad de gör i detalj. När allt kommer omkring är det huvudsakliga syftet med att skapa anpassade krokar att hjälpa andra utvecklare att interagera med din kod.

Så här skapar du ett anpassat Filter i WordPress

Använd funktionen apply_filters() för att skapa en anpassad filterkrok. Så här kan du göra det:

$value_to_filter = "I'm a string, but this can be any PHP data type";

// filters modify a value and are typically tied to a predefined variable
apply_filters( 'my_custom_filter', $value_to_filter );

Ditt anpassade filters parametrar bör innehålla en unik identifierare och ett värde att filtrera. Andra utvecklare kan kroka på ditt anpassade filter med add_filter() -funktionen och ändra det skickade värdet.

add_filter( 'my_custom_filter', 'some_callback_function' );

// define the callback function you mentioned in the above filter function
function some_callback_function( $value_to_filter ) {
    // modify the passed value (or not) 
    return $value_to_filter; // returning a value is a must for filters
}

När du definierar ditt anpassade filter, se till att det inte är placerat innan det värde som det ska filtrera kommer definieras. Om du inte placerar filtret korrekt skrivs det filtrerade värdet över av standardvärdet som kommer efteråt.

Konventionella namn för dina anpassade krokar

Det är viktigt att välja ett unikt namn för alla dina anpassade krokar. Eftersom alla plugin eller teman kan ha sina anpassade krokar, kan identiska kroknamn orsaka konflikter i koden med oväntade resultat.

Om du till exempel kallar din åtgärd för send_email är det högst troligt att andra pluginutvecklare också kan välja samma term eftersom den inte är tillräckligt unik. Om en webbplats installerar både ditt och den andra utvecklares plugins, kan det orsaka fel som blir svåra att spåra.

Du kan sätta prefix framför alla dina anpassade krokar med en gemensam identifierare för att de ska vara både enkla och unika. Så istället för send_email kan du kalla det för plugin_name_send_email (plugin_name_ är det unika prefixet här).

Custom Hooks Demo med ett förlängningsbart plugin

Låt oss skapa ett utbyggbart plugin (eller ett pluggbart plugin) som gör det möjligt för andra utvecklare att interagera med det med hjälp av dess anpassade krokar.

Jag ska kalla detta plugin Custom Hooks Demo. Dess huvudsakliga funktion är att mata ut en citatruta var du än lägger in en kortkod. Det kommer att innehålla anpassade åtgärder och filter på rätt platser för att göra det möjligt för andra utvecklare att ändra eller utöka dess funktionalitet.

Du kan hänvisa till min guide över WordPress kortkoder för att lära dig mer om hur kortkoder fungerar.

Låt oss komma igång med det förlängningsbara pluginet.

<?php

/*
Plugin Name :  Custom Hooks Demo
Description :  Demonstrating how to create an extensible WordPress plugin using custom hooks.
Author      :  Salman Ravoof
Author URI  :  https://salmanravoof.com/
License     :  GPLv2 or later
License URI :  https://www.gnu.org/licenses/gpl-2.0.html
Text Domain :  custom-hooks-demo
*/

/** 
 * the [custom_hooks_demo] shortcode returns the HTML code for a quote box.
 * @return string HTML code for a quote box
*/
add_shortcode( 'custom_hooks_demo', 'my_shortcode_callback' );

function my_shortcode_callback ( $arguments ) {
    ob_start(); // start object buffering to collect all output before sending it to the browser
    
    // set an action hook to run before you output anything
    do_action( 'the_topmost_custom_action' );
    
    // define your variables which you want to allow to be filtered
    $quote_content = "Z.E.R.O. That's the number of people who'd like to have any website autoplay music on their browsers.";
    $quote_author = "John Doenuts";
    
    // create your custom filters after you've set the variables
    $quote_content = apply_filters( 'custom_quote_content', $quote_content );
    $quote_author = apply_filters( 'custom_quote_author', $quote_author );
    
    // build the shortcode output template
    echo "<div style=\"border:3px solid #5333ed;\"><blockquote style=\"margin:20px;border-color:#5333ed;\">";
    echo $quote_content;
    echo "<br><br>";
    echo "― <strong>" . $quote_author . "</strong>";
    echo "</blockquote></div>";
    
    // set an action hook to run after you output everything
    do_action( 'the_ending_custom_action' );
    
    return ob_get_clean(); // get buffer contents, delete the buffer, and then stop buffering
}
  • Funktionen add_shortcode() används för att skapa den anpassade kortkoden. Och sedan definierar du kortkodens callback-funktion med hela detta plugins funktionalitet.
  • ob_start() är en PHP-funktion som möjliggör utmatningsbuffring. Det är en superpraktisk funktion som instruerar PHP att hålla fast vid en utmatning i serverns bufferminne snarare än att mata ut den direkt. Du kan använda den för att bygga komplex, läsbar HTML-kod i PHP.
  • do_action ('the_topmost_custom_action') definierar din första anpassade åtgärd. För att göra den användbar måste du definiera den innan pluginet matar ut någonting. Andra utvecklare kan kroka på denna anpassade åtgärd för att köra sin kod innan den här anpassade kortkoden matar ut någonting.
  • Skapa de variabler du vill filtrera. I detta plugin är dessa variabler $quote_content och $quote_author. Båda två är strängar i det här exemplet, men du kan ställa in dem att vara vilken PHP-datatyp som helst (t.ex. heltal, boolesk, array).
  • Använd funktionen apply_filters() för att skapa dina anpassade filter. Eftersom alla filter returnerar ett värde kan du tilldela de tidigare definierade variablerna filtrets returnerade värde. Andra utvecklare kan nu kroka på detta filter för att ändra standardvärdena för de fördefinierade variablerna.
  • Använd echo-uttryck för att bygga din kortkods utmatning rad för rad. Eftersom vi har aktiverat utmatningsbuffring kommer ingen utmatning att nå webbläsaren direkt.
  • do_action ('the_ending_custom_action') definierar din senaste anpassade åtgärd. Du måste definiera det i slutet, men innan du returnerar allt bufferinnehåll.
  • ob_get_clean() är en standard 3-i-1 PHP-funktion. Den hämtar bufferinnehållet, eliminerar alla bufferdata och stoppar sedan buffringen. Den return det samlade bufferinnehållet som en enda sammanlänkad sträng.

När du har sparat och aktiverat det kommer att lägga till [custom_hooks_demo]-kortkoden till ditt inläggs innehåll att mata ut en citatruta med standardvärdena.

Den ursprungliga citationsrutan med pluginet Custom Hooks Demo.
Den ursprungliga citationsrutan med pluginet Custom Hooks Demo.

Låt oss nu skapa ett annat plugin som heter Custom Hooks Demo Extension. Det kommer att kroka på alla anpassade krokar som skapats av föregående plugin och göra eller ändra något.

<?php

/*
Plugin Name :  Custom Hooks Demo Extension
Description :  Demonstrating how you can extend WordPress plugin functionality with its custom hooks.
Author      :  Salman Ravoof
Author URI  :  https://salmanravoof.com/
License     :  GPLv2 or later
License URI :  https://www.gnu.org/licenses/gpl-2.0.html
Text Domain :  custom-hooks-demo-extension
*/

/**
 * replace the quote content by hooking into the 'custom_quote_content' filter
*/
add_filter( 'custom_quote_content', 'new_quote_content_callback' );
function new_quote_content_callback( $content ) {
    $content = "There are no bugs in programming. Only unexpected features.";
    return $content;
}

/**
 * replace the quote author by hooking into the 'custom_quote_author'
*/
add_filter( 'custom_quote_author', 'new_quote_author_callback' );
function new_quote_author_callback( $author ) {
    $author = "Jane Doodle";
    return $author;
}

/**
 * add an image to the top of the shortcode output by hooking into the 'the_topmost_custom_action'
*/
add_action( 'the_topmost_custom_action', 'quote_image_callback' );
function quote_image_callback() {
    $url = "https://upload.wikimedia.org/wikipedia/commons/thumb/f/f9/Quote-right-cs.svg/75px-Quote-right-cs.svg.png";
    echo '<div><img class="aligncenter" src="'.$url.'"></div>';
}

/**
 * add a button below the shortcut output by hooking into the 'the_ending_custom_action'
*/
add_action( 'the_ending_custom_action', 'add_button_callback' );
function add_button_callback() {
    echo '<div style="text-align:center;"><button name="nice">Nice Quote!</button></div>';
}

Som ni kan se innehåller inte detta tilläggsplugin någonting annat än åtgärds- och filterfunktioner som krokar på det ursprungliga pluginet på rätt ställen för att göra ändringar i det.

Det använder funktionerna add_action() och add_filter() för att registrera sina callback-funktioner med anpassade åtgärder och filter som skapats av det ursprungliga pluginet (t.ex. the_topmost_custom_action, custom_quote_author).

Tilläggspluginet ändrar den ursprungliga citatrutan
Tilläggspluginet ändrar den ursprungliga citatrutan

Anpassade åtgärdskrokar låter dig mata in din kod med rätt intervall i det ursprungliga pluginet och köra dina egna skript. Här lägger vi till en bild längst upp och en knapp längst ner.

På samma sätt låter anpassade filterkrokar dig ändra värdena för citatinnehållet och dess författarnamn. Det ultimata resultatet är ett plugin som är fullt förlängningsbart av vem som helst, utan att ändra dess källkod.

Arbeta med anpassade krokar från tredjepartsutvecklare

Anpassade krokar gör det möjligt för enskilda WordPress-plugins och teman att ha ett rikt ekosystem av utbyggbara plugins. Tänk på WooCommerce-pluginet. Det lägger till e-handelsfunktionalitet till WordPress, men har också massor av krokar i sin kod.

WooCommerces Åtgärds- och filterkroksreferenser
WooCommerces Åtgärds- och filterkroksreferenser

WooCommerce har hundratals tillägg och plugins som använder dess krokar för att bygga på dess kärnfunktionalitet och göra den ännu bättre.

Du kan använda dessa tillägg för att integrera WooCommerce med Stripe, MailChimp, Salesforce, Zapier och mycket mer.

Tillägg förlänger WooCommerces funktionalitet
Tillägg förlänger WooCommerces funktionalitet

En bra praxis är att kolla in dokumentationsavsnittet för populära WordPressplugins för att se hur de implementerar anpassade krokar. Några av mina bästa förslag är Easy Digital Downloads, BuddyPress, Quiz and Survey Master och Gravity Forms.

När ska man använda anpassade krokar?

Beroende på temat eller pluginet du skapar, och vem det är avsett för, kanske du undrar om du behöver lägga till några anpassade krokar.

En bra tumregel när man beslutar om man ska lägga till anpassade krokar eller ej är att fundera på om de erbjuder några förlängningsfördelar för andra utvecklare. Om de inte gör det, är det bättre att vänta tills andra utvecklare ber dig att lägga till dem.

Du måste vara mycket säker på om du behöver lägga till anpassade krokar till ditt plugin eller tema eller ej. När det släpps, och om andra utvecklare redan har använt det, kan du aldrig ändra det utan att bryta bakåtkompatibiliteten.

Ta bort Callback-funktioner från WordPresskrokar

Du har redan sett exempel på hur du tar bort callback-funktioner som är registrerade på vissa krokar. Dessa callbacks kan registreras av plugins, teman, och till och med själva WordPresskärnan. Låt oss titta på att ta bort krokade callback-funktioner med fler exempel.

För att ta bort en callback-funktion från en krok, beroende på om den är registrerad till en åtgärd eller ett filter, måste du använda funktionerna remove_action() eller remove_filter().

Du behöver vara medveten om att du måste anropa dessa funktioner med parametrar som är identiska med de som användes för att faktiskt registrera callback-funktionen. I princip kopiera och klistra in parametrarna från deras add_action()eller add_filter()-funktioner.

Du kan bara ta bort callback-funktioner efter att de är registrerade. Om du försöker ta bort dem innan de är registrerade kommer borttagningsprocessen att misslyckas. Du måste få krokarnas exekveringsordning i rätt ordning.

Låt oss säga att du vill ta bort en callback-funktion som är registrerad av ett tema som lägger till en massa onödigt till din webbplats (du vill ha en snabb webbplats, eller hur?).

function wp_bloated_callback_function() {    
// some code that adds a lot of bloat to the site
}
add_action( 'template_redirect', 'wp_bloated_callback_function', 5 );

Ovanstående callback-funktion kan till exempel ladda många onödiga skript och formatmallar. Att ta bort den kommer att ge din webbplats en enorm prestandaökning.

Du måste dock se till att funktionen remove_action() körs först efter template_redirect-åtgärden. Ett sätt att göra detta är att kroka på after_setup_theme-åtgärden eftersom den utlöses efter template_redirect-åtgärden.

function wp_remove_bloat() {
    // ensure all parameters are identical to the original add_action() function
    remove_action( 'template_redirect', 'wp_bloated_callback_function', 5 );
}

// ensure that remove_action() is called only after add_action()
add_action( 'after_setup_theme', 'wp_remove_bloat' );

wp_bloated_callback_function() kommer nu att krokas av från template_redirect-åtgärden.

Särskilda fall av att ta bort callback-funktioner

Det kan krävas mer för att ta bort callback-funktioner än att bara inaktivera dem helt och hållet. Ibland kan du behöva ta bort dem tillfälligt, köra din kod och sedan lägga till dem igen.

Till exempel aktiveras save_post-åtgärden varje gång funktionerna wp_insert_post() och wp_publish_post()anropas. Du hittar dem båda definierade i wp-includes/post.php-filen.

Så om du har en callback-funktion krokad på save_post-åtgärden, och om du anropar funktionerna wp_insert_post() eller wp_publish_post() inom din callback-funktion, kommer save_post-åtgärden att avfyras flera gånger.

function some_callback_function( $post_id, $post ) {
    // do something here
    wp_insert_post( [some_array] ); // this function also calls the 'save_post' action
    // maybe do something more
}
add_action( 'save_post', 'some_callback_function', 10, 2 );

En funktion som anropar åtgärden som också anropar den kan skapa oväntade resultat. Ett sätt att komma runt det här problemet är att använda funktionen remove_action() inuti din callback-funktion innan du anropar wp_insert_post().

function some_callback_function( $post_id, $post ) {
    // do something here
    
    // remove the callback function from the ‘save_post’ action
    remove_action( 'save_post', 'some_callback_function', 10, 2 );
    
    // now run the wp_insert_post() function
    wp_insert_post( [some_array] );
    
    // add the callback function back to the ‘save_post’ action
    add_action( 'save_post', 'some_callback_function', 10, 2 );
    
    // maybe do something more
}
add_action( 'save_post', 'some_callback_function', 10, 2 );

Det är en annan praktisk användning av remove_action() eller remove_filter()funktionerna. Att gräva djupare in i WordPresskärnan hjälper dig att förstå hur du bättre kan undvika dessa situationer.

Bonusguider för WordPresskrokar

Sammanfattning

Det finns flera fördelar med att använda WordPresskrokar om du är en WordPressutvecklare.

Krokar låter dig inte bara ändra eller utöka WordPresskärnans funktionalitet, men du kan också använda dem för att ändra plugins, teman, och låta andra utvecklare interagera med dina plugins eller teman.

Det är dags att låta WordPresskrokar få dig på kroken!

Salman Ravoof

Salman Ravoof är en självlärd webbutvecklare, författare, skapare och en stor beundrare av fri och öppen källkod (FOSS). Förutom teknik är han intresserad av vetenskap, filosofi, fotografi, konst, katter och mat. Lär dig mer om honom på hans hemsida och kontakta Salman på X.