Web & Ontwikkeling

Hoe maak je toegankelijke modale dialogen met HTML, CSS en JavaScript

How to Create Accessible Modal Dialogs with HTML, CSS, and JavaScript

Bouw toegankelijke modale dialogen met behulp van het native HTML dialog element. Leer hoe je pop-ups opent en sluit, de focus op het toetsenbord beheert, achtergronden vormgeeft en bevestigingsdialoogvensters maakt zonder een JavaScript-bibliotheek.

Hoe je toegankelijke modale dialogen maakt met HTML, CSS en JavaScript

Een bezoeker klikt op een knop op je website. Een popup verschijnt met een formulier, een bevestigingsbericht of aanvullende informatie.

Het visueel maken van de popup is eenvoudig. Het laten correct werken met een toetsenbord, een schermlezer en een mobiele browser is een ander verhaal.

Veel aangepaste modal-implementaties vertrouwen op grote hoeveelheden JavaScript om focus te beheren, interactie met de pagina te blokkeren en de Escape-toets af te handelen.

Moderne HTML biedt een eenvoudigere aanpak: het native <dialog>-element.

Het biedt veel van het verwachte gedrag van een modale dialoog direct in de browser. Je kunt een functionele popup maken met een kleine hoeveelheid HTML, CSS en JavaScript, zonder een framework of plugin te installeren.

In deze tutorial bouwen we een herbruikbare modal, stijlen we deze, voegen we een bevestigingsdialoog toe en verkennen we de toegankelijkheidsdetails die ertoe doen op echte websites.

1. Wat maakt een modale dialoog anders dan een gewone popup?

Een modale dialoog vereist tijdelijk dat de bezoeker interactie heeft met een specifiek deel van de interface voordat hij terugkeert naar de hoofdpagina.

Typische voorbeelden zijn:

  • Bevestigen van het verwijderen van een item.
  • Een contactformulier tonen.
  • Om bevestiging vragen voordat men een pagina verlaat.
  • Aanvullende productinformatie tonen.
  • Een applicatie-instelling bewerken.

Een correct geïmplementeerde modal moet haar doel duidelijk maken, een duidelijke manier om hem te sluiten bieden en toetsenbordfocus op de juiste manier beheren.

Het native <dialog>-element ondersteunt zowel modaal als niet-modaal gedrag.

Methode Gedrag
showModal() Opent een modaal en maakt de rest van het document inert
show() Opent een niet-modale dialoog
close() Sluit de dialoog
method="dialog" Laat een formulierknop de dialoog sluiten

Het modale gedrag omvat focusbeheer en toetsenbordinteractie die door de browser worden geleverd.

2. Maak je eerste HTML-modal

Laten we beginnen met een eenvoudig voorbeeld: een knop die een dialoog opent met een titel, wat tekst en een sluitknop.

<button type="button" id="openDialog">
    View delivery information
</button>

<dialog id="deliveryDialog"
        aria-labelledby="deliveryTitle">

    <h2 id="deliveryTitle">
        Delivery information
    </h2>

    <p>
        Orders are prepared within two business days.
        You will receive a tracking link by email.
    </p>

    <form method="dialog">
        <button type="submit" autofocus>
            Close
        </button>
    </form>

</dialog>

<script>
const openButton = document.getElementById('openDialog');
const dialog = document.getElementById('deliveryDialog');

openButton.addEventListener('click', () => {
    dialog.showModal();
});
</script>

Dat is genoeg om een werkende modale dialoog te maken.

Wanneer de bezoeker op de knop klikt, opent showModal() de dialoog boven de pagina-inhoud.

De browser behandelt verschillende belangrijke gedragingen automatisch:

  • De dialoog komt in de top layer, boven gewone pagina-inhoud.
  • De rest van het document wordt inert.
  • Toetsenbordfocus verplaatst zich naar binnen de dialoog.
  • Het indrukken van Escape sluit het normaal.
  • Focus keert normaal terug naar de openende knop wanneer de dialoog sluit.

De sluitknop gebruikt method="dialog", dus het vereist geen JavaScript-gebeurtenishandler.

3. Styleer de dialoog met CSS

De standaarddialoog werkt, maar het uiterlijk is basis.

We kunnen het afgeronde hoeken, comfortabele ruimte, een responsieve breedte en een achtergrond (backdrop) geven.

dialog {
    width: min(90vw, 520px);
    max-height: 85vh;
    box-sizing: border-box;
    padding: 2rem;
    border: 0;
    border-radius: 14px;
    background: #fff;
    color: #20242b;
    box-shadow: 0 20px 70px rgba(0, 0, 0, .2);
    overflow: auto;
}

