Golang se altro

La capacità di aggiungere condizioni ai nostri programmi è molto critica. Possiamo creare programmi simili a intelligenti che eseguono azioni specifiche solo quando una condizione è vera usando le istruzioni condizionali.

Le dichiarazioni condizionali sono come il pane e il burro dei programmi moderni, permettendo loro di valutare condizioni specifiche e agire solo quando quella condizione è vera.

Ad esempio, possiamo usare una dichiarazione condizionale per:

1. Mostra l'opzione "reimpostare password" se la prova massima della password.
2. Dare uno sconto se l'utente acquista prodotti del valore di un importo specifico.

Come noterai, utilizziamo dichiarazioni condizionali quasi ovunque nel mondo moderno per intraprendere azioni in modo intelligente in base a varie condizioni.

Usando questa guida, capirai come lavorare con istruzioni condizionali usando il linguaggio di programmazione Go.

Iniziare.

In GO, possiamo creare un'istruzione condizionale usando la parola chiave If. Possiamo esprimere la sintassi generale dell'istruzione IF come mostrato:

if condizione
// Esegui questo codice

Iniziamo chiamando la parola chiave If. Successivamente, specifichiamo la condizione per valutare se vero o falso. Se vero, eseguiamo il codice all'interno delle parentesi graffe ricci.

Ad esempio, il codice seguente mostra i prezzi di un biglietto per il film se l'età è maggiore di 18.

Pacchetto principale
Importa "FMT"
funcmain ()
età: = 22
if age> = 18
fmt.Println ("I biglietti per il film sono 10 $")

Nell'esempio sopra, creiamo una variabile chiamata età e gli assegniamo un valore di 22.

Usiamo quindi un'istruzione if per verificare se l'età è maggiore o uguale a 18 (> = 18). Se la condizione è vera, stampiamo il prezzo dei biglietti per il film.

Se eseguiamo il codice sopra, dovremmo ottenere un output come mostrato di seguito:

$ go run if_else.andare

I biglietti per il film sono 10 $

Poiché l'età è maggiore di 18, la condizione diventa vera e eseguiamo il codice all'interno delle parentesi graffe ricci.

Cosa succede quando cambiamo il valore della variabile di età per essere 15?

età: = 15
Se età> 18
fmt.Println ("I biglietti per il film sono 10 $")

Se salviamo il file ed eseguiamo il codice sopra, non dovremmo vedere alcun output. Questo perché la condizione non è più vera. Tuttavia, non abbiamo creato un codice per eseguire un'azione se la condizione era falsa.

Else dichiarazioni

Possiamo creare un codice per eseguire un'azione specifica anche quando la condizione è falsa usando un'istruzione Else.

Nel nostro esempio, ciò sarebbe quello di avvisare l'utente che devono essere più anziani o 18 per vedere il film.

La sintassi per un'istruzione Else è come mostrata:

iffcondition
// Run Me
altro
// salta a me

Considera l'esempio seguente:

Pacchetto principale
Importa "FMT"
funcmain ()
età: = 15
Se età> 18
fmt.Println ("I biglietti per il film sono 10 $")
altro
fmt.Println ("Devi avere 18 anni per vedere il film!")

Se eseguiamo il codice sopra, dovremmo ottenere un output come:

$ go run if_else.andare
Devi essere di età compresa tra il film!

Qui, il programma esegue il blocco altro poiché se la condizione è falsa. Se si cambia il valore dell'età per essere superiore a 18, il programma esegue il blocco IF come:

età: = 22
Se età> 18
fmt.Println ("I biglietti per il film sono 10 $")
altro
fmt.Println ("Devi avere 18 anni per vedere il film!")

L'output è come mostrato:

$ go run if_else.andare
I biglietti per il film sono 10 $

Nota: l'istruzione Else in Go arriva immediatamente dopo la cornice riccia di chiusura dell'istruzione IF. Se aggiungi una nuova riga, il compilatore restituirà un errore come:

età: = 22
Se età> 18
fmt.Println ("I biglietti per il film sono 10 $")

altro
fmt.Println ("Devi avere 18 anni per vedere il film!")

Il codice sopra restituisce un errore di sintassi come:

sintaxerror: inaspettato altro, aspettando

Se ... altro se ... dichiarazioni

Nella maggior parte dei casi, vorremo un programma per valutare e agire per più di un risultato. Prendi il programma del biglietto del film:

Ad esempio, se l'età è compresa tra 18 e 23 anni, il prezzo dei biglietti per il film è di 10 $; Se l'età è compresa tra 24 e 35 anni, i biglietti per il film sono 15 $ e se l'età è maggiore di 36, i biglietti per il film sono 20 $.

In tale scenario, possiamo costruire e altro ... L'istruzione If Else funziona come una tipica istruzione IF, tranne per il fatto che controlla un'altra condizione in un contesto simile.

Considera l'esempio seguente che utilizza un'istruzione IF ... else If per calcolare il prezzo dei biglietti per il film.

Pacchetto principale
Importa "FMT"
funcmain ()
età: = 22
if age> = 18 && age = 24 && age = 18 && age = 24 && age <= 35
fmt.Println ("prezzo: 15 $")
altro
fmt.Println ("prezzo: 20 $")

Se eseguiamo il codice sopra:

$ go run if_else.andare
Prezzo: 20 $

Il programma stampa il prezzo come 20 $. Tuttavia, questo non è quello che vogliamo. Vogliamo che il programma dica all'utente che devono essere di 18 e oltre per acquistare i biglietti per il film.

Quindi, possiamo modificare il codice sorgente come:

Pacchetto principale
Importa "FMT"
func main ()
età: = 13
if age = 18 && age = 24 && age <= 35
fmt.Println ("prezzo: 15 $")
altro
fmt.Println ("prezzo: 20 $")

Il programma stampa il messaggio appropriato se l'età dell'utente è inferiore a 18 anni.

$ go run if_else.andare
Devi battere i 18 anni per acquistare il biglietto

Dichiarazioni IF-Else nidificate

È possibile controllare più condizioni contemporaneamente utilizzando le istruzioni IF-ELSE nidificate. Prendiamo un programma bancario, ad esempio. Possiamo controllare il tipo di account e agire.

Prendi il codice di esempio mostrato di seguito:

Pacchetto principale
Importa "FMT"
funcmain ()
account_type: = "risparmio"
Azione: = "ritiro"
Saldo: = 3000
iFaccount_Type == "risparmio"
if action == "prelievo"
Se equilibrio <200
fmt.Println ("hai fondi insufficienti da ritirare")
altro
fmt.Println ("Quanto vorresti ritirarsi? ")

elseif action == "deposito"
fmt.Println ("Quanto vorresti depositare? ")
altro
fmt.Println ("puoi prelevare o depositare")

altro
fmt.Println ("le azioni sono applicabili solo a un conto di risparmio!")

L'esempio sopra illustra come è possibile utilizzare le dichiarazioni nidificate se e else-if. Iniziamo controllando se l'account_type è uguale al "salvataggio". Se vero, controlliamo se l'azione è uguale a "prelievo" e se vera, verifichiamo se il conto ha il saldo minimo richiesto.

Utilizzando le dichiarazioni se nidificate e else-if, è possibile creare condizioni complesse e più specificate e agire per ogni scenario.

Conclusione

Questa guida ha riguardato come implementare e utilizzare le dichiarazioni condizionali in Go. Per esplorare l'entità delle dichiarazioni condizionali, prendere in considerazione l'implementazione di vari scenari utilizzando vari operatori di confronto.

Grazie per aver letto!