Noi programmatori chiaramente dobbiamo avere il controllo di quello che sta succedendo nel nostro codice e per questo il nostro stato titolo un po' simpatico, quindi saremo noi a dettare le condizioni.

Dunque che cosa sono le istruzioni condizionali è questa è una prima, un primo strumento tipico di tutti i linguaggi di programmazione che ci permette di eseguire determinate istruzioni, quindi un pezzo di codice solo se si verificano determinate condizioni, quindi è come una sorta di bivio all'interno del nostro programma.

Possiamo decidere di eseguire determinate istruzioni solo se si verifica una condizione, mentre se la condizione non è verificata.

Eseguire delle altre istruzioni.

Nello specifico in javascript un'istruzione condizionale si scrive con questa sintassi, quindi parola chiave che in italiano significa se aperta parentesi tonda e all'interno, inserisco la condizione che voglio verificare.

Se si verifica questa condizione, viene eseguito il blocco di istruzioni una quindi quello che si trova all'interno delle parentesi graffe.

Opzionalmente non è obbligatorio.

Possiamo aggiungere anche un pezzo di codice, un blocco di istruzioni da eseguire se la condizione falsa.

Quindi se non viene verificata, questo si può fare aggiungendo la keyword bells e aprendo nuovamente le parentesi graffe per inserire il blocco di istruzioni da eseguire.

Capiamo ora che cos'è una condizione.

Una condizione è un'espressione che equivale tru oppure fools.

Quindi Tru in italiano significa vero ed è una condizione verificata.

Folks invece in italiano significa falso.

Quando la condizione non è verificata, che cosa possiamo inserire all'interno della nostra condizione? Possiamo andare a inserire un confronto, ad esempio tra due valori.

Quindi, se volessimo verificare se una variabile contiene o non contiene un determinato valore, possiamo ad esempio utilizzare l'operatore di uguaglianza o di diversità.

La cosa importante l'operatore di uguaglianza è formato da il doppio simbolo di uguale.

Abbiamo visto nelle elezioni precedenti che per creare una variabile e per assegnare un valore ad una variabile, utilizziamo il simbolo di uguale.

Quindi per verificare se una variabile corrisponde ad un valore.

Quindi, se è uguale ad un valore, dobbiamo utilizzare il doppio simbolo di uguale perché l'uguale singolo è l'assegnazione di un valore.

Quindi, ad esempio, questo è scritto in italiano Se una variabile x è uguale a tre, allora la condizione x vuole uguale falso.

Esci allora la condizione x vuole uguale.

Quattro è falsa.

Perché? Perché la variabile X contiene il valore tre.

Se io prendo il valore di x, che è tre e lo pongo uguale a quattro.

Chiaramente questa uguaglianza non è verificata, quindi equivale al falso.

Con la diversità si va a utilizzare il simbolo di punto esclamativo uguale quindi ancora una volta se una variabile x che contiene il valore tre vado a verificare se il valore della variabile x è diverso da quattro e questa è un'espressione verificata perché tre è diverso da quattro.

Quindi l'espressione x diverso da quattro è vera.

Poi abbiamo dei simboli a cui siamo un pochettino più abituati, soprattutto nell'algebra nella matematica che sono il maggiore e il minore maggiore uguale o minore uguale e questi funzionano chiaramente come nella matematica.

Quindi se ho sempre una variabile x è uguale a tre.

Cerco di verificare se x é maggiore di quattro e questo chiaramente falso perché tre non è maggiore di quattro e via dicendo.

Quindi sempre con x uguale a tre x minori di quattro è vero x maggiore o uguale a quattro è falso e x minore uguale a quattro.

È vero, vediamo subito un esempio riprendo il mio ds code dove abbiamo già appunto html compilato e lo script collegato in fondo al body ora HTML non ci serve.

Lavoreremo solo col già scritto, quindi posso chiudere questa finestra.

Verifichiamo col JavaScript che il foglio sia collega sia collegato correttamente per fare questo.

Questa è una buona norma.

Verificare che il foglio sia già il nostro file già va ascritto sia collegato al nostro file HTML in modo da non dover cominciare a scrivere codici e vedere che non funziona.

E invece il motivo per cui non funzionava era semplicemente che non avevamo collegato correttamente il file.

Quindi J S.

Ok, facciamo una semplice stampa.

Aggiorniamo la pagina, troviamo la stampa in console.

Questo vuol dire che il file già scritto è collegato correttamente.

Ora facciamo un esempio con le nostre istruzioni condizionali abbiamo detto creiamo una variabile consta x uguale a tre, quindi consta x è una variabile costante a cui stiamo assegnando il valore tre.

