3 typer av programmeringsfel och hur man undviker dem

Programmeringsfel är brister i hur applikationer fungerar. De kallas ofta "buggar", därav termen "felsökning".

Som utvecklare kommer du att spendera mycket tid på att fixa buggar. Ett antal av de fel du kommer att möta är vanliga, och att känna till dem hjälper dig att förhindra dem i första hand.

Här är vad du behöver veta om dessa tre typer av programmeringsfel och hur du kan skydda dig mot dem:

1. Runtime eller Execution Fel

Det här är fel som uppstår när ett program körs (dvs. vid körning). De kan orsaka att ett program inte körs ordentligt eller inte ens körs alls.

Dödliga körtidsfel gör att programkörningen stoppas medan de icke-dödliga orsakar att körningen är klar, men med felaktiga resultat.

Ett typiskt runtime-fel är en division med noll-fel. Division med noll ska ge ett oändligt resultat, men tyvärr har vi inte kommit med en datastruktur som kan lagra den mängden data ännu.

Därför leder delning med noll till ett aritmetiskt undantag i Java-kompilatorn.

2. Logiska fel

Logikfel orsakas på grund av bristfälligt resonemang. Det är viktigt att notera att dessa fel inte nödvändigtvis beror på ett ”misstag” du har gjort. De kan uppstå eftersom du inte ansåg ett visst exekveringsscenario.

De är de svåraste att hantera. Detta beror på att kod med ett logiskt fel är ett giltigt program på det språk det är skrivet på. Därför kastar det inte ett kompileringsfel. Det enda problemet är att det ger felaktiga resultat.

Ett dödligt logikfel kommer att göra att programkörningen stoppas medan ett icke-dödligt tillåter att programkörningen fortsätter men med felaktiga resultat.

Ett vanligt logikfel är ett fel-för-ett-fel. Detta inträffar normalt när man anger ett loop-fortsättningstillstånd. Säg att du vill skriva ut de fem första fyrkantiga siffrorna.

Relaterad: Vanligaste programmerings- och kodfel

Du kan sluta skriva koden nedan i din for-loop, som bara ger de första fyra sådana siffrorna.

för (int x = 1; x <5; x ++) {System.out.ln (x * x); }

För att undvika ett sådant fel kan du istället använda <= tecknet. Att använda tecknet mindre än eller lika med är mer intuitivt och det är därför mindre troligt att du blandar ihop dina relationsoperationer.

Ett annat vanligt logikfel utelämnar båda hakparenteserna i ett kontrolluttal och ändå bildar kroppen nedan ett kodblock som är under dess kontroll.

Titta på exemplet nedan. Den kontrollerar om ett slumpmässigt tal är udda eller jämnt och skriver sedan ut en utskrift.

importera java.util. Slumpmässig;
offentlig klass OddEven {
public static void main (String [] args) {
Random numberGenerator = ny Random ();
int randomNumber = numberGenerator.nextInt (10);
if ((randomNumber% 2) == 0)
System.out.println ("Här är ditt lyckosiffror:" + randomNumber);
System.out.println ("Antalet" + randomNumber + "som du har är jämnt"); // rad 11
}
}

Meddelandelinje 11. Det kommer alltid att köras oavsett om det slumpmässiga talet du har är jämnt. Detta skulle naturligtvis vara logiskt fel när numret du fick är udda.

Inklusive båda System.out.println uttalanden mellan hängslen {}, skulle ha undvikit detta.

Relaterad: Programutvecklingssteg som alla programmerare borde veta

Ett annat logikfel att se upp för ger inte ett loop-termination-tillstånd. Detta resulterar i en oändlig slinga och ditt program kommer aldrig att slutföra körningen.

3. Syntax eller kompileringstidsfel

Dessa är fel orsakade på grund av brott mot Java: s språkregler. De kallas också kompilerings- eller kompileringsfel.

Det här är de enklaste felen att hantera eftersom din kompilator alltid rapporterar dem. Många kompilatorer går till och med och berättar raden i din kod som felet är på.

Feltolerans

Ett praktiskt sätt att hantera programvaruproblem är att utnyttja feltolerans genom att inkludera undantagshantering. Du kan använda försök fånga uttalanden för att uppnå detta.

För att fortsätta med programkörning oavsett undantag som finns i fånga blockera, använd till sist påstående.

Syntaksen är:

prova {// Blockera för att köra om det inte finns några problem} 
fångst (undantag e) {
// Blockera för att hantera problem som hittats
} äntligen {// Blockera för att köra efter fångsten
}

Se kodexemplet nedan:

importera java.util. Slumpmässig;
offentlig klass RandomNumbers {
public static void main (String [] args) {
Random numberGenerator = ny Random ();
Prova{
för (int-räknare = 10; räknare <= 100; räknare ++) {
int randomNumber = numberGenerator.nextInt (10);
System.out.println (counter / randomNumber); } }
fångst (undantag e) {
System.out.println ("Uppdelad med noll!");
}
till sist{
System.out.println ("Oändligt värde fick");}
}
}

Ovanstående program genererar ett slumpmässigt tal mellan noll och 10 och använder sedan det numret för att dela ett räknarvärde mellan 10 och 100. Om det uppstår delning med noll fångar systemet upp felet och visar ett meddelande.

Bli bättre på kodning

Det är bra att lägga till kommentarer till din kod. Detta hjälper dig att enkelt kamma igenom dina filer när du har ett fel. Ett litet men mycket viktigt steg för att utveckla starka kodningsmetoder.

Med god kodningssed bör du kunna undvika vanliga programmeringsfel.

Vad är kodning och hur fungerar det?

Förvirrad över kodning? Förstår du inte skript? Här är vad du behöver veta om byggstenarna för programmering.

Läs Nästa

Om författaren

Expandera för att läsa hela berättelsen