Programmeerfouten zijn onvermijdelijk. Vroeg of laat zal uw toepassing onverwacht gedrag vertonen. Net als elke andere programmeertaal roept JavaScript fouten op wanneer er iets misgaat in uw code.
Fouten verstoren de normale stroom van een applicatie. Maar ze helpen je applicatie ook te beschermen tegen onvoorspelbaar gedrag. Weten hoe je op de juiste manier omgaat met fouten is cruciaal.
Waarom is foutafhandeling belangrijk?
Foutafhandeling draagt bij aan een verbeterde gebruikerservaring. U kunt de standaard en soms uitgebreide fouten van JavaScript vervangen door meer voor mensen leesbare foutmeldingen van uzelf. U kunt de oorzaken van sommige fouten gracieus aanpakken en uw programma draaiende houden in plaats van het te laten stoppen.
Foutafhandeling is ook nuttig tijdens de ontwikkeling. Je kunt een runtime-fout opvangen en er iets nuttigs mee doen, zoals loggen in de browserconsole. Dit is eleganter dan de fout die een crash veroorzaakt en niet weet waar of waarom de fout is opgetreden.
Structuur van ingebouwde JavaScript-fouten
JavaScript-fouten zijn objecten met drie eigenschappen:
- naam: Dit is de naam van de fout. Een ontbrekende variabelenaam veroorzaakt bijvoorbeeld een fout met de naam SyntaxError.
- bericht: Dit is de hoofdtekst van het bericht en legt de fout tekstueel uit.
- oorzaak: u kunt deze eigenschap met aangepaste fouten gebruiken om de aanroepstack bij te houden.
Veelvoorkomende soorten fouten in JavaScript
Hier zijn enkele veelvoorkomende fouten in JavaScript.
Syntax error
Syntaxisfouten kunnen optreden wanneer JavaScript uw code probeert te interpreteren. Er wordt een fout gegenereerd als uw code niet overeenkomt met de juiste syntaxis. Enkele veelvoorkomende fouten die syntaxisfouten kunnen veroorzaken, zijn:
- Namen van variabelen ontbreken.
- Ontbrekende "}" na een functie.
- Ontbrekende ")" na een voorwaarde.
ReferentieFout:
Referentiefouten treden op wanneer een programma probeert om verwijzen naar een variabele die niet beschikbaar of buiten bereik is.
Typefout
JavaScript kan een typefout genereren wanneer het geen bewerking kan uitvoeren omdat het type dat het verwacht anders is dan het type dat het ontvangt.
URIEfout
Deze fout treedt op als u een algemene URI-afhandelingsfunctie, zoals decodeURIComponent() — onjuist gebruikt. Als gevolg hiervan mislukt de codering of decodering.
Totale fout
Deze fout wordt gebruikt om meerdere fouten weer te geven die in één zijn verpakt. Gebruik het als je veel fouten tegelijk wilt gooien. Promise.any() kan bijvoorbeeld een AggregateError() genereren wanneer alle beloften die eraan zijn doorgegeven, worden afgewezen.
Interne fout
Er wordt een InternalError gegenereerd wanneer er een fout optreedt in de JavaScript-engine.
Bereikfout
Sommige functies bepalen het waardenbereik dat u als argumenten kunt doorgeven. Deze fout treedt op wanneer u een waarde probeert door te geven die niet in dat bereik is opgenomen.
Foutafhandeling met de Try... Vangblok
JavaScript biedt ingebouwde functionaliteit voor het afhandelen van uitzonderingen met de probeer…vang…eindelijk blok. Het stelt je ook in staat om je eigen fouten op te heffen met behulp van de gooien exploitant.
U kunt een try...catch-blok gebruiken om fouten af te handelen die tijdens runtime optreden. U schrijft geldige code die u verwacht correct uit te voeren in het try-blok. In het catch-blok kunt u foutafhandelingscode schrijven.
proberen {
// Geldige Javascript-code
} vangst (fout) {
// Afhandelingsfout
} Tenslotte {
// Uitgevoerd zelfs als er een fout optreedt
}
Het catch-blok wordt genegeerd als de code in het try-blok geen fouten oplevert. Als het een fout oplevert, springt de uitvoering naar het catch-blok. Code in het laatste blok wordt uitgevoerd, ongeacht of er een fout optreedt of niet. Dit blok is niet verplicht, dus laat het weg als je het niet nodig hebt.
De code die u in het try-blok opneemt, moet geldig zijn. Als dit niet het geval is, geeft JavaScript een parseerfout.
Laten we een praktisch voorbeeld bekijken:
proberen {
troosten.log (tekst)
} vangst (fout) {
troosten.log(fout.bericht)
} Tenslotte {
console.log("Zal hoe dan ook worden uitgevoerd")
}
Dit programma probeert de waarde van de tekstvariabele te loggen. Aangezien die variabele niet is gedefinieerd, zal het programma een fout genereren. Deze fout wordt afgedrukt op de console in het catch-blok. Het laatste blok wordt vervolgens uitgevoerd en drukt een eigen bericht af.
ReferentieFout:: tekst is niet gedefinieerd
Zal hoe dan ook worden uitgevoerd
In situaties waarin u uw eigen fout moet melden, gebruikt u de gooien exploitant.
Beschouw dit voorbeeld dat een fout genereert als de gegevens vals zijn:
const data = getData()proberen {
als (!gegevens) {
gooien "Geen gegevens"
}
troosten.log (gegevens)
// doorgaan
} vangst(fout) {
troosten.log (fout) // "Geen gegevens"
}
In dit voorbeeld roept het programma de functie getData() aan en wijst het resultaat toe aan de gegevensvariabele. In het try-blok genereert het blok een aangepaste fout als de gegevens leeg zijn. Het catch-blok vangt die fout op en logt deze in de console.
Werpfouten zijn zeer gunstig tijdens de ontwikkeling. U kunt het aangepaste foutbericht gebruiken om te begrijpen waarom uw toepassing niet werkt zoals verwacht.
Zoals dit voorbeeld laat zien, kunt u een tekenreeks gebruiken voor het foutobject. Je kunt eigenlijk elke JavaScript-expressie als een fout gooien. Gebruik echter omwille van de consistentie met ingebouwde fouten een JavaScript-object dat een naam en bericht bevat.
gooien {
naam: "Foutnaam",
bericht: "Foutmelding"
}
U kunt ook de ingebouwde constructors van JavaScript gebruiken bij het genereren van fouten. Deze constructors omvatten onder andere Error, SyntaxError en ReferenceError.
Gebruik deze code om een fout te genereren met behulp van de Error-constructor:
gooiennieuweFout("Geen gegevens")
U kunt nu verwijzen naar de naam en het bericht.
troosten.log (fout.naam) // Fout
troosten.log (fout.bericht) // Geen gegevens
Het JavaScript-foutobject uitbreiden
Een aangepaste foutklasse is handig bij het afhandelen van fouten die niet overeenkomen met de objecten die al door JavaScript worden geleverd. U wilt bijvoorbeeld een gegevensvalidatiefout isoleren als een specifiek type met de naam ValidationError.
U kunt een JavaScript ES2015-klasse om een aangepaste foutklasse te maken.
klasValidatiefoutbreidt zich uitFout{
constructeur(bericht) {
super(bericht);
deze.naam = "Validatiefout";
}
}
Gooi een fout met de klasse ValidationError als volgt:
gooiennieuwe ValidationError("Uw foutmelding")
De gegenereerde fout is een object met de naam en berichtwaarden.
{
naam: "Validatiefout",
bericht: "Uw foutmelding"
}
Fouten zijn er om te helpen
Foutafhandeling is een fundamenteel onderdeel van programmeren, welke taal u ook gebruikt. JavaScript heeft geweldige ondersteuning voor het opheffen en onderscheppen van fouten in de stijl van uitzonderingen. Het heeft ook verschillende ingebouwde fouttypen die u voor uw eigen gevallen kunt behandelen en gebruiken.
Sommige fouten, zoals syntaxisfouten, kunnen onopgemerkt blijven wanneer u JavaScript in "slordige modus" schrijft. Door de strikte modus te gebruiken, kan JavaScript fouten opvangen die het anders zou hebben genegeerd.