Nella prima parte di questa serie, i nostri programmi sono stati scritti solo come una sequenza di dichiarazioni. Questa struttura limita fortemente ciò che possiamo fare. Supponiamo che tu stia progettando un programma che deve accedere agli utenti. Si consiglia di indirizzare un utente a una pagina se forniscono le credenziali corrette e le inviano a un'altra se non sono registrate.
Per fare ciò, è necessario utilizzare una struttura decisionale come un'istruzione if. Questo eseguirà un'azione solo in determinate condizioni. Se la condizione non esiste, l'azione non viene eseguita. In questo tutorial imparerai tutto sui condizionali.
Una singola istruzione if eseguirà un'azione se una condizione è vera. Se la condizione è falsa, il programma eseguirà l'istruzione successiva al di fuori del blocco if. Nell'esempio seguente, se l'espressione sta piovendo()
è vero, allora lo faremo putOnCoat ()
e putOnRainboots ()
poi vai fuori()
. Se sta piovendo()
è falso, il programma verrà eseguito solo vai fuori()
.
if (isRaining) putOnCoat (); putOnRainboots (); vai fuori();
Questa è la forma generale per scrivere una dichiarazione if:
se (condizione) dichiarazione; economico; eccetera.
Il condizione è un'espressione che ha il valore true o false. Un'espressione che è vera o falsa è detta espressione booleana. Le espressioni booleane sono fatte con operatori relazionali.
Un operatore relazionale confronta due valori e determina se la relazione tra loro è vera o falsa. Possono essere usati per creare espressioni booleane per le nostre condizioni. Ecco un elenco di operatori relazionali con esempi:
Operatore | Senso | Esempio | Senso |
---|---|---|---|
== | uguaglianza | x == y | X è uguale a y? |
=== | uguaglianza rigorosa | x === y | X è uguale a y in valore e tipo? |
!= | disuguaglianza | x! = y | X non è uguale a y? |
!== | rigorosa disuguaglianza | x! == y | X non è uguale a y in valore e tipo? |
> | più grande di | x> y | È x maggiore di y? |
< | meno di | X < y | È x meno di y? |
> = | Maggiore o uguale | x> = y | X è maggiore o uguale a y? |
<= | inferiore o uguale | X <= y | È x minore o uguale a y? |
È importante notare la differenza tra l'operatore di uguaglianza ==
e l'operatore rigoroso di uguaglianza ===
. Ad esempio, l'espressione 2 == "2"
è vero. Ma l'espressione 2 === "2"
è falso. Nel secondo esempio, i due valori sono tipi di dati diversi ed è per questo che l'espressione è falsa. È la migliore pratica da usare ===
o !==
.
Nell'esempio seguente verrà visualizzato il messaggio "Ottieni una A".
let grade = 93; if (grade> = 90) console.log ("Ottieni una A");
Qual è il valore dell'espressione 5> 3? 6! = "6"?
Un'istruzione if-else eseguirà un blocco di istruzioni se la sua condizione è vera o un altro blocco se la sua condizione è falsa. L'esempio seguente mostrerà il messaggio "username valido" perché la condizione è vera.
let username = "alberta"; if (username === "alberta") console.log ("username valido"); else console.log ("Nome utente errato. Riprova.");
Questa è la forma generale di un'istruzione if-else:
se (condizione) dichiarazione; economico; ecc. else istruzione; economico; eccetera.
Quale sarà l'output di questo programma:
let isLoggedIn = false; if (isLoggedIn) console.log ("Benvenuto"); else console.log ("Non hai effettuato l'accesso");
È anche possibile verificare più di una condizione. Esempio:
let num = 3; if (num === 1) console.log ("I"); else if (num === 2) console.log ("II"); else if (num === 3) console.log ("III"); else if (num === 4) console.log ("IV"); else if (num === 5) console.log ("V"); else console.log ("input non valido");
Questa è la forma generale per scrivere più istruzioni if-else-if:
if (condition1) statement; economico; ecc. else if (condition2) statement; economico; ecc. else istruzione; economico; eccetera.
Un'istruzione switch è anche usata per eseguire condizionatamente parte del tuo programma. L'esempio seguente implementa il nostro convertitore di numeri romani come un'istruzione switch:
let num = 3; switch (num) case 1: console.log ("I"); rompere; caso 2: console.log ("II"); rompere; caso 3: console.log ("III"); rompere; caso 4: console.log ("IV"); rompere; caso 5: console.log ("V"); rompere; default: console.log ("input non valido");
Questa è la forma generale di un'istruzione switch:
switch (espressione) case value1: statement; economico; ecc. rompere; caso valore2: istruzione; economico; ecc. rompere; default: statement; economico; eccetera.
Ogni caso rappresenta un valore che la nostra espressione può assumere. Verrà eseguito solo il blocco di codice per il caso vero. Includiamo un'istruzione break alla fine del blocco di codice in modo che il programma esca dall'istruzione switch e non esegua altri casi. Il caso predefinito viene eseguito quando nessuno degli altri casi è true.
Scrivi un'istruzione switch che visualizza il giorno della settimana con un numero. Ad esempio, 1 = domenica, 2 = lunedì, ecc.
L'operatore e &&
e l'operatore o ||
permettici di connettere due espressioni booleane. L'operatore non !
nega un'espressione. Per illustrare come funzionano gli operatori logici, esamineremo una tabella di verità. Una tabella di verità contiene tutte le combinazioni di valori utilizzate con gli operatori. Io uso P per rappresentare l'espressione della mano sinistra e Q per l'espressione della mano destra.
&&
tavolo della verità:
P | Q | P && Q |
---|---|---|
vero | vero | vero |
vero | falso | falso |
falso | vero | falso |
falso | falso | falso |
Leggiamo il tavolo passando per ogni riga. La prima riga ci dice che quando P è vero e Q è vero, P && Q è vero. L'esempio seguente verifica se 82 è compreso tra 60 e 100 inclusi.
||
tavolo della verità:
P | Q | P || Q |
---|---|---|
vero | vero | vero |
vero | falso | vero |
falso | vero | vero |
falso | falso | falso |
Questo esempio verifica se 82 non rientra nell'intervallo 60-100:
!
tavolo della verità:
P | !P |
---|---|
vero | falso |
falso | vero |
Esempio:
Compila la tabella con i valori mancanti.
P | Q | !P | !Q | !P &&! Q | !P || ! Q |
---|---|---|---|---|---|
vero | vero | ||||
vero | falso | ||||
falso | vero | ||||
falso | falso |
Qualcosa di utile da sapere sugli operatori logici è che se l'espressione sul lato sinistro del &&
l'operatore è falso, l'espressione a destra non verrà controllata perché l'intera istruzione è falsa. E se l'espressione sul lato sinistro di un ||
l'operatore è vero, l'espressione a destra non verrà controllata perché l'intera affermazione è vera.
Un programma può eseguire condizionalmente blocchi di codice usando espressioni booleane. Un'espressione booleana viene scritta utilizzando operatori relazionali. Gli operatori logici ci consentono di combinare espressioni booleane.
Una singola istruzione if fornisce al programma un percorso alternativo da intraprendere se viene soddisfatta una condizione. Le istruzioni If-else forniscono una seconda linea d'azione se la condizione è falsa. E le dichiarazioni if-else-if ci permettono di testare più condizioni. Le istruzioni switch possono essere utilizzate in alternativa a un'istruzione if-else-if quando si verificano più condizioni.
Successivamente, nella parte 3, discuteremo i loop.