Home Rhyylen
Contatto
Programmazione
 
 
V Language
Capitolo 4
I booleani

Il tipo bool è concettualmente molto semplice, come in altri linguaggi. Le variabili di questo tipo possono assumere solo due valori:

-- true
-- false

non sono ammessi altri valori, tanto meno quelli numerici, come invece è possibile avere ad esempio in C.

fn main()
{
    mut x1 := bool(true)
    print(x1)
    x1 = 1
}

L'ultima riga dà origine ad un errore

error: cannot assign to `x1`: expected `bool`, not `int literal`

E' invece ovviamente possibile assegnare a x1 il valore false.

La dichiarazione naturalmente poteva aversi sfruttando l'inferenza:

mut x1 := true

Le variabili booleane sono di facile comprensione logica ma molto più spesso avrete a che fare con espressioni booleane, ovvero espressioni che logicamente esprimono un valore di ritorno booleano.
Ad esempio l'operatore > (maggiore di) esprimerà true o false in espressioni come
 2 > 3
e così altri operatori che vedremo qui di seguito. Quando poi affronteremo i vari cicli di selezione vedremo ancor di più la grande importanza di queste espressioni. Per ora vediamo quindi la tabella degli operatori, nei brevi esempi forniti il valore restituito è sempre true.

  • ==  uguglianza
    x1 == x2
  • >  maggiore di
    1 > 0
    •
  • < minore di
    0 < 1
    •
  • !=  diverso da
    1 != 0
    •
  • >= maggiore o uguale
    3 >= 3
    •
  • <= minore o uguale
    3 <= 3
 Sui valori booleani, true e false, è possibile compiere delle operazioni di carattere logico. Gli operatori principali sono i seguenti:
  • and    espresso come &&
  • or     espresso come ||
  • not    espresso come !
  • uguale espresso come ==
l'ultimo lo abbiamo già incontrato qui sopra ma ora lo vediamo in una luce diversa. Il comportamento di questi operatori può essere espresso attraverso tabelle specifiche, va specificato che essi lavorano esclusivamente su valori booleani:

and
true  and true   -> true
true  and false  -> false
false and true   -> false
false and false  -> false

or
true  or true   -> true
true  or false  -> true
false or true   -> true
false or false  -> false

not
not true  -> false
not false -> true

==
true  == true   -> true
false == true   -> false
true  == false  -> false
false == false  -> true

Non troverete l'implementazione di Xor ma potete implementarla facilmente, esempio rapido:

fn main() {
  a := true
  b := false
  xor_result := (a && !b) || (!a && b)
 (xor_result) // true
}

potete ovviamente modificare il valore di a e b e vedere cosa succede.