WordPress hooks, actions en filters: complete gids

WordPress hooks zijn vaste aanknopingspunten in WordPress-code waarop je eigen functies kunt aansluiten. Gebruik een action om iets uit te voeren, zoals een script laden of een melding tonen. Gebruik een filter om bestaande data te veranderen, zoals een titel, tekst of instellingenarray. Zo breid je een website uit zonder WordPress corebestanden aan te passen.

Voor zakelijke websites zijn hooks vooral relevant wanneer standaardfunctionaliteit niet precies past bij het proces, de contentstructuur of de conversiedoelen. Een goede implementatie houdt maatwerk uitbreidbaar en beter onderhoudbaar.

Wat zijn WordPress hooks?

Een hook is een punt waarop WordPress, een theme of een plugin andere code de gelegenheid geeft om in te grijpen. De code die je koppelt heet een callback-functie. WordPress roept die functie aan zodra de betreffende hook wordt uitgevoerd.

Hooks voorkomen dat je bestanden van WordPress core rechtstreeks wijzigt. Dat is belangrijk: wijzigingen in corebestanden kunnen bij een update verdwijnen en maken onderhoud onnodig kwetsbaar.

Actions en filters: het verschil in één overzicht

Situatie	Kies	Wat doet je callback?	Praktisch voorbeeld
Je wilt extra gedrag uitvoeren	Action	Voert een taak uit	Laad een eigen stylesheet op de website
Je wilt bestaande data wijzigen	Filter	Ontvangt data, past die aan en geeft die terug	Voeg een vaste toevoeging aan paginatitels toe
Je bouwt eigen uitbreidbare functionaliteit	Custom action of filter	Geeft andere ontwikkelaars een uitbreidingspunt	Laat een plugin reageren nadat een aanvraag is verwerkt
Je past gedrag in de block editor aan	JavaScript hook	Wijzigt editorgerelateerde data of gedrag	Breid instellingen van een blok uit

Action: iets laten gebeuren

Met add_action() koppel je een callback aan een action hook. In dit voorbeeld laad je een stylesheet via de daarvoor bedoelde WordPress-hook:

function lynx_laadt_eigen_stylesheet() {
    wp_enqueue_style(
        'lynx-aanpassingen',
        get_stylesheet_directory_uri() . '/aanpassingen.css'
    );
}

add_action( 'wp_enqueue_scripts', 'lynx_laadt_eigen_stylesheet' );

De action verandert zelf geen waarde die WordPress daarna verder verwerkt. Hij zet een handeling in gang.

Filter: data aanpassen en teruggeven

Met add_filter() wijzig je een waarde voordat WordPress die gebruikt of toont. Bij een filter is het teruggeven van de aangepaste waarde essentieel:

function lynx_voegt_toe_aan_titel( $title ) {
    return $title . ' | Voorbeeldbedrijf';
}

add_filter( 'the_title', 'lynx_voegt_toe_aan_titel' );

Laat je return weg, dan kan de uitvoer onverwacht leeg worden of fouten veroorzaken. Pas een algemene filter als the_title bovendien zorgvuldig toe: titels komen op verschillende plekken terug, ook buiten de hoofdinhoud.

Zo implementeer je hooks veilig

1. Omschrijf eerst het gewenste gedrag. Bepaal of je iets wilt uitvoeren of bestaande data wilt wijzigen. Dat maakt de keuze tussen een action en filter direct duidelijk.
2. Zoek een bestaande hook in de officiële documentatie. Gebruik bij voorkeur een bestaande, stabiele hook van WordPress, het actieve theme of de betreffende plugin.
3. Kies de juiste plek voor de code. Zie de beslisregels verderop. Plaats tijdelijke productiewijzigingen niet achteloos in een bestand dat bij een theme-update kan worden overschreven.
4. Maak een uniek voorvoegsel of gebruik een namespace. Geef functies en custom hooks een herkenbare, unieke naam. Daarmee verklein je de kans op naamconflicten met plugins of ander maatwerk.
5. Registreer je callback. Gebruik add_action() of add_filter() en geef alleen argumenten mee die je callback daadwerkelijk verwerkt.
6. Test op een veilige omgeving. Controleer de relevante pagina's, formulieren, beheeromgeving en foutlog voordat je naar productie gaat.
7. Documenteer doel en afhankelijkheden. Leg vast welke hook wordt gebruikt, waarom die nodig is en van welk theme of welke plugin de implementatie afhankelijk is.