dialog::backdrop {
    background: rgba(15, 23, 42, .65);
    backdrop-filter: blur(3px);
}

dialog h2 {
    margin-top: 0;
    font-size: 1.5rem;
}

dialog p {
    line-height: 1.6;
}

dialog button {
    padding: .75rem 1.25rem;
    border: 0;
    border-radius: 8px;
    background: #2458d3;
    color: #fff;
    font: inherit;
    cursor: pointer;
}

dialog button:focus-visible {
    outline: 3px solid #f59e0b;
    outline-offset: 3px;
}

Het ::backdrop-pseudo-element styleert de laag achter een modale dialoog.

Het verschijnt alleen wanneer de dialoog modaal wordt getoond, bijvoorbeeld via showModal().

Een dialoog geopend met show() ontvangt niet automatisch hetzelfde modale backdrop-gedrag.

Waarom de top layer gebruiken?

Traditionele aangepaste popups vertrouwen vaak op steeds grotere z-index-waarden.

Een modale dialoog geopend met showModal() komt in de top layer van de browser, wat veel stacking-context-problemen voorkomt.

Dit is met name handig op websites met sticky headers, zwevende widgets en complexe page builders.

4. Begrijp toetsenbordtoegankelijkheid

Een modal moet werken zonder muis.

Stel je een bezoeker voor die je website navigeert met de Tab-toets. Wanneer een modal opent, moet hij met de controls kunnen interacteren zonder per ongeluk in de pagina erachter te treden.

De native modale dialoog helpt met dit gedrag.

De W3C beschrijft het HTML-dialoogelement als een techniek voor het maken van toegankelijke modale dialogen, inclusief focus-inbeslote en terugkeer van focus wanneer de dialoog sluit.

Geef de dialoog een toegankelijke naam

Gebruik een zichtbare kop en verwijz ernaar met aria-labelledby:

<dialog aria-labelledby="settingsTitle">
    <h2 id="settingsTitle">Account settings</h2>
    ...
</dialog>

Dit geeft hulpmiddelen een betekenisvolle naam voor de dialoog.

Kies de initiële focus zorgvuldig

Het autofocus-attribuut kan het controleren identificeren dat focus moet ontvangen wanneer de modal opent.

Voor een informatieve dialoog kan het focus geven op de sluitknop passend zijn.

Illustration of the article's main concept

Voor een formulier kan het focus geven op de eerste invoer meer zin hebben.

Voor een destructieve bevestiging is het focus geven op de veiligere actie, zoals Annuleren, vaak te verkiezen.

Vermijd het plaatsen van tabindex direct op het <dialog>-element; de HTML-specificatie verbiedt dat attribuut op het element zelf.

Altijd een zichtbare sluitknop voorzien

Hoewel Escape normaal een modale dialoog sluit, blijft een zichtbaar sluitcontrol essentieel.

Mobiele bezoekers hebben misschien geen fysiek toetsenbord, en sommige gebruikers weten niet dat Escape een popup kan sluiten.

5. Maak een bevestigingsdialoog met twee knoppen

Laten we nu een nuttiger voorbeeld bouwen: het bevestigen van het verwijderen van een opgeslagen item.

De bezoeker moet kunnen kiezen tussen Annuleren of Verwijderen.

HTML biedt een handig mechanisme via method="dialog" en de returnValue-eigenschap van de dialoog.

<button type="button" id="deleteItem">
    Delete item
</button>

<dialog id="confirmDialog"
        aria-labelledby="confirmTitle">

    <h2 id="confirmTitle">
        Delete this item?
    </h2>

    <p>
        This action cannot be undone.
    </p>

    <form method="dialog">
        <button value="cancel" autofocus>
            Cancel
        </button>

        <button value="confirm">
            Delete
        </button>
    </form>

</dialog>

<script>
const deleteButton = document.getElementById('deleteItem');
const confirmDialog = document.getElementById('confirmDialog');

deleteButton.addEventListener('click', () => {
    confirmDialog.returnValue = 'cancel';
    confirmDialog.showModal();
});

confirmDialog.addEventListener('close', () => {
    if (confirmDialog.returnValue === 'confirm') {
        // Call your application deletion logic here.
        console.log('Deletion confirmed');
    }
});
</script>

Het belangrijke detail is dat het klikken op een knop binnen een method="dialog"-formulier de dialoog sluit en de returnValue instelt.

Onze code controleert of de gebruiker confirm heeft geselecteerd.

Het resetten van de waarde voordat je opent, voorkomt dat een eerdere bevestiging per ongeluk voor een nieuwe wordt aangezien als de gebruiker de dialoog sluit met Escape.

