HTML schrijven is oké maar wat als er iets fout gaat en je kan er maar niet achter komen waar de fout in je code zit? In dit artikel zullen we je kennis laten maken met een aantal instrumenten die je kunnen helpen om de fouten in je HTML op te sporen en te herstellen.

Vereisten: Basiskennis HTML zoals die is aangeboden in Beginnen met HTML, HTML tekst: basisprincipes en Hyperlinks maken.
Objective: Je verwerft basiskennis over het gebruik van debugging-instrumenten waarmee je de bron van problemen in HTML kan vinden.

Van debuggen hoef je niet bang te zijn

Als je de één of andere code zit te schrijven, is alles meestal dik in orde, tot het gevreesde moment waarop een fout zich voordoet. Je hebt dus iets verkeerd gedaan zodat je code niet werkt — of hij doet het helemaal niet of toch niet helemaal zoals jij dat wil. Hieronder vind je bijvoorbeeld een foutmelding die verschijnt wanneer men een simpel programma probeert te compileren in de Rust-taal.

A console window showing the result of trying to compile a rust program with a missing quote around a string in a print statement. The error message reported is error: unterminated double quote string.Hier is de foutmelding vrij gemakkelijk te begrijpen — "unterminated double quote string" (niet afgesloten dubbele aanhalingstekens string). Als je de lijst bekijkt, zie je waarschijnlijk hoe println!(Hello, world!") een dubbel aanhalingsteken mist. Foutmeldingen kunnen echter snel een stuk ingewikkelder worden en minder gemakkelijk om te interpreteren omdat programma's groter worden en zelfs simpele gevallen kunnen nogal intimiderend overkomen bij iemand die niets over Rust weet. 

Toch hoeft debuggen niet angstaanjagend te zijn. De sleutel tot een comfortabel gevoel bij het schrijven van code, is je vertrouwdheid met de taal en de instrumenten die hij aanbiedt.

HTML en debuggen

HTML is niet zo complex en makkelijker te begrijpen als Rust. HTML wordt niet eerst  in een andere vorm gecompileerd voor de browser die ontleedt en het result toont. HTML wordt geïnterpreteerd, niet  gecompileerd en HTML's element syntaxis is een stuk makkelijker te begrijpen dan een "echte programmeertaal" zoals Rust, JavaScript of Python. De manier waarop browsers HTML ontleden (i.e. parsen in het Engels) is veel toleranter dan de wijze waarop programmeertalen worden uitgevoerd, wat zowel goed als slecht is.

Tolerante code

Dus wat bedoelen we met tolerant? Wel, als je iets fout doet in je code, zal je een aantal fouten tegenkomen. De twee voornaamste zijn :

  • Syntactische fouten: Deze zijn spelfouten in je code die ervoor zorgen dat je programma niet wordt uitgevoerd, zoals de Rust fout die we hierboven hebben getoond. Deze kan je meestal makkelijk herstellen als je vertrouwd bent met de syntaxis van de taal en als je weet wat de foutmeldingen betekenen.
  • Logische fouten: Dit zijn fouten waarbij de syntaxis correct is maar de code is niet wat je eigenlijk wil, wat inhoudt dat het programma niet correct wordt uitgevoerd. Deze zijn vaak veel moeilijker te repareren dan syntactische fouten omdat er geen foutmelding is die je naar de bron van de fout leidt.

HTML zelf lijdt niet onder syntactische fouten omdat browsers HTML op een tolerante manier ontleden (d.w.z. parsen). Dit houdt in dat de pagina zal worden weergegeven zelfs als er syntactische fouten in zitten. Browsers hebben ingebouwde regels die zeggen hoe ze incorrect geschreven opmaak moeten interpreteren zodat je pagina toch wordt uitgevoerd al ziet die er misschien niet uit zoals je verwacht. Dit kan naturlijk nog altijd een groot probleem zijn!

Opmerking: HTML wordt tolerant geparst. Toen het web namelijk werd gecreëerd, werd er beslist dat het belangrijker was dat mensen hun inhoud konden publiceren dan er zeker van te zijn dat de syntaxis volledig correct was.  Het web zou waarschijnlijk niet zo populair zijn, als het vanaf het begin stricter was geweest.

Actief leren: De studie van tolerante code

Het is tijd om de tolerante aard van HTML-code te bestuderen

  1. Eerst download je ons debug-example demo en sla je die locaal op. Deze demo is opzettelijk met fouten erin geschreven die we kunnen onderzoeken (we zeggen dat de HTML-opmaak slecht is gevormd in tegenstelling tot  goed gevormd).
  2. Vervolgens open je de demo in een browser. Die zal er ongeveer zo uitzien:A simple HTML document with a title of HTML debugging examples, and some information about common HTML errors, such as unclosed elements, badly nested elements, and unclosed attributes.
  3. Dat ziet er niet echt geweldig uit. We gaan daarom de broncode bekijken en zien of we erachter kunnen komen waarom dat zo is (enkel de inhoud van de body wordt getoond):
    <h1>HTML debugging voorbeelden</h1>
    
    <p>Wat veroorzaakt er fouten in HTML?
    
    <ul>
      <li>Elementen die niet zijn afgesloten : als een element <strong>niet correct word afgesloten,
          dan kan zijn effect zich uitbreiden naar gebieden die daarvoor niet zijn bedoeld
    
      <li>Slecht geneste elementen: Het is ook belangrijk om je elementen correct te nesten
          zodat je code zich correct gedraagt. <strong>strong <em>sterk benadrukt?</strong>
          wat is dat?</em>
    
      <li>Attributen die niet zijn gesloten : Nog een vaak voorkomende bron van problemen met HTML. Laat ons
          daarvoor een voorbeeld bekijken: <a href="https://www.mozilla.org/>link naar de homepage van
          Mozilla</a>
    </ul>
  4. We gaan deze problemen nu één voor één bekijken:
    • De paragraaf en lijstonderdeel-elementen hebben geen eindtags. Als je naar de afbeelding hierboven kijken, zie je dat dit de weergegeven opmaak niet zo erg beïnvloedt want het is makkelijk om te zien waar een element zou moeten stoppen en een ander beginnen.
    • Het eerste <strong> element heeft geen eindtag. Dit is iets problematischer want het is niet zo gemakkelijk om te weten waar het element zou moeten eindigen. In feite is de rest van de tekst sterk benadrukt. 
    • Een van de secties is slecht genest: <strong>strong <em>sterk benadrukt emphasised?</strong> wat is dat?</em>. Het is niet gemakkelijk om te zeggen hoe dit is geïnterpreteerd door het vorige probleem.
    • De href-attribuutwaarde mist een dubbel aanhalingsteken. Dat heeft blijkbaar het grootste probleem veroorzaakt  — de link is gewoon niet weergegeven.
  5. We kunnen nu ook de opmaak bekijken die de browser heeft gegenereerd in plaats van de opmaak in de broncode. Om dat te doen, kunnen we de hulpprogramma's voor ontwikkelaars bekijken (de browser developer tools in het Engels). Als je niet vertrouwd bent met het gebruik van deze programma's kan je er meer over leren. Neem een paar minuten de tijd en bekijk Discover browser developer tools.
  6. Met de DOM Inspecteur kan je zien hoe de weergegeven opmaak eruit ziet: The HTML inspector in Firefox, with our example's paragraph highlighted, showing the text "What causes errors in HTML?" Here you can see that the paragraph element has been closed by the browser.
  7. Met de DOM inspecteur kunnen we onze code in detail onderzoeken en zien hoe de browser heeft geprobeerd om onze HTML-fouten te herstellen. We hebben dat in Firefox gedaan; andere moderne browsers zouden hetzelfde resultaat moeten produceren:
    • De paragrafen en de lijstonderdelen hebben eindtags gekregen.
    • Het is niet duidelijk waar het eerste <strong>-element zou moeten worden gesloten, dus heeft de browser elke apart tekstblok in zijn eigen strong-tag ingesloten, helemaal tot aan de onderkant van het document!
    • De incorrect geneste element zijn door de browser op deze manier hersteld:
      <strong>sterk
        <em>sterk benadrukt</em>
      </strong>
      <em> wat is dat?</em>
    • De link met het ontbrekende dubbele aanhalingsteken is helemaal verwijderd. Het laatste lijstonderdeel ziet er zo uit:
      <li>
        <strong>Attributen die niet zijn afgesloten: Een andere vaak voorkomende bron van HTML-problemen.
        Laat ons daarvoor een voorbeeld bekijken: </strong>
      </li>

HTML validatie

Door het voorbeeld hierboven begrijp je dat je er echt zeker van wil zijn dat je HTML goed gevormd is. Maar hoe doe je dat? In een klein voorbeeld zoals dat hierboven, is het gemakkelijk om de fouten te vinden, maar wat moet met je een enorm en complex HTML document? 

De beste strategie is om je HTML-pagina eerst door de Markup Validation Service (Opmaak Validatie Dienst) te laten beoordelen. Deze dienst is gecreëerd door de W3C en word er ook door onderhouden. De organisatie zorgt voor de specificaties die HTML, CSS en andere webtechnologieën definiëren. De webpagina aanvaardt je HTML als invoer, verwerkt die en geeft je dan een verslag waarin staat wat er mis is met je HTML.

The HTML validator homepage

Om de HTML in te voeren de je wil laten valideren, kan je een webadres opgeven, een HTML-bestand uploaden of de HTML-code direct invoeren.

Actief leren: Een HTML-document valideren

We gaan dit met ons sample document uitproberen.

  1. Eerst laad je de Markup Validation Service in een tabblad van een browser, als je dat nog niet hebt gedaan.
  2. Klik op Validate by Direct Input.
  3. Kopiëer de volledige code van het sample document (dus niet enkel de body) en plak die in het tekstinvoerveld.
  4. Klik op de Check knop.

Nu zou je een lijst met fouten en andere informatie moeten zien.

A list of of HTML validation results from the W3C markup validation service

De interpretatie van de foutmelding

Al zijn de foutmeldingen meestal een hulp, soms zijn ze dat toch niet helemaal maar met een beetje oefening kan je erachter komen hoe je ze moet interpreteren om je code te repareren. We gaan ze nu één voor één bekijken en hun betekenis ontcijferen. Je zal merken dat elke boodschap een regel en kolomnummer krijgt zodat je kan zien waar de fout zich bevindt.

  • "End tag li implied, but there were open elements" (2 instances): (eindtag li geïmpliceerd maar er waren open elementen (twee gevallen)). Deze boodschappen duiden aan dat een element nog open is en gesloten moet worden. De eintag is geïmpliceerd maar staat er niet echt. De regel/kolom informatie wijst naar de eerste regel na de regel waar de eindtag eigenlijk zou moeten zijn, maar deze aanwijzing is goed genoeg om te zien wat er fout is.
  • "Unclosed element strong" (niet gesloten element strong) : Dit is echt makkelijk te begrijpen — een <strong>-element is niet afgesloten en de lijn/kolom informatie wijst recht naar de plaats van het element.
  • "End tag strong violates nesting rules" (eind tag strong schendt regels voor geneste elementen): Dit verwijst naar de incorrect geneste elementen en de regel/kolom informatie wijst naar waar die zitten.
  • "End of file reached when inside an attribute value. Ignoring tag" (einde van het bestand is bereikt binnen een attribuutwaarde): Deze is vrij cryptisch; hij verwijst naar het feit dat er ergens een attribuutwaarde zit die niet correct werd gevormd, misschien dicht bij het einde van het bestand want het einde van het bestand verschijnt binnen de attribuutwaarde.  Het feit dat de browser de link niet weergeeft, is een goede aanwijzing die ons vertelt welk element de fout bevat.
  • "End of file seen and there were open elements" (einde van het bestand gezien en er waren open elementen) : Dit is een beetje dubbelzinnig, maar in feite verwijst de foutmelding naar het feit dat er open elementen zijn die moeten worden gesloten. De regelnummers wijzen naar de laaste regels van het bestand en deze foutmelding verschijnt samen met een regel code die een voorbeeld van een open element aanduidt:
    example: <a href="https://www.mozilla.org/>link naar de startpagina van Mozilla homepage</a> ↩ </ul>↩ </body>↩</html>

    Opmerking: Een attribuut dat het aanhalingsteken mist dat de attribuutwaarde afsluit, kan resulteren in een open element omdat de rest van het document wordt geïnterpreteerd als de inhoud van het attribuut.

  • "Unclosed element ul" (niet afgesloten element ul): Dit is niet erg behulpzaam omdat het <ul>-element wel degelijk correct is afgesloten. Dese fout verschijnt omdat het <a>-element niet is afgesloten en dat komt door het ontbrekende aanhalingsteken op het einde van de attribuutwaarde.

Als je niet de betekenis van elke foutmelding kan uitdokteren, hoef je je daarover niet te veel zorgen te maken — het is een goed idee om niet alle fouten tegelijk te herstellen. Bewerk er een paar en probeer dan opnieuw je HTML te valideren en kijk welke fouten er nog over schieten. Soms is het genoeg om één fout weg te werken. De rest van de fouten verdwijnt dan vanzelf omdat meerdere fouten door één enkel probleem veroorzaakt kunnen worden. Het probleem creëert dan een domino-effect.

Als alle fouten hersteld zijn, zal je de volgende tekst met groene achtergrond in je uitvoer zien. Dit is de vertaling: het document is gevalideerd volgens de gespecifiëerde schema's en volgens bijkomende beperkingen die door de validator zijn gecontroleerd.

Banner that reads "The document validates according to the specified schema(s) and to additional constraints checked by the validator."

Samenvating

En dat is het dus, een inleiding op het debuggen van HTML. Je zou nu een paar nuttige vaardigheden onder de knie moeten hebben. Je zal er later in je carrière op kunnen rekenen wanneer je CSS, Javascript en andere soorten code gaat debuggen. Dit betekent ook het einde van onze introductie op HTML — Je kan nu verder gaan door jezelf te testen met onze evaluaties: de link naar de eerste vind je hieronder.

Documentlabels en -medewerkers

 Aan deze pagina hebben bijgedragen: Tonnes, mientje
 Laatst bijgewerkt door: Tonnes,