Priority en argumenten begrijpen

Meerdere callbacks kunnen aan dezelfde hook hangen. De priority bepaalt de volgorde waarin WordPress ze uitvoert. Gebruik die alleen wanneer de volgorde functioneel nodig is, bijvoorbeeld omdat jouw wijziging voortbouwt op een andere callback.

Hooks kunnen ook gegevens meegeven aan callbacks. Bij het registreren bepaal je welke beschikbare argumenten je functie ontvangt. Houd callback en registratie gelijk: verwacht je functie meerdere waarden, dan moet de hook die waarden ook leveren en moet je registratie daarop zijn ingericht.

Praktische regel: begin eenvoudig. Voeg pas een afwijkende priority of extra argumenten toe wanneer je precies weet welk conflict of welke afhankelijkheid je oplost.

Custom hooks maken voor eigen maatwerk

Ontwikkel je een eigen plugin of uitgebreider theme-onderdeel, dan kun je zelf uitbreidingspunten aanbieden. Daarmee voorkom je dat toekomstige aanpassingen in je kernlogica terechtkomen.

Een custom action met do_action()

function lynx_verwerkt_aanvraag( $aanvraag ) {
    // Verwerk de aanvraag.

    do_action( 'lynx_na_aanvraag_verwerkt', $aanvraag );
}

Andere code kan daarna op deze gebeurtenis reageren:

function lynx_stuurt_interne_melding( $aanvraag ) {
    // Verstuur of registreer een interne melding.
}

add_action( 'lynx_na_aanvraag_verwerkt', 'lynx_stuurt_interne_melding' );

Een custom filter met apply_filters()

function lynx_bepaalt_aanvraaglabel( $label ) {
    return apply_filters( 'lynx_aanvraaglabel', $label );
}

Een andere ontwikkelaar kan de waarde wijzigen zonder de oorspronkelijke functie aan te passen:

function lynx_wijzigt_aanvraaglabel( $label ) {
    return 'Nieuwe zakelijke aanvraag';
}

add_filter( 'lynx_aanvraaglabel', 'lynx_wijzigt_aanvraaglabel' );

Kies duidelijke, unieke namen voor custom hooks. Een prefix of namespace voorkomt dat jouw hooknaam botst met die van andere code.

Waar hoort hook-code thuis?

• Eigen plugin: kies dit voor functionaliteit die moet blijven bestaan wanneer het design of theme verandert. Denk aan koppelingen, bedrijfslogica, maatwerk rondom formulieren of contentprocessen.
• Custom theme: geschikt voor functionaliteit die onlosmakelijk verbonden is met de presentatie van dat specifieke theme.
• functions.php: alleen passend wanneer dit bestand onderdeel is van een goed beheerd custom of child theme. Houd rekening met de afhankelijkheid van het actieve theme.
• WordPress core: nooit aanpassen voor websitespecifiek maatwerk. Updates kunnen wijzigingen overschrijven.

Gebruik je een block theme, dan ligt de grens tussen presentatie en functionaliteit extra scherp. Lees daarom ook de gids over 404- en soft-404-fouten als je templates, contentroutes of verwijderde onderdelen aanpast. Technische wijzigingen kunnen gevolgen hebben voor bezoekers én zoekmachines.

JavaScript hooks in de block editor

De block editor heeft naast PHP-hooks ook JavaScript-hooks via het pakket @wordpress/hooks. Daarmee kun je gedrag en data in de editor uitbreiden. Dit is vooral relevant voor maatwerkblokken, editorintegraties en geavanceerde aanpassingen aan de bewerkervaring.

import { addFilter } from '@wordpress/hooks';

