--- schema_version: "1" id: e487e2cf1efa552579ea510fd58eb207aec15ce59119fcadd075235a4b9dd92d title: Funzioni logiche collection: tableau version: next locale: it-it portal_url: https://docs.salesforce.com/tableau/next/it-it/pro/desktop/functions_functions_logical.md canonical_url: https://help.tableau.com/v0.0/pro/desktop/it-it/functions_functions_logical.htm source_site: help.tableau.com content_type: documentation content_hash: b413c434d8637215e2a5ce0892964752b2dd0d8ba3ba59f93131595fa7182466 description: Reference for Tableau logical functions such as IF, CASE, and AND. --- [Passa al contenuto principale](#main-content) # Funzioni logiche Questo articolo illustra le funzioni logiche e i relativi utilizzi in Tableau. Mostra anche come creare un calcolo logico attraverso un esempio. ## Perché utilizzare i calcoli logici I calcoli logici ti consentono di determinare se una determinata condizione è vera o falsa (logica booleana). Ad esempio, potresti voler classificare i valori in base a determinati limiti. Un calcolo logico potrebbe presentarsi in questo modo: IF \[Profit\] > 0 THEN 'Profitable' ELSEIF \[Profit\] = 0 THEN 'Break even' ELSE 'Loss' END ## Funzioni logiche e operatori disponibili in Tableau ### AND

Sintassi	`<expr1> AND <expr2>`
Definizione	Esegue una congiunzione logica su due espressioni. Se entrambi i lati sono True, il test logico restituisce True.
Output	Booleano (True o False)
Esempio	IF [Season] = "Spring" AND "[Season] = "Fall" THEN "It's the apocalypse and footwear doesn't matter" END “Se sia (Season = Spring) e (Season = Fall) sono contemporaneamente True, viene restituito It’s the apocalypse and footwear doesn’t matter”.
Note	Spesso usato con IF e IIF. Vedi anche NOT e OR. Se entrambe le espressioni sono `TRUE` (ovvero, né `FALSE` né `NULL`), il risultato è `TRUE`. Se una delle due espressioni è `NULL`, il risultato è `NULL`. In tutti gli altri casi, il risultato è `FALSE`. Se crei un calcolo in cui il risultato di un confronto `AND` viene visualizzato in un foglio di lavoro, Tableau mostra `TRUE` e `FALSE`. Se desideri modificare questa impostazione, utilizza l’area Formato nella finestra di dialogo del formato. Nota: l’operatore `AND` sfrutta la valutazione a corto circuito. Questo significa che, se la prima espressione è valutata come `FALSE`, allora la seconda espressione non viene valutata affatto. Questo può essere utile se la seconda espressione si traduce in un errore quando la prima espressione è `FALSE`, in quanto la seconda espressione in questo caso non viene mai valutata.

### CASE

Sintassi	`CASE <expression> WHEN <value1> THEN <then1> WHEN <value2> THEN <then2> ... [ELSE <default>] END`
Output	Dipende dal tipo di dati dei valori `<then>`.
Definizione	Valuta l’espressione `expression` e la confronta con le opzioni specificate (`<value1>`, `<value2>` e così via). Quando rileva un valore `value` corrispondente all’espressione, CASE restituisce il valore `return` corrispondente. Se non trova alcuna corrispondenza, viene restituito il valore predefinito (facoltativo). Se non ci sono un valore predefinito né valori corrispondenti, viene restituito NULL.
Esempio	`CASE [Season] WHEN 'Summer' THEN 'Sandals' WHEN 'Winter' THEN 'Boots' ELSE 'Sneakers' END` “Controlla il campo Season. Se il valore è Summer, restituisci Sandals. Se il valore è Winter, restituisci Boots. Se nessuna delle opzioni nel calcolo corrisponde a quanto indicato nel campo Season, restituisci Sneakers.”
Note	Vedi anche IF e IIF. Utilizzato con WHEN, THEN, ELSE e END. [!TIP] Suggerimento: spesso è possibile utilizzare un gruppo per ottenere gli stessi risultati di una complicata funzione CASE oppure utilizzare CASE per sostituire la funzionalità di raggruppamento nativa, come nell’esempio precedente. Potresti eseguire test per determinare quale offre le migliori prestazioni per il tuo scenario.

### ELSE

