1 Panoramica delle dichiarazioni condizionali

Le dichiarazioni condizionali sono strumenti importanti per controllare il flusso logico dei programmi nella programmazione. In Golang, le dichiarazioni condizionali sono simili a quelle di altri linguaggi di programmazione, ma hanno le proprie caratteristiche. Ci permettono di decidere quale codice eseguire in base alle condizioni vere o false, aumentando notevolmente la flessibilità e la manutenibilità del codice.

2 Dichiarazione if

2.1 Utilizzo di base della dichiarazione if

La dichiarazione if è la più basilare dichiarazione condizionale nel linguaggio Go. La sua sintassi è la seguente:

if condizione {
    // Codice da eseguire quando la condizione è vera
}

Ecco un semplice esempio:

package main

import "fmt"

func main() {
    x := 10
    if x > 5 {
        fmt.Println("x è maggiore di 5")
    }
}

Questo codice controllerà se x è maggiore di 5 e, se lo è, eseguirà l'operazione di stampa.

2.2 Espressioni condizionali

Le espressioni condizionali consistono di operatori di confronto (come ==, !=, <, >, <=, >=) e operatori logici (come && (AND), || (OR), ! (NOT)).

Per esempio, per verificare se una variabile è all'interno di un determinato intervallo:

y := 20
if y >= 10 && y <= 30 {
    fmt.Println("y è compreso tra 10 e 30")
}

La precedente espressione condizionale utilizza l'operatore logico && per garantire che il valore di y sia compreso tra 10 e 30.

2.3 Struttura if...else e else if

Quando la condizione if non viene soddisfatta, possiamo utilizzare else per eseguire un blocco di codice alternativo. Il else if ci consente di verificare più condizioni. Ecco un esempio:

punteggio := 88

if punteggio >= 90 {
    fmt.Println("Eccellente")
} else if punteggio >= 80 {
    fmt.Println("Buono")
} else if punteggio >= 70 {
    fmt.Println("Medio")
} else {
    fmt.Println("Sotto la media")
}

Questo codice stamperà valutazioni diverse in base al valore di punteggio.

3 Dichiarazione switch

3.1 Sintassi di base di switch

La dichiarazione switch è una dichiarazione di ramificazione condizionale più concisa, particolarmente adatta alle situazioni in cui è necessario valutare più valori. La sintassi di base della dichiarazione switch è la seguente:

switch espressione {
case valore1:
    // Codice da eseguire quando corrisponde a valore1
case valore2:
    // Codice da eseguire quando corrisponde a valore2
default:
    // Codice da eseguire per default
}

Se il valore di espressione corrisponde al valore successivo a case, verrà eseguito il rispettivo blocco di codice.

3.2 switch Fallthrough

Nella dichiarazione switch di Go, ogni ramo non passa automaticamente al caso successivo a meno che non venga utilizzata la parola chiave fallthrough.

switch num {
case 1:
    fmt.Println("Uno")
    fallthrough
case 2:
    fmt.Println("Due")
default:
    fmt.Println("Né Uno né Due")
}

Nel codice precedente, se num è 1, anche se corrisponde a case 1, a causa della presenza della parola chiave fallthrough, il programma continuerà ad eseguire il codice in case 2 e stamperà "Due".

3.3 Branching di tipo e Branching personalizzato

La dichiarazione switch supporta anche il branching basato sui tipi di variabili, noto come branching di tipo. Inoltre, possiamo creare condizioni di branching personalizzate più complesse.

Esempio di branching di tipo:

var i interface{} = 1

switch i.(type) {
case int:
    fmt.Println("i è un intero")
case float64:
    fmt.Println("i è un float64")
default:
    fmt.Println("i è un altro tipo")
}

Condizioni di branching personalizzate possono essere scritte per eseguire giudizi condizionali più complessi secondo necessità.

4 Esercizio pratico

In questa sezione, approfondiremo la comprensione e l'applicazione delle dichiarazioni condizionali in Golang attraverso esempi specifici. Attraverso sfide pratiche di programmazione, diventerai più competente nell'uso delle dichiarazioni if e switch per risolvere problemi reali.

Calcolatore di Voti

Scriviamo un semplice calcolatore di voti. Questo programma determinerà e stamperà il voto corrispondente in base al punteggio inserito dall'utente. I criteri di valutazione sono i seguenti:

  • A per punteggi pari o superiori a 90
  • B per punteggi compresi tra 80 e 89
  • C per punteggi compresi tra 70 e 79
  • D per punteggi compresi tra 60 e 69
  • F per punteggi inferiori a 60

Possiamo utilizzare sia un'istruzione if che un'istruzione switch per implementare questa funzionalità. Per prima cosa, vediamo un esempio usando un'istruzione if:

package main

import (
	"fmt"
)

func main() {
	var punteggio int
	fmt.Print("Inserisci il punteggio: ")
	fmt.Scan(&punteggio)

	if punteggio >= 90 {
		fmt.Println("Voto: A")
	} else if punteggio >= 80 {
		fmt.Println("Voto: B")
	} else if punteggio >= 70 {
		fmt.Println("Voto: C")
	} else if punteggio >= 60 {
		fmt.Println("Voto: D")
	} else {
		fmt.Println("Voto: F")
	}
}

In questo codice, dichiariamo prima una variabile punteggio per memorizzare il punteggio inserito dall'utente. Utilizziamo la funzione fmt.Scan per ottenere l'input dell'utente. Quindi, utilizziamo diverse istruzioni if e else if per determinare il voto corrispondente al punteggio e utilizziamo la funzione fmt.Println per stampare il voto.

Successivamente, vediamo un esempio utilizzando un'istruzione switch:

package main

import (
	"fmt"
)

func main() {
	var punteggio int
	fmt.Print("Inserisci il punteggio: ")
	fmt.Scan(&punteggio)

	switch {
	case punteggio >= 90:
		fmt.Println("Voto: A")
	case punteggio >= 80:
		fmt.Println("Voto: B")
	case punteggio >= 70:
		fmt.Println("Voto: C")
	case punteggio >= 60:
		fmt.Println("Voto: D")
	default:
		fmt.Println("Voto: F")
	}
}

Nell'esempio utilizzando l'istruzione switch, la struttura del codice è più concisa e chiara. Non abbiamo bisogno di utilizzare molte istruzioni if e else if consecutive; invece, specifichiamo direttamente le condizioni in ciascun case dopo il switch. Il punteggio che non corrisponde alla condizione del case precedente passerà automaticamente al case successivo fino a quando corrisponde al ramo condizionale corrispondente o raggiunge il default, che stamperà il voto F.

Ora che hai imparato come utilizzare if e switch per le valutazioni condizionali, prova a scrivere il tuo programma e a praticare per approfondire la comprensione.

Nella prossima sezione, continueremo a presentare problemi più pratici per aiutarti a consolidare la tua padronanza delle istruzioni condizionali in Golang.

Si prega di notare che il codice sopra è solo a scopo didattico. Quando utilizzato in applicazioni pratiche, è necessario considerare fattori come l'interazione con l'utente e la gestione degli errori per renderlo più robusto.