3 soorten programmeerfouten en hoe u ze kunt vermijden

Programmeerfouten zijn gebreken in de manier waarop applicaties werken. Ze worden gewoonlijk "bugs" genoemd, vandaar de term "debuggen".

Als ontwikkelaar zul je merken dat je veel tijd besteedt aan het oplossen van bugs. Een aantal van de fouten die u tegenkomt, komen vaak voor, en als u ze kent, kunt u ze in de eerste plaats voorkomen.

Dit is wat u moet weten over deze drie soorten programmeerfouten en hoe u zich hiertegen kunt beschermen:

1. Runtime- of uitvoeringsfouten

Dit zijn fouten die optreden wanneer een programma wordt uitgevoerd (d.w.z. tijdens runtime). Ze kunnen ervoor zorgen dat een programma niet goed of zelfs helemaal niet wordt uitgevoerd.

Fatale runtime-fouten zorgen ervoor dat de uitvoering van het programma stopt, terwijl de niet-fatale ervoor zorgen dat de uitvoering wordt beëindigd, maar met onjuiste resultaten.

Een typische runtime-fout is een fout door deling door nul. Delen door nul zou een oneindig resultaat moeten opleveren, maar helaas hebben we nog geen datastructuur bedacht die die hoeveelheid data kan opslaan.

Daarom leidt deling door nul tot een rekenkundige uitzondering in de Java-compiler.

2. Logische fouten

Logische fouten worden veroorzaakt door een gebrekkige redenering. Het is belangrijk op te merken dat deze fouten niet noodzakelijk te wijten zijn aan een "fout" die u heeft gemaakt. Ze kunnen optreden omdat u geen rekening hebt gehouden met een bepaald uitvoeringsscenario.

Ze zijn het moeilijkst te hanteren. Dit komt omdat code met een logische fout een geldig programma is in de taal waarin het is geschreven. Daarom zal het geen compilerfout genereren. Het enige probleem is dat het onjuiste resultaten oplevert.

Een fatale logische fout zorgt ervoor dat de uitvoering van het programma stopt, terwijl een niet-fatale de uitvoering van het programma laat doorgaan, maar met onjuiste resultaten.

Een veelvoorkomende logische fout is een off-by-one fout. Dit gebeurt normaal gesproken bij het aangeven van een lus-voortzettingsvoorwaarde. Stel dat u de eerste vijf vierkante cijfers wilt afdrukken.

Verwant: Meest voorkomende programmeer- en codeerfouten

Je zou uiteindelijk de onderstaande code in je for-lus kunnen schrijven, die alleen de eerste vier van dergelijke nummers geeft.

voor( int x=1; x<5; x++){ Systeem.uit.ln (x*x); }

Om een ​​dergelijke fout te voorkomen, kunt u in plaats daarvan het teken <= gebruiken. Het gebruik van het minder-dan-of-gelijk-aan-teken is intuïtiever en u zult daarom minder snel uw relationele bewerkingen door elkaar halen.

Een andere veelvoorkomende logische fout is het weglaten van beide accolades van een control-statement en toch vormt de body eronder een codeblok dat onder zijn controle staat.

Kijk naar het voorbeeld hieronder. Het controleert of een willekeurig getal even of oneven is en drukt vervolgens een uitvoer af.

java.util importeren. Willekeurig;
openbare klasse OddEven{
public static void main (String[] args) {
Willekeurig nummerGenerator = new Random();
int randomNumber = numberGenerator.nextInt (10);
if ((willekeurig getal%2)==0)
System.out.println("Hier is je geluksgetal:" + randomNumber);
System.out.println("Het getal "+ randomNumber +" dat je hebt is even"); // regel 11
}
}

Let op regel 11. Het wordt altijd uitgevoerd, ongeacht of het willekeurige getal dat je hebt even is. Dit zou natuurlijk logisch verkeerd zijn als het nummer dat je hebt oneven is.

Inclusief beide Systeem.uit.println uitspraken tussen accolades { }, zou dit hebben vermeden.

Verwant: Stappen voor softwareontwikkeling die alle programmeurs moeten weten

Een andere logische fout om op te letten, is het niet bieden van een lusbeëindigingsconditie. Dit resulteert in een oneindige lus en uw programma zal nooit worden uitgevoerd.

3. Syntaxis- of compileertijdfouten

Dit zijn fouten die worden veroorzaakt door schendingen van de taalregels van Java. Ze worden ook compilatie- of compilatiefouten genoemd.

Dit zijn de gemakkelijkste fouten om af te handelen, omdat uw compiler ze altijd zal rapporteren. Veel compilers gaan zelfs door en vertellen u op welke regel in uw code de fout zich bevindt.

Fouttolerantie

Een praktische manier om met softwareproblemen om te gaan, is het toepassen van fouttolerantie door exception handling op te nemen. Je kunt gebruiken proberen te vangen uitspraken om dit te bereiken.

Om door te gaan met de uitvoering van het programma, ongeacht de uitzondering die is vastgelegd in de vangst blok, gebruik de Tenslotte uitspraak.

De syntaxis is:

probeer { // Blokkeren om uit te voeren als er geen problemen zijn} 
vangst (uitzondering e){
// Blokkeren om gevonden problemen af ​​te handelen
}eindelijk{ // Blokkeren om uit te voeren na vangst
}

Zie het onderstaande codevoorbeeld:

java.util importeren. Willekeurig;
openbare klasse RandomNumbers{
public static void main (String[] args) {
Willekeurig nummerGenerator = new Random();
proberen{
voor (int teller = 10; teller<=100; teller++){
int randomNumber = numberGenerator.nextInt (10);
System.out.println (teller/willekeurig nummer); } }
vangst (uitzondering e){
System.out.println("Deling door nul gevonden!");
}
Tenslotte{
System.out.println("Oneindige waarde gekregen");}
}
}

Het bovenstaande programma genereert een willekeurig getal tussen nul en 10 en gebruikt dat getal vervolgens om een ​​tellerwaarde te delen tussen 10 en 100. Als deling door nul wordt aangetroffen, vangt het systeem de fout op en wordt er een bericht weergegeven.

Beter worden in coderen

Het is een goede gewoonte om opmerkingen aan uw code toe te voegen. Dit zal je helpen om gemakkelijk door je bestanden te kammen als je een bug hebt. Een kleine, maar zeer belangrijke stap in het ontwikkelen van sterke codeerpraktijken.

Met goede coderingspraktijken zou u veelvoorkomende programmeerfouten moeten kunnen vermijden.

Wat is coderen en hoe werkt het?

Verward over coderen? Begrijp je scripting niet? Dit is wat u moet weten over de bouwstenen van programmeren.

Lees volgende

Over de auteur

Uitvouwen om het volledige verhaal te lezen