Sintassi	`CASE <expression> WHEN <value1> THEN <then1> WHEN <value2> THEN <then2> ... [ELSE <default>] END`
Definizione	Una parte facoltativa di un’espressione `IF` o `CASE` utilizzata per specificare un valore predefinito da restituire se nessuna delle espressioni testate è True.
Esempio	IF [Season] = "Summer" THEN 'Sandals' ELSEIF [Season] = "Winter" THEN 'Boots' ELSE 'Sneakers' END CASE [Season] WHEN 'Summer' THEN 'Sandals' WHEN 'Winter' THEN 'Boots' ELSE 'Sneakers' END
Note	Utilizzato con CASE, WHEN, IF, ELSEIF, THEN e END `ELSE` è facoltativo con `CASE` e `IF`. In un calcolo dove `ELSE` non è specificato, se nessuna delle condizioni `<test>` è True, il calcolo complessivo restituirà Null. `ELSE` non richiede una condizione (ad esempio, `[Season] = "Winter"`) e può essere pensato come una forma di gestione dei valori Null.

### ELSEIF

Sintassi	`[ELSEIF <test2> THEN <then2>]`
Definizione	Una parte facoltativa di un’espressione `IF` utilizzata per specificare condizioni aggiuntive oltre l’IF iniziale.
Esempio	IF [Season] = "Summer" THEN 'Sandals' ELSEIF [Season] = "Winter" THEN 'Boots' ELSEIF [Season] = "Spring" THEN 'Sneakers' ELSEIF [Season] = "Autumn" THEN 'Sneakers' ELSE 'Bare feet' END
Note	Utilizzato con IF, THEN, ELSE e END `ELSEIF` può essere considerata una clausola `IF` aggiuntiva. `ELSEIF` è facoltativo e può essere ripetuto più volte. A differenza di `ELSE`, `ELSEIF` richiede una condizione (ad esempio, `[Season] = "Winter"`).

### END

Definizione Utilizzato per chiudere un’espressione IF o CASE.

Esempio

IF [Season] = "Summer" THEN 'Sandals' 
ELSEIF [Season] = "Winter" THEN 'Boots' 
ELSE 'Sneakers' 
END

“Se Season = Summer, restituisci Sandals. In caso contrario, controlla l’espressione successiva. Se Season = Winter, restituisci Boots. Se nessuna delle espressioni è True, restituisci Sneakers.”

CASE [Season] 
WHEN 'Summer' THEN 'Sandals' 
WHEN 'Winter' THEN 'Boots' 
ELSE 'Sneakers' 
END

“Controlla il campo Season. Se il valore è Summer, restituisci Sandals. Se il valore è Winter, restituisci Boots. Se nessuna delle opzioni nel calcolo corrisponde a quanto indicato nel campo Season, restituisci Sneakers.”

Note

Utilizzato con CASE, WHEN, IF, ELSEIF, THEN e ELSE.

### IF

Sintassi	`IF <test1> THEN <then1> [ELSEIF <test2> THEN <then2>...] [ELSE <default>] END`
Output	Dipende dal tipo di dati dei valori `<then>`.
Definizione	Testa una serie di espressioni e restituisce il valore `<then>` per il primo `<test>` True.
Esempio	IF [Season] = "Summer" THEN 'Sandals' ELSEIF [Season] = "Winter" THEN 'Boots' ELSE 'Sneakers' END “Se Season = Summer, restituisci Sandals. In caso contrario, controlla l’espressione successiva. Se Season = Winter, restituisci Boots. Se nessuna delle espressioni è True, restituisci Sneakers.”
Note	Vedi anche IF e IIF. Utilizzato con ELSEIF, THEN, ELSE e END

### IFNULL

Sintassi	`IFNULL(expr1, expr2)`
Output	Dipende dal tipo di dati dei valori `<expr>`.
Definizione	Restituisce `<expr1>` se non è Null, altrimenti `<expr2>`.
Esempio	IFNULL([Assigned Room], "TBD") “Se il campo Assigned Room non è Null, restituisci il relativo valore. Se il campo Assigned Room è Null, restituisci invece TBD.”
Note	Confronta con ISNULL. `IFNULL` restituisce sempre un valore. `ISNULL` restituisce un valore booleano (True o False). Vedi anche ZN.

### IIF