function lynx_uitbreiden_blokinstellingen( settings, name ) {
    if ( name !== 'core/paragraph' ) {
        return settings;
    }

    return settings;
}

addFilter(
    'blocks.registerBlockType',
    'lynx/uitbreiden-blokinstellingen',
    lynx_uitbreiden_blokinstellingen
);

De namespace lynx/uitbreiden-blokinstellingen identificeert deze registratie. Gebruik een unieke namespace, zodat je een eigen JavaScript-hook gericht kunt beheren of verwijderen. Voor de bredere keuze tussen moderne themes, templates en de editor is een strategisch ontwerp- en ontwikkeltraject vaak verstandiger dan losse codewijzigingen. Bekijk daarvoor strategisch creatief webdesign.

Hooks verwijderen

Soms wil je gedrag van een theme of plugin uitschakelen. Daarvoor bestaan remove_action() en remove_filter(). Dit werkt alleen als je dezelfde hook, callback en relevante registratiegegevens gebruikt als bij de oorspronkelijke koppeling.

remove_action( 'wp_enqueue_scripts', 'voorbeeld_callback' );

Controleer ook het moment waarop je code draait. Probeer je een callback te verwijderen voordat deze is toegevoegd, dan heeft de verwijdering geen effect. Pas bestaande pluginfunctionaliteit bij voorkeur uit via officiële instellingen of gedocumenteerde extensiepunten, niet door willekeurig interne callbacks te verwijderen.

Veelgemaakte fouten

• Corebestanden aanpassen: dit maakt updates risicovol en wijzigingen zijn niet duurzaam.
• Een filterwaarde niet teruggeven: filters horen een waarde terug te leveren.
• Te algemene functienamen gebruiken: dit vergroot de kans op conflicten.
• Code in het verkeerde theme plaatsen: functionaliteit die losstaat van het ontwerp hoort meestal in een plugin.
• Geen rekening houden met context: een hook kan ook in het dashboard, via een API of op andere templates draaien.
• Ongetest live aanpassen: één syntaxfout kan een pagina of beheerscherm onbruikbaar maken.
• Hooks gebruiken waar configuratie voldoende is: kies eerst de beschikbare WordPress-, theme- of plugininstellingen als die het doel veilig oplossen.

Testen en debuggen

Werk voor maatwerk bij voorkeur met versiebeheer en een gescheiden ontwikkel- of testomgeving. Test niet alleen of de gewenste verandering zichtbaar is, maar ook of bestaande formulieren, templates en beheerhandelingen blijven werken.

Bij problemen helpt het om de callback tijdelijk te isoleren, de naam en timing van de hook te controleren en foutmeldingen in de server- of WordPress-logging te beoordelen. Documenteer na afloop welke wijziging is gedaan. Dat voorkomt zoekwerk wanneer een plugin-, theme- of WordPress-update later iets verandert.

Wanneer maatwerk WordPress development inschakelen?

Schakel een ontwikkelaar in wanneer een wijziging bedrijfsprocessen, leadopvolging, privacygevoelige gegevens, complexe formulieren, externe koppelingen of editorfunctionaliteit raakt. Ook als verschillende plugins dezelfde onderdelen beïnvloeden, is een technische beoordeling verstandig.

LYNX Media combineert websiteontwikkeling met aandacht voor vindbaarheid en conversie. Bekijk het overzicht van webdesign-, SEO- en online-marketingdiensten als je wilt bepalen welke technische verbeteringen en commerciële doelen samen moeten komen.

Praktische checklist

• Is dit een action, een filter of een instelling die al beschikbaar is?
• Is er een gedocumenteerde hook die past bij het doel?
• Staat de code in een plugin of theme op de juiste plek?
• Hebben functies en custom hooks een unieke naam of namespace?
• Geeft iedere filtercallback een correcte waarde terug?
• Is de wijziging getest buiten de productieomgeving?
• Is vastgelegd wat de code doet en waarvan die afhankelijk is?

Hulp nodig bij WordPress-maatwerk? Bespreek je website of online groeikansen met LYNX Media.