Met de try...catch-constructie kunt u een codeblok op fouten controleren.
JavaScript - FoutopsporingTijdens het surfen op internet zijn we allemaal een JavaScript-waarschuwingsvenster tegengekomen dat ons vertelde dat er een runtime-fout is opgetreden en dat werd gevraagd: "Wilt u debuggen?" Een foutmelding als deze kan nuttig zijn voor ontwikkelaars, maar niet voor gebruikers. Wanneer gebruikers fouten zien, hebben ze de neiging de webpagina te verlaten.
In deze tutorial leert u hoe u JavaScript-foutmeldingen kunt onderscheppen en afhandelen, zodat u uw kijkers niet kwijtraakt.
probeer... vangen constructieMet de try...catch-constructie kunt u een codeblok op fouten controleren.
Het try-blok bevat de code die wordt uitgevoerd en gecontroleerd, en het catch-blok bevat de code die wordt uitgevoerd als er fouten optreden.| Syntaxis { poging } //Voer hier wat code uit { vangen (err) } |
// Foutafhandeling hier
Houd er rekening mee dat try ... catch in kleine letters (kleine letters) wordt geschreven. Het gebruik van hoofdletters genereert een JavaScript-fout!Voorbeelden
Het onderstaande voorbeeld zou een pop-up "Welkom gast!" moeten weergeven. wanneer de muisknop wordt ingedrukt. Er zit echter een typefout in de functie message(). alert() wordt afgedrukt als adddlert(). Er treedt een JavaScript-fout op. Het catch-blok vangt de fout op en voert aanvullende code uit om deze af te handelen. De code geeft een aangepast foutbericht weer waarin de gebruiker wordt geïnformeerd wat er is gebeurd:
In het volgende voorbeeld wordt een bevestigingsvenster gebruikt om een aangepast bericht weer te geven waarin gebruikers worden verteld dat ze op OK kunnen klikken om door te gaan of op Annuleren om naar de hoofdpagina te gaan. Als de methode false retourneert, heeft de gebruiker op Annuleren geklikt en wordt de gebruiker door de code omgeleid. Als de methode true retourneert, doet de code niets:
|
document.locatie.href="http://site/";
Soms treden er bij het uitvoeren van een programma fouten op die moeilijk te voorzien of te anticiperen zijn, en soms zelfs onmogelijk. Wanneer u bijvoorbeeld een bestand over het netwerk overbrengt, kan de netwerkverbinding onverwachts wegvallen. dergelijke situaties worden uitzonderingen genoemd. De C#-taal biedt ontwikkelaars mogelijkheden om met dergelijke situaties om te gaan. De try...catch...finally-constructie in C# is hiervoor ontworpen.
Probeer ( ) vang ( ) eindelijk ( )
Wanneer u een try...catch..finally-blok gebruikt, worden alle instructies in het try-blok eerst uitgevoerd. Als er in dit blok geen uitzonderingen voorkomen, wordt na de uitvoering ervan het laatste blok uitgevoerd. En dan proberen..vangen..voltooit eindelijk zijn werk.
Als zich plotseling een uitzondering voordoet in een try-blok, stopt de normale uitvoeringsopdracht en begint de CLR te zoeken naar een catch-blok dat de uitzondering kan afhandelen. Als het juiste catch-blok wordt gevonden, wordt het uitgevoerd en nadat het is voltooid, wordt het definitieve blok uitgevoerd.
Als het vereiste catch-blok niet wordt gevonden, beëindigt het programma de uitvoering ervan op abnormale wijze wanneer er een uitzondering optreedt.
Beschouw het volgende voorbeeld:
Klasse Programma ( static void Main(string args) ( int x = 5; int y = x / 0; Console.WriteLine($"Resultaat: (y)"); Console.WriteLine("Einde programma"); Console.Lezen ();
In dit geval wordt het getal gedeeld door 0, wat een uitzondering zal genereren. En wanneer we de applicatie in de foutopsporingsmodus starten, zien we een venster in Visual Studio dat ons informeert over de uitzondering:
In dit venster zien we dat er een uitzondering is opgetreden, die van het type System.DivideByZeroException is, dat wil zeggen een poging om door nul te delen. Met behulp van het item Details bekijken kunt u meer gedetailleerde informatie over de uitzondering bekijken.
En in dit geval hoeven we alleen nog maar het programma te voltooien.
Om een dergelijke programmacrash te voorkomen, moet u de try...catch...finally-constructie gebruiken om uitzonderingen af te handelen. Laten we het voorbeeld dus als volgt herschrijven:
Class Program ( static void Main(string args) ( try ( int x = 5; int y = x / 0; Console.WriteLine($"Resultaat: (y)"); ) catch ( Console.WriteLine("Er heeft zich een uitzondering voorgedaan ! "); ) eindelijk ( Console.WriteLine("Eindelijk blokkeren"); ) Console.WriteLine("Einde van het programma"); Console.Read(); ) )
In dit geval hebben we opnieuw een uitzondering in het try-blok, omdat we proberen door nul te delen. En het bereiken van de lijn
Int-y = x / 0;
de uitvoering van het programma stopt. De CLR zal het catch-blok vinden en de controle naar dat blok overdragen.
Na het catch-blok wordt het final-blok uitgevoerd.
Er heeft zich een uitzondering voorgedaan! Blokkeer tenslotte Einde van het programma
Het programma zal dus nog steeds geen deling door nul uitvoeren en daarom het resultaat van deze deling niet afdrukken, maar nu zal het niet crashen en zal de uitzondering worden afgehandeld in het catch-blok.
Opgemerkt moet worden dat deze constructie een try-blok vereist. Gegeven een catch-blok, kunnen we het final-blok weglaten:
Try ( int x = 5; int y = x / 0; Console.WriteLine($"Resultaat: (y)"); ) catch ( Console.WriteLine("Er is een uitzondering opgetreden!"); )
Omgekeerd, als we een definitief blok hebben, kunnen we het catch-blok weglaten en de uitzondering niet afhandelen:
Probeer ( int x = 5; int y = x / 0; Console.WriteLine($"Resultaat: (y)"); ) eindelijk ( Console.WriteLine("Eindelijk blokkeren"); )
Hoewel een dergelijke constructie volkomen correct is vanuit het oogpunt van de C#-syntaxis, zal de uitzondering echter niet worden afgehandeld, omdat de CLR het vereiste catch-blok niet kan vinden, en zal het programma crashen.
Afhandeling van uitzonderingen en voorwaardelijke bepalingenDe ontwikkelaar kan een aantal uitzonderlijke situaties voorzien. Stel dat het programma bijvoorbeeld bestaat uit het invoeren van een getal en het uitvoeren van het kwadraat ervan:
Statische leegte Main(string args) ( Console.WriteLine("Voer een getal in"); int x = Int32.Parse(Console.ReadLine()); x *= x; Console.WriteLine("Vierkant getal: " + x) ; Console.Lezen();
Als de gebruiker geen getal invoert, maar een tekenreeks of andere tekens, genereert het programma een foutmelding. Aan de ene kant is dit precies de situatie waarin je een try..catch-blok kunt gebruiken om een mogelijke fout af te handelen. Het zou echter veel optimaaler zijn om de geldigheid van de conversie te controleren:
Statische leegte Main(string args) ( Console.WriteLine("Voer een getal in"); int x; stringinvoer = Console.ReadLine(); if (Int32.TryParse(invoer, uit x)) ( x *= x; Console WriteLine("Vierkant getal: " + x); ( Console.WriteLine("Ongeldige invoer"); ) Console.Read();
De methode Int32.TryParse() retourneert true als de conversie kan worden uitgevoerd, en false als dit niet mogelijk is. Als de conversie geldig is, bevat de variabele x het ingevoerde getal. Dus zonder try...catch te gebruiken, kunt u een mogelijke uitzondering afhandelen.
Vanuit prestatieoogpunt is het gebruik van try..catch-blokken duurder dan het gebruik van conditionals. Daarom is het, indien mogelijk, in plaats van try..catch beter om voorwaardelijke constructies te gebruiken om te controleren op uitzonderlijke situaties.
In de T-SQL-taal is het, net als in veel andere programmeertalen, mogelijk om fouten op te sporen en te onderscheppen; vandaag zullen we kijken naar de TRY CATCH-constructie, met behulp waarvan we uitzonderlijke situaties kunnen aanpakken, d.w.z. onverwachte fouten.
Zoals u al heeft begrepen, hebben we het niet over syntaxisfouten, waarover de SQL-server ons al vóór de uitvoering van de SQL-instructies zelf informeert, maar over fouten die onder bepaalde omstandigheden in een bepaald stuk code kunnen optreden.
Het eenvoudigste voorbeeld is delen door nul. Zoals u weet, kunt u niet door nul delen, maar dit getal kan nog steeds verschijnen bij delingsbewerkingen. Er zijn ook andere fouten die kunnen optreden bij bewerkingen op niet-standaard, onjuiste gegevens, hoewel dezelfde bewerkingen op normale gegevens zonder fouten worden uitgevoerd.
Daarom is er in de Transact-SQL-taal een speciale constructie TRY...CATCH, deze verscheen in de 2005-versie van de SQL-server en wordt gebruikt voor foutafhandeling. Als iemand bekend is met andere programmeertalen, dan is deze constructie u waarschijnlijk bekend, aangezien deze in veel programmeertalen wordt gebruikt.
Opmerking! Voor een meer gedetailleerde studie van de T-SQL-taal raad ik beginnende programmeurs aan het boek The T-SQL Programmer's Path te lezen. Transact-SQL-taaltutorial.
PROBEER CATCH-constructie in T-SQLTRY CATCH is een Transact-SQL-constructie voor foutafhandeling. Alles wat u op fouten wilt controleren, d.w.z. In het TRY-blok plaats je code waarin fouten kunnen voorkomen. Het begin van dit blok wordt aangegeven door de BEGIN TRY-instructie, en het einde van het blok dienovereenkomstig door END TRY.
Wat u ook wilt doen als er een fout optreedt, d.w.z. De instructies die moeten worden uitgevoerd als er een fout optreedt in het TRY-blok, plaatst u in het CATCH-blok, het begin ervan wordt aangegeven met BEGIN CATCH en het einde is END CATCH. Als er geen fouten zijn opgetreden in het TRY-blok, wordt het CATCH-blok overgeslagen en worden de daaropvolgende instructies uitgevoerd. Als er fouten optreden, worden de instructies in het CATCH-blok uitgevoerd en vervolgens worden de instructies die volgen op dit blok uitgevoerd. Met andere woorden: alle instructies die volgen op het CATCH-blok zullen worden uitgevoerd, tenzij we natuurlijk de uitvoering van de opdracht met geweld hebben beëindigd. pakket in het CATCH-blok.
Het CATCH-blok zelf verzendt geen informatie over gedetecteerde fouten naar de oproepende applicatie als u bijvoorbeeld het nummer of de beschrijving van de fout wilt achterhalen, dan kunt u hiervoor de instructies SELECT, RAISERROR of PRINT gebruiken in de opdracht; CATCH-blok.
Belangrijke punten over de TRY CATCH-constructie in T-SQL- Het CATCH-blok moet onmiddellijk na het TRY-blok komen; het plaatsen van instructies tussen deze blokken is niet toegestaan;
- TRY CATCH vangt alle fouten op met een ernstcode groter dan 10 die de databaseverbindingen niet sluiten;
- In de TRY...CATCH-constructie kunt u slechts één pakket en één blok SQL-instructies gebruiken;
- De TRY...CATCH-constructie kan worden genest, in een TRY-blok kan er bijvoorbeeld een andere TRY...CATCH-constructie zijn, of in een CATCH-blok kunt u een foutafhandelaar schrijven voor het geval er fouten optreden in het CATCH-blok zelf;
- De GOTO-instructie kan niet worden gebruikt om TRY- of CATCH-blokken in te voeren, maar kan alleen worden gebruikt om naar labels binnen TRY- of CATCH-blokken te springen;
- Het verwerken van TRY...CATCH-fouten in door de gebruiker gedefinieerde functies wordt niet ondersteund;
- De constructie TRY...CATCH verwerkt de volgende fouten niet: waarschuwings- en informatieberichten met een ernstniveau van 10 of lager, door de client veroorzaakte verbindingsbeëindiging en beëindiging door de beheerder met behulp van een KILL-instructie.
Om informatie te verkrijgen over fouten die de uitvoering van het CATCH-blok hebben veroorzaakt, kunt u de volgende functies gebruiken:
- ERROR_NUMBER() – retourneert het foutnummer;
- ERROR_MESSAGE() - retourneert een beschrijving van de fout;
- ERROR_STATE() - retourneert de foutstatuscode;
- ERROR_SEVERITY() - retourneert de ernst van de fout;
- ERROR_PROCEDURE() - retourneert de naam van de opgeslagen procedure of trigger waarin de fout is opgetreden;
- ERROR_LINE() - Retourneert het regelnummer van de instructie die de fout heeft veroorzaakt.
Als deze functies buiten een CATCH-blok worden aangeroepen, retourneren ze NULL.
Een voorbeeld van het gebruik van de TRY...CATCH-constructie voor foutafhandelingOm te demonstreren hoe de TRY...CATCH-constructie werkt, gaan we een eenvoudige SQL-instructie schrijven waarin we opzettelijk een fout maken, zoals een deling door nul.
Begin van het foutafhandelingsblok BEGIN TRY --Instructies waarin fouten kunnen optreden DECLARE @TestVar1 INT = 10, @TestVar2 INT = 0, @Rez INT SET @Rez = @TestVar1 / @TestVar2 END TRY --Begin van CATCH-blok BEGIN CATCH - -Acties die worden uitgevoerd als er een fout optreedt SELECT ERROR_NUMBER() AS [Foutnummer], ERROR_MESSAGE() AS [Foutbeschrijving] SET @Rez = 0 END CATCH SELECT @Rez AS [Resultaat]
In dit geval geven we het foutnummer en de beschrijving weer met behulp van de functies ERROR_NUMBER() en ERROR_MESSAGE(), en wijzen we ook de waarde 0 toe aan de uiteindelijke resultaatvariabele. Zoals we zien, worden de instructies na het CATCH-blok nog steeds uitgevoerd.
Dat is alles voor mij, ik hoop dat het materiaal nuttig voor je was, tot ziens!
In dit voorbeeld hebben we een typefout gemaakt in de code (in het try-blok).
Het voorbeeld zou de waarschuwing "Welkom gast!" moeten geven, maar de waarschuwing is verkeerd gespeld.
Het catch-blok vangt de fout op en voert een code uit om deze af te handelen:
poging (
addlert("Welkom gast!");
}
vangen(err) (
document.getElementById("demo").innerHTML = err.message;
}
Hieronder vindt u meer voorbeelden van 'Probeer het zelf'.
Definitie en gebruikDe instructie try/catch/finally verwerkt enkele of alle fouten die kunnen optreden in een codeblok, terwijl de code nog steeds wordt uitgevoerd.
Fouten kunnen codeerfouten zijn die door de programmeur zijn gemaakt, fouten als gevolg van verkeerde invoer en andere onvoorziene zaken.
Met de try-instructie kunt u een codeblok definiëren dat moet worden getest op fouten terwijl het wordt uitgevoerd.
Met de catch-instructie kunt u een codeblok definiëren dat moet worden uitgevoerd als er een fout optreedt in het try-blok.
Met de instructie final kun je code uitvoeren, na try-and-catch, ongeacht het resultaat.
Opmerking: de instructies catch en final zijn beide optioneel, maar u moet een van deze gebruiken (zo niet beide) terwijl u de instructie try gebruikt.
Tip: Wanneer er een fout optreedt, stopt JavaScript normaal gesproken en genereert het een foutmelding. Gebruik de instructie throw om een aangepaste fout te maken (een uitzondering gooien). Als u throw samen met try and catch gebruikt, kunt u de programmastroom regelen en aangepaste foutmeldingen genereren.
Voor meer informatie over JavaScript-fouten kunt u de JavaScript-fouten-tutorial lezen.
Browserondersteuning| proberen/vangen/eindelijk | Ja | Ja | Ja | Ja | Ja |
Poging (
tryCode - Codeblok om te proberen
}
vangst( fout) {
catchCode - Codeblok om fouten af te handelen
}
Eindelijk(
finalCode - Codeblok dat moet worden uitgevoerd, ongeacht het try/catch-resultaat
}
| probeerCode | Vereist. Codeblok dat moet worden getest op fouten terwijl het wordt uitgevoerd |
| fout | Vereist indien gebruikt met opvangbak. Specificeert een lokale variabele die naar de fout verwijst. De variabele kan verwijzen naar het Error-object (bevat informatie over de opgetreden fout, zoals het bericht "addlert is niet gedefinieerd"). Als de uitzondering is gemaakt door de throw-instructie, verwijst de variabele naar het object dat is opgegeven in de throw-instructie (zie "Meer voorbeelden") |
| catchCode | Optioneel. Codeblok dat moet worden uitgevoerd als er een fout optreedt in het try-blok. Als er geen fout optreedt, wordt dit codeblok nooit uitgevoerd |
| eindelijkCode | Optioneel. Codeblok dat moet worden uitgevoerd, ongeacht het try/catch-resultaat |
| ECMAScript 3 |
In dit voorbeeld wordt de invoer onderzocht. Als de waarde onjuist is, wordt er een uitzondering (err) gegenereerd.
De uitzondering (err) wordt opgevangen door de catch-instructie en er wordt een aangepast foutbericht weergegeven:
Voer een getal tussen 5 en 10 in:
Testinvoer
functie mijnFunctie() (
var-bericht, x;
bericht = document.getElementById("bericht");
bericht.innerHTML = "";
x = document.getElementById("demo").waarde;
poging (
if(x == "") gooi "is leeg";
if(isNaN(x)) gooit "geen getal";
if(x > 10) gooi "te hoog";
als(x< 5) throw "too low";
}
vangen(err) (
message.innerHTML = "Invoer" + err;
}
}
Hallo! In deze les wil ik het hebben over fouten in JavaScript en hoe je daar daadwerkelijk mee om kunt gaan. Het komt immers vaak voor dat er van tijd tot tijd fouten optreden, en het is niet eens een kwestie van programmeerervaring of zelfs maar een volledig gebrek daaraan. Doorgewinterde programmeurs maken immers ook fouten; niemand is hier immuun voor.
Er zijn hoofdzakelijk twee soorten fouten: syntactisch en logisch. Syntactische fouten omvatten fouten in de namen van variabelen, functies en fouten in de codesyntaxis. In principe zijn dergelijke fouten eenvoudig op te sporen via de browserconsole.
Maar logische fouten zijn bij hen niet zo eenvoudig omdat ze leiden tot een onjuiste uitvoering van de programmacode. Om ze te elimineren, moet u daarom het programma debuggen om te begrijpen wat er feitelijk bij elke stap van het script gebeurt. Hier zullen we vooral kijken naar de lokalisatie van syntaxisfouten met behulp van de try…catch-constructie. 
Probeer…vang de structuur voor het opvangen van fouten
Het try..catch-construct bestaat uit 2 blokken: try en dan catch. Hier is een voorbeeld van een algemene invoer
Probeer ( // code... ) catch (err) ( // foutafhandeling )
Dit ontwerp werkt als volgt:
Daarom stopt het script niet als er een fout optreedt bij het proberen, en bovendien hebben we de mogelijkheid om de fout binnen het catch-blok af te handelen.
Laten we dit met voorbeelden bekijken.
- Voorbeeld zonder fouten: bij het opstarten worden waarschuwingen (1) en (2) geactiveerd: try ( alert("Try block"); // (1)
