Rust - from Mozilla

L'istruzione if           

Il ciclo oggetto di questo paragrafo è decisamente semplice in Rust, come del resto lo è negli altri linguaggi. Concettualmente si tratta dell'esecuzione di una certa azione, ovvero una sequenza di una o più istruzioni, al verificarsi di una condizione booleana, quindi una condizione il cui risultato è "vero" (true) o "falso (false). L'esecuzione può avvenire in 3 modalità, ne approfittiamo per evidenziare le due keyword coinvolte:

if condizione istruzioni

if condizione istruzioni
else istruzioni

if condizione istruzioni
else if condizione istruzioni
....
else istruzioni

a seconda della logica delle condizioni che possono verificarsi. Vediamo il tutto con un esempio "progressivo"

  Esempio 5.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
use std::io;
use std::io::prelude::*;
fn main()
{
  print!( "Inserisci un numero: ");
  io::stdout().flush().ok().expect("");
  let mut input01 = String::new();
  io::stdin().read_line(&mut input01);
  let x01: i32 = input01.trim().parse()
  .ok()
  .expect("Please type a number!");
  if x01 > 10
  {
    print!("Inserito numero > 10");
  }
}

Alla riga 12 abbiamo il nostro if in azione. la condizione è che x01 sia maggiore di 10 e in tal caso viene eseguita la riga 14 altrimenti il programma esce senza fare nulla. Come si vede if può sottendere una o più istruzioni racchiuse tra parentesi graffe. Diversamente da altri linguaggi le graffe sono obbligatorie anche in presenza di una sola istruzione, il che è una scelta che condivido.
Allarghiamo ora l'esempio:

  Esempio 5.2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
use std::io;
use std::io::prelude::*;
fn main()
{
  print!( "Inserisci un numero: ");
  io::stdout().flush().ok().expect("");
  let mut input01 = String::new();
  io::stdin().read_line(&mut input01);
  let x01: i32 = input01.trim().parse()
  .ok()
  .expect("Please type a number!");
  if x01 > 10
  {
    print!("Inserito numero > 10");
  }
  else
  {
    print!("Inserito un numero <= 10");
  }
}

in questo caso abbiamo introdotto un secondo branch che racchiude quanto non previsto nel precedente. Per allargare la casistica, presentando così il terzo caso, modifichiamo l'esempio in maniera radicale:

  Esempio 5.3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
use std::io;
use std::io::prelude::*;
fn main()
{
  print!( "Inserisci la tua eta': ");
  io::stdout().flush().ok().expect("");
  let mut input01 = String::new();
  io::stdin().read_line(&mut input01);
  let x01: i32 = input01.trim().parse()
  .ok()
  .expect("Please type a number!");
  if x01 <= 10
  {
    print!("Nido o asilo o le elementari");
  }
  else if (x01 > 10 && x01 < 14)
  {
    print!("Vai alla scuola secondaria");
  }
  else if (x01 >= 14 && x01 < 18)
  {
    print!("Sei alle superiori?");
  }
  else
  {
    print!("O sei all'UNI o hai finito la scuola... o stai mentendo");
  }
}

Questo è un esempio completo per quanto concerne le casistiche, tenete presente che potete avere quanti else if vi sono necessari, anche se sarebbe bene non eccedere in questo senso per questioni di leggibilità e manutenibilità dei vostri programmi. Se avete casistiche ampie in termini di possibilità vedremo un altro costrutto che fa al caso. Notate bene che le parentesi tonde alle righe 16 e 20, messe solo per evidenziare le condizioni sono in realtà opzionali, anzi il compilatore emette un warning segnalandovi che non sono necessarie.

Il nostro if nell'ambito di questo linguaggio è una vera e propria espressione. Questa quindi ha sempre un valore e questo coincide col valore del branch che viene eseguito. Vediamo come questo si può applicare in pratica:

  Esempio 5.4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
use std::io;
use std::io::prelude::*;
fn main()
{
  print!( "Inserisci un numero: ");
  io::stdout().flush().ok().expect("");
  let mut input01 = String::new();
  io::stdin().read_line(&mut input01);
  let x01: i32 = input01.trim().parse()
  .ok()
  .expect("Please type a number!");
  let y = if x01 % 2 == 0 {"pari"} else {"dispari"};
  print!("{}", y);
}

Quindi y assume il valore espresso dall'esito della valutazione della condizione.