Quindi all'interno di questa scatolina con un'etichetta x, cioè il valore tre.

Se ora andiamo a verificare il contenuto di questa variabile, quindi, ad esempio X uguale uguale a tre, stiamo andando a verificare se il contenuto della variabile X equivale al valore tre.

Quindi facciamo sempre una stampa X contiene tre.

Se queste questa condizione viene verificata.

Vediamo la stampa in console, aggiorniamo la pagina e in effetti troviamo in console la scritta X contiene il valore tre.

Se ad esempio io modificasse il valore di x e lo ponessi uguale a quattro, ora questa condizione non dovrebbe più essere verificata e quindi non dovrei vedere la stampa in console.

Aggiorniamo e in effetti la stampa in console sparisce.

Abbiamo detto che possiamo anche eseguire un blocco di istruzioni nel momento in cui la condizione non viene verificata.

Quindi, ad esempio, Consob blog X non contiene, non contiene tra aggiorno la pagina e ora trovo la scritta X non contiene tre che corrisponde proprio al blocco di istruzioni contenute nel ramo ex.

Quindi la condizione non è verificata.

Significa che il primo blocco di istruzioni non viene eseguito e al suo posto viene eseguito il secondo blocco di istruzioni, quello inserito all'interno del blocco else.

Vediamo ora come poter concatenare più condizioni, come poter unire più condizioni.

Quindi in questo caso entrano in gioco le espressioni Boo Lehane e da qui il nostro nome.

Chiaramente quindi questa espressione Boo lehane possono essere di diversi tipi.

Ad esempio possiamo utilizzare gli operatori binari, gli operatori binari come funzionano, uniscono due espressioni e valutano il risultato complessivo di queste espressioni.

Il primo operatore binario è l'operatore end, che in italiano sarebbe la e quindi una e logica come funziona l'operatore hand restituisce vero, quindi l'espressione completa corrisponde al vero solo se entrambi gli operandi sono veri.

Quindi le du il le due espressioni che io sto unendo con l'operatore hand sono entrambe vere nello stesso momento.

Quindi ipotizzando di avere due variabili, una variabile x uguale a tre é una variabile y uguale a quattro l'espressione x minore di quattro e y maggiore di cinque è falsa.

Analizziamo la x minore di quattro.

Il valore di x è tre, quindi ponendo x che contiene il valore tre minore di quattro.

Questa prima parte è vera perché tre è minore di quattro.

Se poi analizziamo la seconda parte Y maggiore di cinque il valore, il valore di y abbiamo detto essere quattro, quindi quattro maggiore di cinque è certamente falso.

Quindi, nonostante avessimo la prima espressione vera, nonostante avessimo la prima espressione vera, la seconda espressione è falsa.

Quindi unendo un'espressione vera e un'espressione falsa, il risultato complessivo è falso con l'operatore logico or quindi la o logica in italiano si ottiene vero, quindi il risultato complessivo dell'espressione è vera se almeno uno degli operandi è vero.

Quindi è sufficiente che una delle due espressioni che io collego con la or sia vera per risultare vero.

Nel complesso, quindi utilizzando sempre le nostre variabili x uguale a tre y uguale a quattro, otteniamo che x minore di quattro or y maggiore di cinque risulta essere vero perché come abbiamo detto x minore di quattro dove x vale tre è verificata e nonostante y maggiore di cinque sia falsa perché quattro non è maggiore di cinque il complesso.

Il risultato complessivo di questa operazione è vera, perché la prima è la prima espressione è verificata ed è sufficiente che una delle due sia vera per risultare vera.

Nel complesso.

Quindi, per utilizzare questi operatori logici all'interno delle nostre istruzioni condizionali, possiamo andare a modificare, ad esempio, ad aggiungere ad esempio alle nostre EAV questi operatori per verificare due condizioni contemporaneamente.

Quindi, se prima avevamo una semplice EAV che verificava una un'uguaglianza su una singola variabile, ora possiamo ad esempio verificare l'uguaglianza su due variabili differenti e solamente se entrambe le uguaglianze sono verificate eseguire le istruzioni all'interno, quindi in questo specifico esempio abbiamo x uguale uguale a tre.

Quindi stiamo verificando se la variabile x contiene il valore tre é la variabile y contiene il valore quattro, quindi solamente se la variabile x contiene tre e contemporaneamente la variabile y contiene il valore quattro, viene eseguito il blocco del ramo iefp.

Se questa queste due condizioni non sono verificate o x è diverso da tre oppure y è diverso da quattro.