Het voorbeeld verwijdert bewust niets. In een echte applicatie zou de bevestigde actie je eigen PHP-eindpunt of applicatiecontroller aanroepen, met de benodigde autorisatie- en CSRF-beschermingen.

6. Test de bevestigingsworkflow

Een nuttige demonstratie is een lijst met opgeslagen items, elk met een Verwijder-knop. Het klikken op Verwijderen moet een bevestigingsdialoog openen. Annuleren moet het item ongewijzigd laten; Bevestigen moet alleen het geselecteerde item verwijderen.

Dit illustreert de bevestigingsstroom zonder echte websitegegevens te wijzigen.

7. Voeg een contactformulier toe in een dialoog

Een contactformulier is nog een veelvoorkomend use case.

Maar er is een belangrijk verschil tussen het sluiten van een dialoog en het versturen van gegevens naar een server.

Een formulier met method="dialog" sluit de popup. Het stuurt geen conventionele HTTP-request naar je PHP-backend.

Voor een echt contactformulier, gebruik een normale formulierversturing of een AJAX-verzoek.

Bijvoorbeeld:

<dialog id="contactDialog"
        aria-labelledby="contactTitle">

    <h2 id="contactTitle">
        Contact us
    </h2>

    <form action="/contact-handler.php" method="post">
        <label for="contactEmail">
            Your email
        </label>

        <input
            type="email"
            id="contactEmail"
            name="email"
            required
            autocomplete="email"
            autofocus
        >

        <label for="contactMessage">
            Your message
        </label>

        <textarea
            id="contactMessage"
            name="message"
            required
        ></textarea>

        <button type="submit">
            Send message
        </button>

        <button type="button" id="closeContact">
            Cancel
        </button>
    </form>
</dialog>

De Verzenden-knop stuurt het formulier normaal.

De Annuleren-knop moet de dialoog sluiten zonder te versturen:

document.getElementById('closeContact')
    .addEventListener('click', () => {
        document.getElementById('contactDialog').close();
    });

Je PHP-handler moet de verzonden gegevens nog steeds valideren, anti-spam-bescherming implementeren en een betekenisvol succes- of foutbericht retourneren.

Een modale dialoog verbetert de interface; het vervangt geen server-side formulierbeveiliging.

8. Kunnen gebruikers de dialoog sluiten door ernaast te klikken?

Veel websites laten bezoekers een popup sluiten door op de achtergrond (backdrop) te klikken.

Dit gedrag heet vaak light dismiss.

Moderne HTML bevat het closedby-attribuut, waarmee je kunt specificeren of een dialoog kan worden gesloten via buitenaan-interactie, platform-sluitverzoeken of expliciete controls.

Bijvoorbeeld:

<dialog id="infoDialog" closedby="any">
    <h2>More information</h2>
    <p>Additional details appear here.</p>

    <form method="dialog">
        <button>Close</button>
    </form>
</dialog>

De closedby="any"-waarde staat light-dismiss-gedrag toe in browsers die het ondersteunen.

Ondersteuning voor nieuwere dialoogfeatures moet echter worden gecontroleerd tegen je doelbrowsers. De basis showModal()- en close()-API's zijn breder gevestigd.

Voor kritieke bevestigingsdialogen kan ongewilde buitenafsluiting ongewenst zijn.

In alle gevallen, houd een zichtbare sluit- of annuleren-control.

9. Vermijd deze veelvoorkomende implementatiefouten

Technical workflow illustration

Een modal openen door het open-attribuut toe te voegen

Deze code:

dialog.setAttribute('open', '');

biedt niet hetzelfde gedrag als:

dialog.showModal();

Het open-attribuut toont de dialoog niet-modaal. Het maakt de rest van het document niet automatisch inert.

Gebruik showModal() wanneer je een echte modal nodig hebt.

Het open-attribuut verwijderen om een modal te sluiten

Vermijd het handmatig verwijderen van het open-attribuut van een actieve modal.

Gebruik:

dialog.close();

Dit volgt de bedoelde levenscyclus en zorgt voor het juiste sluitgedrag.

Een link gebruiken in plaats van een knop

Een control die een interface-actie opent, moet doorgaans een knop zijn:

<button type="button">Open settings</button>

Gebruik links voor navigatie naar een ander resource.

Focus-zichtbaarheid vergeten

Gebruikers die met een toetsenbord navigeren, hebben een zichtbare indicatie nodig van welk control actief is.

Houd een duidelijke :focus-visible-stijl in plaats van browser-focus-outlines te verwijderen zonder vervanging.

De dialoog plaatsen in een verborgen container

Als een oudercontainer verborgen is, of als een CMS dynamisch de omringende markup vervangt, kan de dialoog onverwacht gedrag vertonen.

