3 tipi di errori di programmazione e come evitarli

Gli errori di programmazione sono difetti nel funzionamento delle applicazioni. Sono comunemente indicati come "bug", da cui il termine "debug".

Come sviluppatore, ti ritroverai a passare molto tempo a correggere i bug. Alcuni degli errori che incontrerai sono comuni e conoscerli ti aiuterà a prevenirli in primo luogo.

Ecco cosa devi sapere su questi tre tipi di errori di programmazione e come puoi salvaguardarli:

1. Errori di runtime o di esecuzione

Questi sono errori che si verificano durante l'esecuzione di un programma (cioè in fase di esecuzione). Possono causare l'esecuzione non corretta di un programma o addirittura la mancata esecuzione.

Gli errori fatali di runtime causano l'arresto dell'esecuzione del programma mentre quelli non fatali causano il completamento dell'esecuzione, ma con risultati errati.

Un tipico errore di runtime è una divisione per zero errore. La divisione per zero dovrebbe produrre un risultato infinito, ma sfortunatamente non abbiamo ancora creato una struttura dati in grado di memorizzare quella quantità di dati.

Pertanto, la divisione per zero porta a un'eccezione aritmetica nel compilatore Java.

2. Errori logici

Gli errori logici sono causati da un ragionamento errato. È importante notare che questi errori non sono necessariamente dovuti a un "errore" che hai commesso. Possono verificarsi perché non hai considerato un determinato scenario di esecuzione.

Sono i più difficili da gestire. Questo perché il codice con un errore logico è un programma valido nella lingua in cui è scritto. Pertanto, non genererà un errore del compilatore. L'unico problema è che produce risultati errati.

Un errore logico fatale causerà l'arresto dell'esecuzione del programma, mentre uno non fatale consentirà l'esecuzione del programma ma con risultati errati.

Un errore logico comune è un errore off-by-one. Ciò si verifica normalmente quando si afferma una condizione di continuazione del ciclo. Supponi di voler stampare i primi cinque numeri quadrati.

Relazionato: Errori di programmazione e codifica più comuni

Potresti finire per scrivere il codice seguente nel tuo ciclo for, che fornisce solo i primi quattro di questi numeri.

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

Per evitare un tale errore, potresti invece usare il segno <=. Usare il segno di minore o uguale a è più intuitivo e quindi avrai meno probabilità di confondere le tue operazioni relazionali.

Un altro errore logico comune è omettere entrambe le parentesi graffe di un'istruzione di controllo e tuttavia il corpo sottostante forma un blocco di codice che è sotto il suo controllo.

Guarda l'esempio qui sotto. Controlla se un numero casuale è pari o dispari, quindi stampa un output.

import java.util. Casuale;
classe pubblica PariDispari{
public static void main (String[] args) {
Numero casualeGenerator = new Random();
int randomNumber = numberGenerator.nextInt (10);
if ((numerocasuale%2)==0)
System.out.println("Ecco il tuo numero fortunato:" + randomNumber);
System.out.println("Il numero "+ randomNumber +" che hai ottenuto è pari"); // riga 11
}
}

Avviso Riga 11. Verrà sempre eseguito indipendentemente dal fatto che il numero casuale che hai ottenuto sia pari. Questo sarebbe ovviamente sbagliato dal punto di vista logico quando il numero che hai ottenuto è dispari.

Compresi entrambi System.out.println istruzioni tra parentesi graffe { }, lo avrebbero evitato.

Relazionato: Fasi di sviluppo del software che tutti i programmatori dovrebbero conoscere

Un altro errore logico a cui prestare attenzione è la mancata fornitura di una condizione di terminazione del ciclo. Ciò si tradurrà in un ciclo infinito e il tuo programma non finirà mai l'esecuzione.

3. Errori di sintassi o di compilazione

Questi sono errori causati da violazioni delle regole del linguaggio Java. Sono anche chiamati errori di compilazione o in fase di compilazione.

Questi sono gli errori più facili da gestire perché il tuo compilatore li segnalerà sempre. Molti compilatori addirittura vanno avanti e ti dicono la riga nel tuo codice su cui si trova l'errore.

Tolleranza ai guasti

Un modo pratico per affrontare i problemi del software consiste nell'utilizzare la tolleranza agli errori includendo la gestione delle eccezioni. Puoi usare prova a prendere dichiarazioni per raggiungere questo obiettivo.

Per continuare con l'esecuzione del programma indipendentemente dall'eccezione rilevata nel catturare blocca, usa il finalmente dichiarazione.

La sintassi è:

try{ // Blocca l'esecuzione se non ci sono problemi} 
catch (Eccezione e){
// Blocca per gestire i problemi rilevati
}finally{ // Blocco da eseguire dopo catch
}

Vedi l'esempio di codice qui sotto:

import java.util. Casuale;
numeri casuali di classe pubblica{
public static void main (String[] args) {
Numero casualeGenerator = new Random();
provare{
for (int contatore = 10; contatore<=100; contatore++){
int randomNumber = numberGenerator.nextInt (10);
System.out.println (counter/randomNumber); } }
catch (Eccezione e){
System.out.println("Riscontrata divisione per zero!");
}
finalmente{
System.out.println("Valore infinito ottenuto");}
}
}

Il programma precedente genera un numero casuale compreso tra zero e 10, quindi utilizza quel numero per dividere un valore del contatore tra 10 e 100. Se viene rilevata una divisione per zero, il sistema rileva l'errore e visualizza un messaggio.

Migliora la programmazione

È buona norma aggiungere commenti al codice. Questo ti aiuterà a spulciare facilmente i tuoi file quando hai un bug. Un piccolo, ma molto importante passo per lo sviluppo di pratiche di codifica forti.

Con buone pratiche di codifica, dovresti essere in grado di evitare errori di programmazione comuni.

Che cos'è la codifica e come funziona?

Confuso sulla codifica? Non capisci gli script? Ecco cosa devi sapere sugli elementi costitutivi della programmazione.

Leggi Avanti

Circa l'autore

Espandi per leggere la storia completa