Questo è sufficiente per non eseguire il codice ed eseguire eventualmente il ramo elsa nel caso in cui fosse presente, facciamo un esempio anche con gli operatori logici.

Riprendendo l'esempio di prima abbiamo una variabile x che é uguale a quattro.

Abbiamo già verificato che questa eav falsificata perché quattro non è uguale a tre, quindi questa eav non viene eseguita com.

Quindi questa condizione all'interno dell'aif viene valutata come falsa e di conseguenza viene eseguito Samuels.

Ora, volendo fare un esempio con due variabili, quindi creiamo una variabile consta y uguale a cinque.

Ad esempio, andiamo a vedere come combinare due due espressioni per ottenere un operatore per ottenere un'espressione più complessa.

Quindi, ad esempio, se volessimo verificare che X sia maggiore di tre e y sia minore di dieci.

Quindi nel nostro caso la X vale quattro, quindi quattro è certamente maggiore di tre e la y sia minore di dieci y vale cinque, quindi certamente minori di dieci.

Ora potremmo modificare queste queste stampe in console.

Scrivere iksen maggiore di tre y eh minore di dieci ok nel ramo ex sappiamo che andiamo a finire se una delle due è falsa.

Perché? Perché solamente se entrambe sono vere contemporaneamente viene eseguito il ramo eav.

Se una delle due non è verificata tutta l'espressione nel complesso diventa falsa e quindi viene eseguito.

Samuels quindi nel ramo è che cosa possiamo dire? Possiamo dire che x non è maggiore di tre oppure y non è minore di dieci, quindi una delle due non sappiamo quale delle due condizioni viene falsificata, perché quando il codice viene eseguito non lo possiamo sapere con certezza in ogni momento.

Chiaramente in questo caso noi abbiamo assegnato dei valori espliciti a queste variabili, ma nella realtà succederà che queste variabili dipendono da il contenuto della pagina dall'interazione dell'utente da eventi che vengono scatenati.

Quindi, aggiornando la nostra pagina che cosa otteniamo? Otteniamo che x é maggiore di tre e ye minore di dieci.

Quindi provando a sostituire il valore di x con ad esempio due due non è più maggiore di tre.

Quindi di conseguenza questo primo pezzo è falsificato.

Aggiorno la pagina e in effetti ora vediamo che solamente falsificando il primo pezzo otteniamo la stampa x non è maggiore di tre, oppure y è maggiore di non è minore di dieci y è cinque, quindi sarebbe minore di dieci, ma non è sufficiente per verificare l'intera espressione.

Possiamo anche modificare il valore di y por lo uguale a tredici.

Ad esempio, in questo caso sarebbero falsificate entrambe le espressioni.

Ancora una volta.

Se io riprendo la x e la pongo uguale a sei, ad esempio di nuovo ottengo la stampa del ramo elsa, perché in questo caso è x è maggiore di tre perché equivale a sei, ma la y è sempre superiore a dieci, quindi vediamo come è sufficiente che una delle due espressioni non si è verificata per falsificare l'intera espressione logica.

Vediamo ora un esempio con l'operatore ore e vediamo come cambia.

Quindi possiamo anche utilizzare le stesse espressioni di prima.

Quindi x é maggiore di tre or y minore di facciamo sempre una stampa e se questa condizione viene verificata.

Sappiamo che può dipendere anche solamente da una delle due espressioni.

Quindi perché è sufficiente che una delle due espressioni sia verificata per verificare l'intera espressione? Quindi che cosa possiamo dire? Che x è maggiore di tre oppure y è minore di dieci.

Una delle due è verificata e quindi l'intera espressione viene verificata.

Altrimenti l'unico modo per finire nel ramo ex è il caso in cui entrambe le espressioni siano false.

Quindi se entrambe sono false è l'espressione non viene verificata.

Quindi x è minore di tre oppure x non è maggiore di tre e y non è minore di dieci.

Quindi quando cadiamo nel ramo elsa in questo caso siamo sicuri che entrambe sono false, perché se una delle due fosse falsa sicuramente saremmo entrati nel ramo iff.

Andiamo a verificarlo quindi utilizzando sempre x uguale a sei e y uguale a tredici.

Che cosa abbiamo? Sei maggiori di tre è verificata e quindi l'intera espressione viene verificata.

Quindi x è maggiore di tre, oppure y è maggiore di dieci è minore di dieci nonostante y equivalga a tredici e quindi non è minore di dieci.

Comunque l'intera condizione è verificata perché x è maggiore di tre.