Voor page-builder-integraties, verkies een stabiele container en zorg dat de JavaScript pas draait nadat de dialoog in het document is geïnsereerd.

10. Integreer een dialoog in WordPress of Joomla

Je hoeft geen extensie te maken om het native dialoogelement te gebruiken.

Voor een eenvoudige website bestaat de integratie uit drie delen:

Deel Waar het komt
HTML-markup Custom HTML-blok, module, sjabloon of page-builder-element
CSS Thema of sjabloon custom CSS
JavaScript Thema/sjabloon custom JavaScript of een ondersteunde code-injectie-functie

WordPress

In WordPress kun je de HTML in een Custom HTML-blok plaatsen, mits je account en editor-configuratie de benodigde markup toestaan.

Voeg de styling toe via het ondersteunde custom CSS-mechanisme van je thema.

Voor de JavaScript, gebruik een thema-ondersteund scriptgebied, een child theme, of een betrouwbare code-injectie-extensie die JavaScript correct afhandelt.

Sommige editors en beveiligingsconfiguraties filteren <script>-elementen. Ga niet ervan uit dat JavaScript direct in een contentblok geplakt zal uitvoeren.

Joomla

In Joomla kan een Custom module of een editor die geschikte HTML-markup toestaat, de dialoog bevatten.

Voeg de CSS toe aan de custom stylesheet van je sjabloon, zoals user.css in een Cassiopeia-gebaseerde site.

Plaats JavaScript in de ondersteunde custom script-locatie van de sjabloon of via een geschikte extensie.

Afhankelijk van de geconfigureerde editor en tekstfilters, kan Joomla bepaalde elementen of attributen verwijderen wanneer content wordt opgeslagen.

Als je markup verdwijnt, inspecteer de editor- en filterconfiguratie in plaats van herhaaldelijk dezelfde code te plakken.

Page builders

Hetzelfde principe geldt voor visuele page builders: gebruik hun HTML-, CSS- en JavaScript-integratiemogelijkheden.

Voor dynamisch geladen content, initialiseer event listeners pas nadat de relevante elementen bestaan.

Als een pagina meerdere dialogen bevat, geef er dan aan elk een unieke ID.

11. Test je modal voor publicatie

Een dialoog die er correct uitziet op desktop, kan nog steeds bruikbaarheidsproblemen hebben.

Test het met een muis, toetsenbord en mobiel apparaat.

Test Verwacht resultaat
Openingsknop klikken Dialoog verschijnt
Tab indrukken Focus blijft binnen de controls van de modal
Shift + Tab indrukken Omgekeerde toetsenbordnavigatie werkt
Escape indrukken Dialoog sluit wanneer toegestaan
Op Close of Annuleren klikken Dialoog sluit
Dialoog sluiten Focus keert adequaat terug
Op mobiel openen Content blijft leesbaar en scrollbaar
Ongeldig formulier versturen Validatiefoutmelding is zichtbaar
Geldig formulier versturen Applicatie verwerkt de data correct
Een schermlezer gebruiken Dialoog heeft een begrijpbare naam

De WCAG-techniek H102 van de W3C biedt nuttige richtlijnen voor het valideren van native modaal gedrag.

12. Wanneer moet je een dialoog gebruiken in plaats van een plugin?

Een native dialoog is met name geschikt voor kleine, gefocuste interacties: bevestigingen, informatiepanelen en eenvoudige formulieren.

Voor complexere behoeften, zoals multi-stap wizards, geavanceerde galerijen, of dialogen die diep geïntegreerd zijn met een CMS-workflow, kan een speciale component of extensie nog steeds de beter onderhoudbare optie zijn.

Het voordeel van de native aanpak is dat het een solide, door de browser ondersteunde basis biedt zonder nog een JavaScript-afhankelijkheid te introduceren.

Het vermindert ook de hoeveelheid aangepast focus- en toetsenbordbeheer dat je zelf hoeft te implementeren.

Conclusie: begin met de ingebouwde mogelijkheden van de browser

Een modale dialoog hoeft geen grote JavaScript-bibliotheek te vereisen.

Het native HTML <dialog>-element biedt een effectieve basis voor toegankelijke popups, bevestigingsberichten en formulieren.

Met showModal(), close(), method="dialog" en een paar CSS-regels kun je een interface maken die werkt in moderne browsers terwijl je profiteert van ingebouwd focus- en toetsenbordgedrag.

Voor WordPress, Joomla en custom PHP-websites kan dit een efficiënte alternatief zijn voor het installeren van nog een plugin voor een relatief eenvoudige interactie.

De sleutel is om het native gedrag correct te gebruiken, duidelijke controls te voorzien en het resultaat te testen met echte toetsenbord- en mobiele interacties.

Officiële en technische referenties