Sintassi	`IIF(<test>, <then>, <else>, [<unknown>])`
Output	Dipende dal tipo di dati dei valori nell’espressione.
Definizione	Controlla se una condizione è soddisfatta (`<test>`) e restituisce `<then>` se il test è True, `<else>` se il test è False e un valore facoltativo per `<unknown>` se il test è Null. Se il valore unknown facoltativo non è specificato, `IIF` restituisce Null.
Esempio	IIF([Season] = 'Summer', 'Sandals', 'Other footwear') “Se Season = Summer, restituisci Sandals. In caso contrario, restituisci Other footwear” IIF([Season] = 'Summer', 'Sandals', IIF('Season' = 'Winter', 'Boots', 'Other footwear') ) “Se Season = Summer, restituisci Sandals. In caso contrario, controlla l’espressione successiva. Se Season = Winter, restituisci Boots. Se nessuna delle due è True, restituisci Sneakers.” IIF('Season' = 'Summer', 'Sandals', IIF('Season' = 'Winter', 'Boots', IIF('Season' = 'Spring', 'Sneakers', 'Other footwear') ) ) “Se Season = Summer, restituisci Sandals. In caso contrario, controlla l’espressione successiva. Se Season = Winter, restituisci Boots. Se nessuna delle espressioni è True, restituisci Sneakers.”
Note	Vedi anche IF e CASE. `IIF` non ha un equivalente di `ELSEIF` (come `IF`) o clausole `WHEN` ripetute (come `CASE`). Più test possono invece essere valutati in sequenza mediante l’annidamento di istruzioni `IIF` come l’elemento `<unknown>`. Viene restituito il primo True (quello più esterno). In altre parole, nel calcolo seguente il risultato sarà Red, non Orange, perché l’espressione smette di essere valutata non appena A=A viene valutato come True: `IIF('A' = 'A', 'Red', IIF('B' = 'B', 'Orange', IIF('C' = 'D', 'Yellow', 'Green')))`

### IN

Sintassi	`<expr1> IN <expr2>`
Output	Booleano (True o False)
Definizione	Restituisce `TRUE` se qualsiasi valore in `<expr1>` corrisponde a qualsiasi valore in `<expr2>`.
Esempio	SUM([Cost]) IN (1000, 15, 200) “Il valore del campo Cost è 1000, 15 o 200?” [Field] IN [Set] “Il valore del campo è presente nell’insieme?”
Note	I valori in `<expr2>` possono essere un insieme, un elenco di valori letterali o un campo combinato. Vedi anche WHEN.

### ISDATE

Sintassi	`ISDATE(string)`
Output	Booleano (True o False)
Definizione	Restituisce True se una stringa `<string>` è una data valida. L’espressione di input deve essere un campo stringa (di testo).
Esempio	ISDATE("2018-09-22") “La stringa 2018-09-22 è una data formattata correttamente?”
Note	Ciò che viene considerato una data valida dipende dalle impostazioni locali del sistema che valuta il calcolo. Ad esempio: Negli Stati Uniti: `ISDATE("2018-09-22") = TRUE` `ISDATE("2018-22-09") = FALSE` Nel Regno Unito: `ISDATE("2018-09-22") = FALSE` `ISDATE("2018-22-09") = TRUE`

### ISNULL

Sintassi	`ISNULL(expression)`
Output	Booleano (True o False)
Definizione	Restituisce True se l’espressione `<expression>` è NULL (non contiene dati validi).
Esempio	ISNULL([Assigned Room]) “Il campo Assigned Room è Null?”
Note	Confronta con IFNULL. `IFNULL` restituisce sempre un valore. `ISNULL` restituisce un valore booleano. Vedi anche ZN.

### MAX

