diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md index f8b15275c..8067c2a1d 100644 --- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md +++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md @@ -2,9 +2,9 @@ importance: 5 --- -# Qual'e il risultato dell'OR? +# Qual è il risultato dell'OR? -Che risultato restituirà il codice qui sotto? +Quale sarà il risultato del codice sotto? ```js alert( null || 2 || undefined ); diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md index ff9f9b9da..99241bd73 100644 --- a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md +++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md @@ -4,10 +4,10 @@ La risposta: prima `1`, poi `2`. alert( alert(1) || 2 || alert(3) ); ``` -La chiamata ad `alert` non ritorna alcun valore. In altre parole, ritorna `undefined`. +La chiamata ad `alert` non ritorna alcun valore; ossia `undefined`. -1. Il primo OR `||` valuta il suo operando sinistro `alert(1)`. Questo mostra il primo messaggio con `1`. -2. La funzione `alert` ritorna `undefined`, quindi OR prosegue con il secondo operando alla ricerca di un valore vero. +1. Il primo OR `||` valuta l'operando sinistro `alert(1)`. Questo mostra il primo messaggio, `1`. +2. La funzione `alert` ritorna `undefined`, quindi OR prosegue con il secondo operando, alla ricerca di un valore vero. 3. Il secondo operando `2` è vero; quindi l'esecuzione si ferma, viene ritornato `2` e mostrato dall'alert esterno. Non ci sarà il `3`, perchè la valutazione non arriva a `alert(3)`. diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md index eb9f3ef4d..59216589c 100644 --- a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md +++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md @@ -2,9 +2,9 @@ importance: 3 --- -# Qual'è il risultato dell'alert con l'OR? +# Qual è il risultato dell'alert con l'OR? -Cosa stampa il codice qui sotto? +Cosa mostrerà il codice sotto? ```js alert( alert(1) || 2 || alert(3) ); diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md index 8c73f5d56..f221e6c2e 100644 --- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md +++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md @@ -2,7 +2,7 @@ importance: 5 --- -# Qual'è il risultato dell'AND? +# Qual è il risultato dell'AND? Cosa mostrerà l'esecuzione di questo codice? diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md index c1d39e0e8..6b0d58e00 100644 --- a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md +++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md @@ -4,7 +4,7 @@ La risposta è: `1`, e poi `undefined`. alert( alert(1) && alert(2) ); ``` -La chiamata `alert` ritorna `undefined` (mostra solo un messaggio, quindi non ha nessuna valore di ritorno significativo). +La chiamata `alert` ritorna `undefined` (mostra solo un messaggio, quindi non ha nessuna valore significativo di ritorno). -Per questo `&&` valuta l'operando di sinistra (che mostra `1`), e si ferma immediatamente, perchè `undefined` è un valore falso. AND `&&` cerca un valore falso e lo ritorna. +Per questo `&&`, valutato l'operando di sinistra (che mostra `1`), si ferma: `undefined` è un valore falso e `&&` lo ritorna immediatamente. diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md index 9d276beb5..5c435a17e 100644 --- a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md +++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md @@ -2,7 +2,7 @@ importance: 3 --- -# Qual'è il risultato degli alert? +# Qual è il risultato degli alert? Cosa mostrerà questo codice? diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md index dd854f726..760471fdd 100644 --- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md +++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md @@ -2,8 +2,8 @@ importance: 3 --- -# Controlla l'intervallo esternamente +# Controlla l'intervallo fuori -Scrivi una condizione `if` che controlli la variabile `age`, questa NON deve essere compresa tra `14` e `90`, estremi inclusi. +Scrivi una condizione `if` che controlli la variabile `age`; questa NON deve essere compresa tra `14` e `90` (inclusi). Scrivi due varianti: la prima utilizzando NOT `!`, la seconda -- senza. diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md index 1c30697ea..5804953fc 100644 --- a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md +++ b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md @@ -3,17 +3,17 @@ La risposta: il primo e il terzo verranno eseguiti. I dettagli: ```js run -// Runs. -// The result of -1 || 0 = -1, truthy +// Viene eseguito +// Il risultato di -1 || 0 = -1 è vero if (-1 || 0) alert( 'first' ); -// Doesn't run -// -1 && 0 = 0, falsy +// Non viene eseguito +// -1 && 0 = 0, falso if (-1 && 0) alert( 'second' ); -// Executes -// Operator && has a higher precedence than || -// so -1 && 1 executes first, giving us the chain: +// Eseguito +// L'operatore && ha la precedenza su ||, +// quindi -1 && 1 vengono eseguiti per primi; la catena dentro `if` diventa: // null || -1 && 1 -> null || 1 -> 1 if (null || -1 && 1) alert( 'third' ); ``` diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md index c308e75e1..9def51940 100644 --- a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md +++ b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md @@ -2,11 +2,11 @@ importance: 5 --- -# Una indovinello con "if" +# Un indovinello con "if" Quali di questi `alert` verranno eseguiti? -Quale sarà il risultato dell'espressione all'interno di `if(...)`? +Quale sarà il risultato delle espressioni all'interno dei vari `if(...)`? ```js if (-1 || 0) alert( 'first' ); diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md index 055bdff56..7d9afdf29 100644 --- a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md +++ b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md @@ -6,20 +6,20 @@ importance: 3 Scrivi il codice che richiede un login tramite `prompt`. -Se l'utente digita `"Admin"`, allora si richiede una password tramite `prompt`, se l'input è una stringa vuota o `key:Esc` -- mostra "Canceled.", se invece è un'altra stringa -- allora mostra "I don't know you". +Se l'utente digita `"Admin"`, si richiede una password tramite `prompt`; se l'input è una stringa vuota o `key:Esc` -- mostra "Canceled."; se è diversa da `"Admin"`, mostra "I don't know you". -La passoword viene controllata con le seguenti regole: +La passoword viene controllata secondo i seguenti criteri: -- Se è uguale a "TheMaster", allora mostra "Welcome!", -- Un'altra stringa -- mostra "Wrong password", -- Per una stringa vuota o `key:Esc`, mostra "Canceled." +- Se è uguale a "TheMaster", mostra "Welcome!", +- Un stringa diversa da "TheMaster" -- mostra "Wrong password", +- Una stringa vuota o `key:Esc` -- mostra "Canceled." Lo schema: ![](ifelse_task.svg) -Utilizzate blocchi `if` annidati. Tenete a mente anche la leggibilità del codice. +Utilizza blocchi `if` annidati e tieni a mente la leggibilità del codice. -Suggerimento: passare un input vuoto tramite prompt ritorna una stringa vuota `''`. Premere `key:ESC` con prompt aperto ritorna `null`. +Suggerimento: passare un input vuoto tramite prompt ritorna una stringa vuota `''`. Premere `key:ESC` metre il prompt è aperto ritorna `null`. [demo] diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md index 5fda35104..feedabaf4 100644 --- a/1-js/02-first-steps/11-logical-operators/article.md +++ b/1-js/02-first-steps/11-logical-operators/article.md @@ -1,8 +1,8 @@ # Operatori logici -In JavaScript ci sono tre operatori logici: `||` (OR), `&&` (AND), `!` (NOT). +In JavaScript ci sono tre operatori logici: `||` (OR), `&&` (AND), e `!` (NOT). -Nonostante si chiamino "logici", possono essere applicati a valori di qualsiasi tipo, non solo ai booleani. Il risultato stesso può essere di qualunque tipo. +Nonostante si chiamino "logici", possono essere applicati a valori di qualsiasi tipo, non solo ai booleani (i risultati stessi possono essere di qualunque tipo). Vediamoli nei dettagli. @@ -14,9 +14,9 @@ L'operatore "OR" viene rappresentato da due linee verticali: result = a || b; ``` -Nella programmazione classica, l'OR logico è pensato per manipolare solo tipi booleani. Se almeno un argomento è `true`, allora il risultato sarà `true`, altrimenti sarà `false`. +Nella programmazione classica, l'OR logico è utilizzato per manipolare solo tipi booleani. Se almeno un argomento è `true`, allora il risultato sarà `true`, altrimenti sarà `false`. -In JavaScript questo operatore è un pò più potente. Ma prima guardiamo come si comporta con valori booleani. +In JavaScript questo operatore è un po' più potente. Ma prima vediamo come si comporta con i valori booleani. Ci sono quattro combinazioni logiche possibili: @@ -27,11 +27,11 @@ alert( true || false ); // true alert( false || false ); // false ``` -Come possiamo vedere, il risultato è sempre `true` tranne nei casi in cui entrambi gli operandi sono `false`. +Come possiamo vedere, il risultato è sempre `true`, tranne nei casi in cui entrambi gli operandi sono `false`. -Se un operando non è booleano, allora viene convertito in booleano per essere valutato. +Se un operando non è di tipo booleano, allora viene momentaneamente convertito per la valutazione. -Ad esempio, il numero `1` viene visto come `true`, il numero `0` -- come `false`: +Ad esempio, il numero `1` viene considerato come `true`, il numero `0` come `false`: ```js run if (1 || 0) { // funziona proprio come ( true || false ) @@ -60,7 +60,7 @@ let hour = 12; let isWeekend = true; if (hour < 10 || hour > 18 || isWeekend) { - alert( 'The office is closed.' ); // è il fine settimana + alert( 'The office is closed.' ); // l'Ufficio è chiuso } ``` @@ -68,9 +68,9 @@ if (hour < 10 || hour > 18 || isWeekend) { La logica descritta sopra è ovvia. Adesso proviamo ad addentrarci in qualche caratteristica "extra" di JavaScript. -Si può estendere l'algoritmo come segue: +Si può estendere l'algoritmo come segue. -Dando molti valori tramite OR: +Dati svariati operandi: ```js result = value1 || value2 || value3; @@ -79,12 +79,12 @@ result = value1 || value2 || value3; L'operatore OR `||` si comporta come segue: - Valuta gli operandi da sinistra a destra. -- Ogni operando viene converito in booleano. Se il risultato è `true`, allora si ferma e ritorna il valore originale dell'operando. -- Se tutti gli altri operandi sono stati valutati (ad esempio tutti erano `false`), ritorna l'ultimo operando. +- Ogni operando viene convertito a booleano. Se il risultato è `true`, il logical OR si ferma e ritorna il valore originale dell'operando. +- Se tutti gli operandi sono stati valutati e nessuno è `true`, ritorna l'ultimo operando. Un valore viene ritornato nella sua forma originale, non nella sua conversione booleana. -In altra parole, una catena di OR `"||"` ritorna il primo valore vero, se invece non ce ne sono ritorna l'ultimo valore trovato. +In altre parole, una catena di OR `"||"` ritorna il primo valore vero; se invece non ce ne sono ritorna l'ultimo valore. Ad esempio: @@ -97,13 +97,13 @@ alert( null || 0 || 1 ); // 1 (il primo valore true) alert( undefined || null || 0 ); // 0 (tutti falsi, ritorna l'ultimo valore) ``` -Questo ci porta ad alcuni utilizzi interessanti rispetto al "puro e classico OR booleano".boolean-only OR". +Questo ci permette alcuni utilizzi interessanti rispetto al "puro e classico OR booleano"boolean-only OR". -1. **Prelevare il primo valore vero da una lista di variabili o espressioni.** +1. **Trovare il primo valore vero in una lista di variabili o espressioni.** - Immaginiamo di avere diverse variabili, `firstName`, `lastName` e `nickName`, tutti opzionali (possono quindi essere undefined o avere valori falsi). + Immaginiamo di avere diverse variabili, `firstName`, `lastName` e `nickName`, tutte opzionali (possono quindi essere *undefined* o avere valori falsi). - Possiamo utilizzare OR `||` per selezionare quello che contiene il valore e mostrarlo (oppure mostrare `"Anonymous"` se nessun valore è settato): + Possiamo utilizzare OR `||` per selezionare quella che contiene un valore e mostrarlo (oppure mostrare `"Anonymous"` se nessua variabile è definita): ```js run let firstName = ""; @@ -119,27 +119,17 @@ Questo ci porta ad alcuni utilizzi interessanti rispetto al "puro e classico OR 2. **Valutazione a Corto-Circuito.** - Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. OR valuta ed esegue i test da sinistra a destra. La valutazione si ferma al primo risultato vero, questo viene poi ritornato. Il processo è chiamato "valutazione a corto-circuito", perchè cerca di terminare il prima possibile partendo da sinistra verso destra. + Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. L'operatore OR esegue la valutazione da sinistra a destra e si ferma al primo risultato vero, il quale viene ritornato. Il processo è chiamato "valutazione a corto-circuito" perché cerca di concludersi il prima possibile, senza dover elaborare tutti gli operandi. - Questo si vede chiaramente quando il secondo argomento causerebbe side-effect. Come l'assegnazione di una variabile. - - Se proviamo ad eseguire l'esempio che segue, `x` non verrà assegnata: - - alert(x); // undefined, perché (x = 1) non viene valutato - ``` - - Se invece il primo argomento è `false`, allora `||` prosegue e valuta il secondo, in questo caso l'assegnazione funziona: + Il logical OR è particolarmente utile quando il secondo argomento causerebbe un *side-effect* come l'assegnazione di una variabile o la chiamata a una funzione. + Nell'esempio che segue solo il secondo messaggio verrà mostrato. ```js run no-beautify *!*true*/!* || alert("not printed"); *!*false*/!* || alert("printed"); ``` - - Un'assegnazione è un caso semplice. Potrebbero essere coinvolti altri tipi di side-effect. - - Quello che abbiamo visto, è un "modo breve di fare `if`". Il primo operando viene convertito a booleano e solo se è falso viene eseguito il secondo. - - La maggior parte delle volte è meglio utilizzare un " `if` "regolare", per mantenere il codice leggibile, in alcuni casi però può risultare utile. + Nella prima linea l'operatore OR trova subito un valore vero e ferma immediatamente la valutazione, quindi *alert* non viene eseguito. + Si può utilizzare questa funzionalità per eseguire un commando nel caso in cui la prima parte della condizione sia falsa. ## && (AND) @@ -178,9 +168,9 @@ if (1 && 0) { // valutato come true && false ``` -## AND "&& trova il primo valore falso +## AND "&&" trova il primo valore falso -Fornire più valori AND: +Dati svariati operandi: ```js result = value1 && value2 && value3; @@ -189,12 +179,12 @@ result = value1 && value2 && value3; L'operatore AND `&&` si comporta come segue: - Valuta gli operandi da sinistra a destra. -- Ogni operando viene convertito in booleano. Se il risultato è `false`, si ferma e ritorna il valore originale dell'operando. -- Se tutti gli operandi precedenti sono stati valutati (ad esempio nel caso siano tutti veri) , ritorna l'ultimo operando. +- Ogni operando viene convertito a booleano. Se il risultato è `false`, si ferma e ritorna il valore originale dell'operando. +- Se tutti gli operandi precedenti sono stati valutati e nessuno è `false`, ritorna l'ultimo operando. -In altre parole, AND ritorna il primo valore falso se lo trova, altrimenti ritorna l'ultimo valore. +In altre parole, AND ritorna il primo valore falso, altrimenti ritorna l'ultimo valore. -Le regole sono molto simili a quelle dell'OR. La differenza è che AND ritorna il primo valore *falso* mentre OR ritorna il primo valore *VERO*. +Le regole sono molto simili a quelle dell'OR. La differenza è che AND ritorna il primo valore *falso* mentre OR ritorna il primo valore *vero*. Esempi: @@ -210,7 +200,7 @@ alert( null && 5 ); // null alert( 0 && "no matter what" ); // 0 ``` -Possiamo anche passare diversi valori in una sola riga. Vediamo come viene ritornato il primo valore falso: +Possiamo anche passare diversi valori in una sola riga. Nota come il primo valore falso viene ritornato non appena raggiunto: ```js run alert( 1 && 2 && null && 3 ); // null @@ -225,7 +215,7 @@ alert( 1 && 2 && 3 ); // 3, l'ultimo ````smart header="Precedenza di AND `&&` è maggiore dell'OR `||`" La precedenza dell'operatore AND `&&` è maggiore di quella dell'OR `||`. -Quindi il codice `a && b || c && d` esegue in maniera analoga all'espressione: `(a && b) || (c && d)`. +Quindi il codice `a && b || c && d` è analogo all'espressione: `(a && b) || (c && d)`. ```` ````warn header="Non rimpiazzate `if` con `||` o `&&`" @@ -242,7 +232,7 @@ let x = 1; Le azioni nella parte destra di `&&` vengono eseguite solamente se la valutazione non si ferma prima. Cioè: solo se `(x > 0)` è vera. -Quindi sostanzialmente è analogo a: +Il codie sopra è sostanzialmente analogo a: ```js run let x = 1; @@ -253,6 +243,7 @@ if (x > 0) alert( 'Greater than zero!' ); La variante con `&&` sembra essere più corta. Ma l'istruzione `if` è più ovvia e tende ad essere più leggibile. Quindi è consigliato usare ogni costrutto solo per i suoi scopi. Usate un `if` se volete imporre una condizione. Utilizzate invece `&&` se volete un AND. +```` ## ! (NOT) @@ -266,7 +257,7 @@ result = !value; L'operatore accetta un solo argomento e si comporta come segue: -1. Converte l'operando al tipo booleano: `true/false`. +1. Converte l'operando a booleano: `true/false`. 2. Ritorna il valore inverso. Ad esempio: @@ -283,13 +274,13 @@ alert( !!"non-empty string" ); // true alert( !!null ); // false ``` -Quello che accade è che il primo NOT converte il tipo a booleano e ritorna il suo inverso, il secondo NOT lo inverte nuovamente. Alla fine abbiamo un valore di tipo booleano. +Quello che accade è che il primo NOT converte l'operando a booleano e ritorna il suo inverso, e il secondo NOT lo *inverte nuovamente*. Il risultato è un valore di tipo booleano. -C'è un modo molto più lungo per fare la stessa cosa -- una funzione del linguaggio `Boolean`: +C'è un modo molto più lungo per fare la stessa cosa, usare la funzione `Boolean`, integrata in JavaScript: ```js run alert( Boolean("non-empty string") ); // true alert( Boolean(null) ); // false ``` -La precedenza del NOT `!` è la più alta fra tutti gli operatori logici quindi viene sempre eseguita per prima, precede `&&`, `||`. +La precedenza del NOT `!` è la più alta fra tutti gli operatori logici; viene sempre eseguita per prima e precede sia `&&` che `||`. pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy