Construcții condiționale

Construcțiile condiționale verifică adevărul unei anumite condiții și, în funcție de rezultatele verificării, permit ghidarea execuției programului pe unul dintre căi.

if...else

Construcția if primește o condiție - o expresie care returnează o valoare de tip bool. Dacă această condiție este adevărată, atunci se execută blocul de instrucțiuni următor.

package main
import "fmt"

func main() {
    a := 6
    b := 7
    if a < b {
        fmt.Println("a este mai mic decât b")
    }
}

Condiția este plasată după cuvântul cheie if. În acest caz, se verifică dacă valoarea variabilei a este mai mică decât valoarea variabilei b. Deoarece în acest caz valoarea variabilei a este cu adevărat mai mică decât valoarea variabilei b, adică condiția returnează true, atunci se va executa blocul de cod următor, care va afișa mesajul pe consolă.

Dacă dorim să specificăm o logică alternativă care să fie executată atunci când condiția este falsă, putem adăuga expresia else:

package main
import "fmt"

func main() {
    a := 6
    b := 7
    if a < b {
        fmt.Println("a este mai mic decât b")
    } else {
        fmt.Println("a este mai mare decât b")
    }
}

Astfel, dacă expresia condițională de după if este adevărată, se execută blocul de după if, iar dacă este falsă, se execută blocul de după else.

Dacă dorim să verificăm mai multe opțiuni alternative, putem adăuga expresii else if:

package main
import "fmt"

func main() {
    a := 8
    b := 8
    if a < b {
        fmt.Println("a este mai mic decât b")
    } else if a > b {
        fmt.Println("a este mai mare decât b")
    } else {
        fmt.Println("a este egal cu b")
    }
}

Astfel, dacă expresia de după if este adevărată, se va executa blocul if. În caz contrar, se verifică expresia de după else if. Dacă aceasta este adevărată, se execută blocul else if. Dacă este falsă, se va executa blocul else.

Pot exista mai multe expresii else if:

if a == 9 {
    fmt.Println("a = 9")
} else if a == 8 {
    fmt.Println("a = 8")
} else if a == 7 {
    fmt.Println("a = 7")
}

switch

Construcția switch verifică valoarea unei expresii. Cu ajutorul operatorilor case se definesc valorile pentru comparație. Dacă valoarea după operatorul case corespunde valorii expresiei din switch, atunci se execută codul din blocul respectiv.

package main
import "fmt"

func main() {
    a := 8
    switch a {
        case 9: 
            fmt.Println("a = 9")
        case 8: 
            fmt.Println("a = 8")
        case 7: 
            fmt.Println("a = 7")
    }
}

Ca expresie, construcția switch utilizează variabila a. Valoarea acesteia este comparată succesiv cu valorile de după operatorii case. Deoarece variabila a este 8, va fi executat blocul case 8: fmt.Println("a = 8"). Celelalte blocuri case nu vor fi executate.

După operatorul switch, putem specifica orice expresie care returnează o valoare. De exemplu, o operație de adunare:

a := 7
switch (a + 2) {
    case 9: 
        fmt.Println("9")
    case 8: 
        fmt.Println("8")
    case 7: 
        fmt.Println("7")
}

De asemenea, construcția switch poate conține un bloc opțional default, care se execută dacă niciunul dintre operatorii case nu conține valoarea dorită:

package main
import "fmt"

func main() {
    a := 87
    switch a {
        case 9: 
            fmt.Println("a = 9")
        case 8: 
            fmt.Println("a = 8")
        case 7: 
            fmt.Println("a = 7")
        default: 
            fmt.Println("valoarea variabilei a nu este definită")
    }
}

De asemenea, putem specifica mai multe valori după operatorul case:

a := 5
switch a {
    case 9: fmt.Println("a = 9")
    case 8: fmt.Println("a = 8")
    case 7: fmt.Println("a = 7")
    case 6, 5, 4: 
        fmt.Println("a = 6 sau 5 sau 4, dar nu este sigur")
    default: 
        fmt.Println("valoarea variabilei a nu este definită")
}