Sintassi	`MAX(expression)` oppure `MAX(expr1, expr2)`
Output	Stesso tipo di dati dell’argomento o `NULL` se qualsiasi parte dell’argomento è NULL.
Definizione	Restituisce il massimo dei due argomenti, che devono essere dello stesso tipo di dati. `MAX` può anche essere applicato a un singolo campo come aggregazione.
Esempio	MAX(4,7) = 7 MAX(#3/25/1986#, #2/20/2021#) = #2/20/2021# MAX([Name]) = "Zander"
Note	Per le stringhe `MAX` è solitamente l’ultimo valore in ordine alfabetico. Per le origini dati di database, `MAX` permette di trovare il valore stringa più alto nella sequenza di ordinamento definita dal database per quella colonna. Per le date Per le date, `MAX` è la data più recente. Se `MAX` è un’aggregazione, il risultato non avrà una gerarchia di date. Se `MAX` è un confronto, il risultato manterrà la gerarchia di date. Come aggregazione `MAX(expression)` è una funzione aggregata e restituisce un singolo risultato aggregato. Questo risultato viene mostrato come `AGG(expression)` nella visualizzazione. Come confronto `MAX(expr1, expr2)` confronta i due valori e restituisce un valore a livello di riga. Vedi anche `MIN`.

### MIN

Sintassi	`MIN(expression)` oppure `MIN(expr1, expr2)`
Output	Stesso tipo di dati dell’argomento o `NULL` se qualsiasi parte dell’argomento è NULL.
Definizione	Restituisce il minimo dei due argomenti, che devono essere dello stesso tipo di dati. `MIN` può anche essere applicato a un singolo campo come aggregazione.
Esempio	MIN(4,7) = 4 MIN(#3/25/1986#, #2/20/2021#) = #3/25/1986# MIN([Name]) = "Abebi"
Note	Per le stringhe `MIN` è solitamente il primo valore in ordine alfabetico. Per le origini dati di database, `MIN` permette di trovare il valore stringa più basso nella sequenza di ordinamento definita dal database per quella colonna. Per le date Per le date, `MIN` è la prima data. Se `MIN` è un’aggregazione, il risultato non avrà una gerarchia di date. Se `MIN` è un confronto, il risultato manterrà la gerarchia di date. Come aggregazione `MIN(expression)` è una funzione aggregata e restituisce un singolo risultato aggregato. Questo risultato viene mostrato come `AGG(expression)` nella visualizzazione. Come confronto `MIN(expr1, expr2)` confronta i due valori e restituisce un valore a livello di riga. Vedi anche `MAX`.

### NOT

Sintassi	`NOT <expression>`
Output	Booleano (True o False)
Definizione	Esegue una negazione logica su un’espressione.
Esempio	IF NOT [Season] = "Summer" THEN 'Don't wear sandals' ELSE 'Wear sandals' END “Se Season non è uguale a Summer, restituisci Don’t wear sandals. In caso contrario, restituisci Wear sandals.”
Note	Spesso usato con IF e IIF. Vedi anche AND e OR.

### OR

Sintassi	`<expr1> OR <expr2>`
Output	Booleano (True o False)
Definizione	Esegue una disgiunzione logica su due espressioni.
Esempio	IF [Season] = "Spring" OR [Season] = "Fall" THEN "Sneakers" END “Se (Season = Spring) o (Season = Fall) è True, restituisci Sneakers.”
Note	Spesso usato con IF e IIF. Vedi anche AND e NOT. Se una delle due espressioni è `TRUE`, il risultato è `TRUE`. Se entrambe le espressioni sono `FALSE`, il risultato è `FALSE`. Se entrambe le espressioni sono `NULL`, il risultato è `NULL`. Se crei un calcolo che visualizza il risultato di un confronto `OR` in un foglio di lavoro, Tableau mostra TRUE e FALSE. Se desideri modificare questa impostazione, utilizza l’area Formato nella finestra di dialogo del formato. Nota: l’operatore `OR` sfrutta la valutazione a corto circuito. Questo significa che, se la prima espressione è valutata come `TRUE`, allora la seconda espressione non viene valutata affatto. Questo può essere utile se la seconda espressione si traduce in un errore quando la prima espressione è `TRUE`, in quanto la seconda espressione in questo caso non viene mai valutata.

### THEN

Sintassi	`IF <test1> THEN <then1> [ELSEIF <test2> THEN <then2>...] [ELSE <default>] END`
Definizione	Una parte richiesta di un’espressione `IF`, `ELSEIF` o `CASE`, utilizzata per definire quale risultato restituire se un valore o un test specifico è True.
Esempio	IF [Season] = "Summer" THEN 'Sandals' ELSEIF [Season] = "Winter" THEN 'Boots' ELSE 'Sneakers' END “Se Season = Summer, restituisci Sandals. In caso contrario, controlla l’espressione successiva. Se Season = Winter, restituisci Boots. Se nessuna delle espressioni è True, restituisci Sneakers.” CASE [Season] WHEN 'Summer' THEN 'Sandals' WHEN 'Winter' THEN 'Boots' ELSE 'Sneakers' END “Controlla il campo Season. Se il valore è Summer, restituisci Sandals. Se il valore è Winter, restituisci Boots. Se nessuna delle opzioni nel calcolo corrisponde a quanto indicato nel campo Season, restituisci Sneakers.”
Note	Utilizzato con CASE, WHEN, IF, ELSEIF, THEN, ELSE e END

### WHEN

Sintassi	`CASE <expression> WHEN <value1> THEN <then1> WHEN <value2> THEN <then2> ... [ELSE <default>] END`
Definizione	Una parte richiesta di un’espressione `CASE`. Trova il primo `<value>` che corrisponde a `<expression>` e restituisce il valore `<then>` corrispondente.
Esempio	CASE [Season] WHEN 'Summer' THEN 'Sandals' WHEN 'Winter' THEN 'Boots' ELSE 'Sneakers' END “Controlla il campo Season. Se il valore è Summer, restituisci Sandals. Se il valore è Winter, restituisci Boots. Se nessuna delle opzioni nel calcolo corrisponde a quanto indicato nel campo Season, restituisci Sneakers.”
Note	Utilizzato con CASE, THEN, ELSE e END. `CASE` supporta anche la costruzione `WHEN IN`, come ad esempio: CASE <expression> WHEN IN <set1> THEN <then1> WHEN IN <combinedfield> THEN <then2> ... ELSE <default> END I valori con cui si confronta `WHEN IN`, devono essere un insieme, un elenco di valori letterali o un campo combinato. Vedi anche IN.

### ZN

Sintassi	`ZN(expression)`
Output	Dipende dal tipo di dati di `<expression>` oppure 0.
Definizione	Restituisce <expression> se non è Null, altrimenti restituisce zero.
Esempio	ZN([Test Grade]) “Se Test Grade non è Null, restituisci il relativo valore. Se Test Grade è Null, restituisci 0.”
Note	`ZN` è un caso specializzato di IFNULL dove l’alternativa se l’espressione è Null è sempre 0 anziché essere specificato nel calcolo. `ZN` è particolarmente utile quando si eseguono calcoli aggiuntivi e un valore Null renderebbe Null l’intero calcolo. Tuttavia, occorre prestare attenzione nell’interpretazione dei risultati poiché Null non è sempre sinonimo di 0 e potrebbe rappresentare dati mancanti. Vedi anche ISNULL.

**Nota:** alcuni di questi sono in realtà operatori logici e appaiono in nero, non in blu. Per maggiori informazioni, consulta [Sintassi degli operatori](https://help.tableau.com/v0.0/pro/desktop/it-it/functions_operators.htm#Operators). Nota relativa a CASE, IF e IIF CASE è spesso più facile da usare di IF o IIF. In molti casi, IF, IIF e CASE possono essere utilizzati in modo intercambiabile. Un’istruzione CASE può sempre essere riscritta come istruzione IF, anche se l’istruzione CASE sarà generalmente più concisa e potrebbe essere più semplice da interpretare. Tuttavia, non tutte le istruzioni IF possono essere scritte come istruzioni CASE, poiché ogni ELSEIF potrebbe fare riferimento a un campo diverso. **Suggerimento**: confrontiamo un esempio utilizzando la stessa logica tra queste tre funzioni:

CASE

IIF

CASE [Region]
WHEN 'West' THEN 1
WHEN 'East' THEN 2
WHEN 'South' THEN 3
WHEN 'North' Then 4
ELSE 5
END

IF [Region] = 'West' THEN 1
ELSEIF [Region] = 'East' THEN 2
ELSEIF [Region] = 'South' THEN 3
ELSEIF [Region] = 'North' THEN 4
ELSE 5
END

IIF([Region] = 'West', 1,
 IIF([Region] = 'East', 2,
  IIF([Region] = 'South', 3,
   IIF([Region] = 'North', 4,
   5, 0)
  )
 )
)

La struttura CASE è molto semplice, facile da scrivere e interpretare. Tuttavia, l’espressione (in questo caso, [Region]) non può essere un’operazione logica, a differenza di IF o IIF.

I valori Null vengono gestiti allo stesso modo per CASE e IF.

La struttura IF THEN consente più clausole ELSEIF, il che rende le valutazioni multiple molto più semplici rispetto a IIF.

Gestione dei valori NULL: qualsiasi risultato sconosciuto (Null) viene gestito dalla stessa clausola ELSE dei risultati False. In questo caso, a qualsiasi regione diversa dalle quattro specificate (incluso Null) verrà assegnato il valore 5.

La struttura IIF gestisce i risultati sconosciuti in modo diverso rispetto ai risultati False e ha una sintassi diversa da IF. Il compromesso per la gestione specifica dei valori Null è l’annidamento, come nel caso precedente, che può essere complicato da scrivere e interpretare.

Gestione dei valori NULL: a qualsiasi regione non Null diversa dalle quattro specificate verrà assegnato il valore 5, ma a un valore Null verrà assegnato 0.

**Nota**: molte volte è possibile utilizzare un gruppo per ottenere gli stessi risultati di una funzione CASE complicata. Esegui un test per stabilire se un’opzione offre migliori prestazioni rispetto all’altra. ### Esempi Le funzioni CASE possono essere utili per scenari come la ridefinizione dell’aliasing: CASE LEFT(DATENAME('weekday',\[Order Date\]),3) WHEN 'Sun' THEN 0 WHEN 'Mon' THEN 1 WHEN 'Tue' THEN 2 WHEN 'Wed' THEN 3 WHEN 'Thu' THEN 4 WHEN 'Fri' THEN 5 WHEN 'Sat' THEN 6 END Oppure per offrire all’utente finale la possibilità di selezionare quale misura visualizzare in un grafico quando vengono utilizzate con un [parametro](https://www.tableau.com/it-it/about/blog/2015/11/using-parameter-change-fields-45866): CASE \[Choose a Measure\] WHEN "Sales" THEN SUM(\[Sales\]) WHEN "Profit" THEN AVG(\[Profit\]) WHEN "Quantity" THEN COUNT(\[Quantity\]) WHEN "Shipping Cost" THEN MEDIAN(\[Shipping Cost\]) END ## Creare un calcolo logico Per informazioni su come creare un calcolo logico, segui i passaggi seguenti. 1. In Tableau Desktop, connettiti all’origine dati salvata **Esempio - Supermercato**, fornita con Tableau. 2. Passa a un foglio di lavoro. 3. Dal riquadro **Dati**, trascina Stato sullo spazio Righe. 4. Dal riquadro **Dati**, trascina Categoria sullo spazio Righe e posizionalo a destra di Stato. 5. Dal riquadro **Dati**, trascina Vendite nello spazio Colonne. 6. Seleziona Analisi > Crea campo calcolato. 7. Nell’editor di calcolo che si apre, esegui le seguenti operazioni: - Denomina il campo calcolato KPI. - Immetti la seguente formula: SUM(\[Profit\]) > 0 Questo calcolo controlla rapidamente se un membro è maggiore di zero. In caso affermativo, restituisce vero; in caso contrario, restituisce falso. - Al termine, fai clic su **OK**. Visualizzerai il nuovo campo calcolato sotto Misurazioni nel riquadro Dati. Proprio come gli altri campi, puoi utilizzarlo in una o più visualizzazioni. 9. Dal riquadro **Dati**, trascina **KPI** su **Colore** sulla scheda Indicatori. Ora puoi vedere le categorie che perdono denaro in ogni stato. ![Funzione logica applicata a un grafico a barre per evidenziare le categorie di prodotto in perdita in ciascuno stato.](/tableau/next/it-it/pro/desktop/it-it/Img/logicalfunctions1.png) ## Vedi anche [Visualizzare gli indicatori chiave di prestazione](https://help.tableau.com/v0.0/pro/desktop/it-it/kpi.htm) [Funzioni in Tableau](https://help.tableau.com/v0.0/pro/desktop/it-it/functions.htm) [Funzioni di Tableau (per categoria)](https://help.tableau.com/v0.0/pro/desktop/it-it/functions_all_categories.htm) [Funzioni di Tableau (in ordine alfabetico)](https://help.tableau.com/v0.0/pro/desktop/it-it/functions_all_alphabetical.htm)