Se ora modifichiamo anche il valore di x e lo riportiamo ad esempio due ora vediamo che x non è maggiore di tre, perché in effetti è due e y non è minore di dieci perché tredici.

Vediamo come la band e la or siano complementari.

Quindi per verificare una ed è necessario che entrambe le condizioni siano verificate per verificare una or è sufficiente che una delle due condizioni sia verificata e quindi i rami fra i rami heels non sempre corrispondono chiaramente, perché il significato dell'espressione è differente.

Esiste poi un operatore logico chiamato notte.

Questo operatore è un operatore umanitario perché agisce su un'unica espressione.

Quindi non collega due espressioni, ma funziona solamente su un operatore.

Il note solitamente si usa per verificare Lynn contrario di un qualcosa, quindi è più facile a farsi che a dirsi.

Vediamo un esempio se abbiamo una variabile utente loggato, ad esempio, che equivale al falso, quindi l'utente non sia loggato nella nostra applicazione.

Quando noi andiamo ad utilizzare questa variabile booleana come espressione condizionale, essendo che contiene il valore FOOLS, questa EAV non è verificata perché se utente loggato equivale al falso, significa che l'espressione stessa equivale al falso, quindi il blocco non sarà eseguito.

Se però noi nella stessa situazione di prima con un utente loggato uguale fools andiamo a imporre la condizione not utente loggato, che cosa significa? Significa che stiamo andando a verificare se la variabile utente loggato contiene forse é utente loggato.

In effetti contiene il valore.

Forse quindi nel complesso l'espressione è verificata, quindi il blocco di istruzioni viene eseguito.

Facciamo un esempio commentiamo il codice visto in precedenza e creiamo una nuova variabile.

Quindi, ad esempio, ma usiamo lo stesso esempio, creiamo una nuova variabile, come abbiamo visto nell'esempio quindi utente loggato uguale.

Forse quindi abbiamo una una variabile booleana, quindi una variabile che può assumere il valore o tre, o forse ovvero o falso.

Quindi se ora andiamo a verificare il valore di utente loggato questa espressione che cosa significa? Significa vai a verificare che cosa contiene una variabile.

Se il contenuto della variabile equivale a tru, esegue il blocco di istruzioni.

Quindi ad esempio console log utente bloccato.

Altrimenti, se l'espressione all'interno dell'aif non è verificata.

Andiamo ad eseguire il Samuels e quindi significa che l'utente non è loggato.

Aggiorniamo la pagina.

In effetti troviamo in console la stampa utente non legato.

Quindi avendo posto la variabile uguale fools non viene eseguito ramo eav, ma viene eseguito il mio ex.

Se ora modifichiamo il valore di questa variabile e le assegniamo al valore tru in console troviamo la stampa utente loggato.

Quindi adesso si questa espressione viene verificata, quindi la condizione è vera e quindi esegue il primo blocco.

Ora facciamo un esempio con il note quindi se di nuovo o la variabile uguale fools e verifico notte utente loggato significa che come dire, come diremmo in italiano l'utente non è loggato.

Quindi questa cosa questa condizione è vera se utente loggato è uguale falso, questa condizione é falsificata.

Se l'utente è loggato, quindi è come fare all'incontrario come ribaltare la condizione.

Quindi l'utente non è loggato perché in effetti la nostra variabile è uguale a fool's.

Se ora pongo questa variabile uguale a tru cosa dovrebbe succedere? La variabile uguale a tre ma se io vado a negare tru diventa folks.

Quindi ottengo lynn contrario non vero è falso e quindi che succede? Succede che viene eseguito il mio ex andiamo a vedere e voi la otteniamo il console, la stampa utente allungato la stessa cosa la possiamo fare anche con gli operatori di uguaglianza che abbiamo visto poco fa.

Quindi se ad esempio io riprendo sempre la mia variabile const x uguale a tre, se io ora pongo x diverso da tre, mi sto chiedendo se è diverso da tre.

Quindi console log x è diverso da tre hans Consob blog.

Quindi se la condizione è falsa significa che x è uguale a tre.

Aggiorniamo la pagina e in effetti troviamo la stampa x è uguale a tre.

Che cosa sta succedendo? La mia variabile X contiene il valore tre nell'istruzione condizionale.

Mi sto chiedendo se il valore della variabile X è diverso da tre e questo è falso perché x è proprio tre.

Quindi l'espressione non è verificata e ancora una volta viene eseguito blocco ex.

Quindi abbiamo capito che l'operatore not ribalta quello che farebbe l'operatore di uguaglianza oppure falsifica la verità, quindi fa diventare il vero falso e il falso vero