Esercizio - Valutare un'espressione

11 minuti

La logica decisionale viene usata per stabilire percorsi alternativi attraverso il codice, in cui la decisione su quale percorso seguire si basa sulla valutazione di un'espressione. Ad esempio, si potrebbe scrivere codice che esegue uno dei due percorsi in base all'input di un utente. Se l'utente immette la lettera "a", il codice eseguirà un blocco di codice. Se immette la lettera "b", il codice eseguirà un blocco di codice diverso. In questo esempio si controlla il percorso di esecuzione in base al valore assegnato a una stringa. Il codice seleziona un percorso di esecuzione basato su un'espressione, su come viene valutata tale espressione e sulla logica sottostante usata per definire i percorsi.

Esaminare come costruire e valutare un'espressione è un buon punto di partenza.

Che cos'è un'espressione?

Un'espressione è una combinazione di valori (letterali o variabili), operatori e metodi che restituiscono un singolo valore. Un'istruzione è un comando completo in C# e le istruzioni includono una o più espressioni. Ad esempio, l'istruzione if seguente contiene una singola espressione che restituisce un singolo valore:

if (myName == "Luiz")

Si potrebbe pensare che il valore restituito da un'espressione sia un numero o forse una stringa. È vero che gli sviluppatori di applicazioni usano diversi tipi di espressioni per scopi diversi. In questo caso, quando si sviluppa un'istruzione di selezione if, si userà un'espressione che restituisce true o false. Gli sviluppatori fanno riferimento a questo tipo di espressione come espressione booleana. Quando il codice include un'espressione booleana, il valore restituito è sempre un singolo valore true o false.

Le espressioni booleane sono importanti perché il codice può usarle per decidere quale blocco di codice eseguire.

Esistono molti tipi diversi di operatori che è possibile usare all'interno di un'espressione booleana. Ad esempio, l'istruzione precedente usa l'operatore if== di uguaglianza per verificare se una variabile stringa è assegnata a un determinato valore. L'operatore scelto dipenderà dai percorsi di codice disponibili, dalle condizioni associate ai percorsi e dalla logica dell'applicazione sottostante.

Valutazione dell'uguaglianza e della disuguaglianza

Una delle valutazioni del codice più comuni è un controllo per verificare se due valori sono uguali. Quando si verifica l'uguaglianza, si individua l'operatore di uguaglianza == tra i due valori da controllare. Se i due valori su entrambi i lati dell'operatore di uguaglianza sono equivalenti, l'espressione restituirà true. In caso contrario, restituirà false.

Al contrario, potrebbe anche essere necessario verificare se due valori non sono uguali. Per verificare la disuguaglianza, si userà l'operatore di disuguaglianza != tra i due valori.

Ci si potrebbe chiedere perché l'operatore di uguaglianza e quello di disuguaglianza siano entrambi necessari. Il motivo diventerà più chiaro quando si apprenderà come creare istruzioni di diramazione e si inizierà a scrivere codice reale. Due operatori che eseguono attività opposte consentono di essere più espressivi e compatti.

A questo punto è possibile preparare l'ambiente di codifica e iniziare a scrivere codice che valuta le espressioni booleane.

Preparare l'ambiente di scrittura del codice

Questo modulo include attività pratiche che guidano l'utente attraverso il processo di compilazione ed esecuzione di un codice dimostrativo. È consigliabile completare queste attività usando Visual Studio Code come ambiente di sviluppo. L'uso di Visual Studio Code per queste attività consente di acquisire familiarità nella scrittura e nell'esecuzione del codice in un ambiente di sviluppo usato da professionisti di tutto il mondo.

Aprire Visual Studio Code.

Per aprire Visual Studio Code è possibile usare il menu Start di Windows (o una risorsa equivalente per un altro sistema operativo).
Nel menu File di Visual Studio Code selezionare Apri cartella.
Nella finestra di dialogo Apri cartella passare alla cartella Desktop di Windows.

Se si usa un percorso di cartella diverso per conservare i progetti di codice, è possibile usare tale percorso. Per questo training, è importante che il percorso sia facile da individuare e da ricordare.
Nella finestra di dialogo Apri cartella, selezionare Seleziona cartella.

Se viene visualizzata una finestra di dialogo di sicurezza che chiede se si considerano attendibili gli autori, selezionare Sì.
Nel menu Terminale di Visual Studio Code selezionare Nuovo terminale.

Si noti che in un prompt dei comandi nel pannello Terminale viene visualizzato il percorso della cartella corrente. Ad esempio:
```
C:\Users\someuser\Desktop>
```
Nota

Se si usa il proprio PC anziché un ambiente sandbox o ospitato e sono stati completati altri moduli di Microsoft Learn in questa serie dedicata a C#, potrebbe essere già stata creata una cartella di progetto per gli esempi di codice. In tal caso, è possibile ignorare il passaggio successivo, usato per creare un'app console nella cartella TestProject.
Al prompt dei comandi del terminale, per creare una nuova applicazione console in una cartella specificata, immettere il prompt seguente:
```
dotnet new console -o ./CsharpProjects/TestProject
```
Questo comando dell'interfaccia della riga di comando .NET usa un modello di programma .NET per creare un nuovo progetto di applicazione console C# nel percorso di cartella specificato. Il comando crea le cartelle CsharpProjects e TestProject e usa TestProject come nome del file .csproj.

Se viene visualizzato un messaggio che indica che i file esistono già, continuare con i passaggi successivi. I file di progetto esistenti verranno riutilizzati.
Nella visualizzazione EXPLORER espandere la cartella CsharpProjects .

Verranno visualizzati la cartella TestProject e due file, un file di programma C# denominato Program.cs e un file di progetto C# denominato TestProject.csproj.
Nel menu File di Visual Studio Code selezionare Apri cartella.
Nella finestra di dialogo Apri cartella selezionare la cartella CsharpProjects e quindi selezionare Seleziona cartella.
Nella visualizzazione EXPLORER espandere la cartella TestProject e quindi selezionare Program.cs.
Eliminare le righe di codice esistenti.

Si userà questo progetto console C# per creare, compilare ed eseguire esempi di codice durante questo modulo.
Chiudere il pannello Terminale.

Usare l'operatore di uguaglianza

Assicurarsi che Visual Studio Code sia aperto e che Program.cs sia visualizzato nel pannello dell'editor.

Nota

Program.cs deve essere vuoto. In caso contrario, selezionare ed eliminare tutte le righe di codice.

Digitare il codice seguente nel pannello Editor di Visual Studio Code.

Console.WriteLine("a" == "a");
Console.WriteLine("a" == "A");
Console.WriteLine(1 == 2);

string myValue = "a";
Console.WriteLine(myValue == "a");

In Visual Studio Code scegliere Salva dal menu File.

Il file Program.cs deve essere salvato prima di compilare o eseguire il codice.
Nel pannello ESPLORA RISORSE per aprire un terminale nel percorso della cartella TestProject, fare clic con il pulsante destro del mouse su TestProject e quindi scegliere Apri nel terminale integrato.

Si aprirà un pannello Terminale. Il terminale deve includere un prompt dei comandi che mostra che il terminale è aperto sul percorso della cartella TestProject.
Nel prompt dei comandi del terminale, digitare dotnet run per eseguire il codice, quindi premere INVIO.

Nota

Se viene visualizzato un messaggio che indica "Impossibile trovare un progetto da eseguire", assicurarsi che il prompt dei comandi del terminale visualizzi il percorso previsto della cartella TestProject. Ad esempio: C:\Users\someuser\Desktop\csharpprojects\TestProject>

Verrà visualizzato l'output seguente.
```
True
False
False
True
```

Migliorare la verifica dell'uguaglianza delle stringhe usando i metodi helper predefiniti della stringa

Potrebbe essere una sorpresa vedere che la riga Console.WriteLine("a" == "A"); restituisce false. Quando si confrontano le stringhe, è importante distinguere tra maiuscole e minuscole.

Si consideri anche questa riga di codice:

Console.WriteLine("a" == "a ");

Qui è stato aggiunto uno spazio alla fine della stringa. Questa espressione restituirà anche false.

In alcuni casi, avere uno spazio prima o dopo il testo potrebbe essere perfettamente accettabile. Se tuttavia è necessario accettare una corrispondenza non esatta, è possibile "manipolare" prima i dati. "Manipolare" i dati significa che eseguire alcune operazioni di pulizia prima di verificare l'uguaglianza tramite un confronto.

Si consideri ad esempio il caso in cui si raccoglie l'input dell'utente all'interno di un ciclo. Dopo aver immesso ogni valore, è possibile fornire all'utente un prompt per determinare se desidera continuare, ad esempio Do you want to continue (Y/N)?. Se l'utente vuole continuare, probabilmente immetterà y o Y. Si vuole che il codice interpreti entrambi i valori allo stesso modo, anche se y non è equivalente a Y.

Prima di controllare l'uguaglianza di due valori stringa, in particolare quando uno o entrambi i valori sono stati immessi da un utente, è necessario:

Verificare che entrambe le stringhe siano in lettere tutte maiuscole o tutte minuscole usando il metodo helper ToUpper() o ToLower() su qualsiasi valore delle stringhe.
Rimuovere gli spazi vuoti iniziali o finali usando il metodo helper Trim() su qualsiasi valore delle stringhe.

È possibile migliorare il controllo dell'uguaglianza precedente concatenando questi due metodi helper in entrambi i valori, come mostrato nell'elenco codici seguente:

Sostituire il codice nell'editor di Visual Studio Code con il seguente:

string value1 = " a";
string value2 = "A ";
Console.WriteLine(value1.Trim().ToLower() == value2.Trim().ToLower());

Salvare il file di codice e quindi usare Visual Studio Code per eseguire il codice.
Si noti che quando si esegue il codice, questa volta restituirà True.

Usare l'operatore di disuguaglianza

Usare l'operatore di commento riga // per impostare come commento tutto il codice del passaggio precedente,

Digitare il codice seguente nel pannello Editor di Visual Studio Code.

Console.WriteLine("a" != "a");
Console.WriteLine("a" != "A");
Console.WriteLine(1 != 2);

string myValue = "a";
Console.WriteLine(myValue != "a");

Salvare il file di codice e quindi usare Visual Studio Code per eseguire il codice.

Verrà visualizzato l'output seguente.
```
False
True
True
False
```

Come si prevede, il risultato quando si usa l'operatore di disuguaglianza è l'opposto di ciò che si riscontra quando si usa l'operatore di uguaglianza. Ciò significa che il codice verrà ramificato anche in modo opposto, il che può essere voluto.

Valutazione dei confronti

Quando si usano tipi di dati numerici, potrebbe essere necessario determinare se un valore è maggiore o minore di un altro valore. Usare gli operatori seguenti per eseguire questi tipi di confronti:

Maggiore di >
Minore di <
Maggiore o uguale a >=
Minore o uguale a <=

Naturalmente, gli operatori == e != usati per confrontare i valori di stringa precedenti funzioneranno anche quando si confrontano i tipi di dati numerici.

Usare gli operatori di confronto

Usare l'operatore di commento riga // per impostare come commento tutto il codice dell'attività precedente.

Digitare il codice seguente nel pannello Editor di Visual Studio Code.

Console.WriteLine(1 > 2);
Console.WriteLine(1 < 2);
Console.WriteLine(1 >= 1);
Console.WriteLine(1 <= 1);

Salvare il file di codice e quindi usare Visual Studio Code per compilare ed eseguire il codice.

Verrà visualizzato l'output seguente:
```
False
True
True
True
```

Metodi che restituiscono un valore booleano

Alcuni metodi restituiscono un valore booleano (true o false). Nell'esercizio seguente verrà usato un metodo predefinito sulla classe String per determinare se una stringa più grande contiene una parola o una frase specifica pertinente per l'applicazione.

Nota

Alcuni tipi di dati hanno metodi che eseguono attività utili. Il tipo di dati String ne include diverse. Molti restituiscono un valore booleano, inclusi Contains(), StartsWith() ed EndsWith(). Per altre informazioni, vedere il modulo di Microsoft Learn "Manipolare i dati alfanumerici usando i metodi della classe String in C#".

Usare un metodo che restituisce un valore booleano

Usare l'operatore di commento riga // per impostare come commento tutto il codice del passaggio precedente,

Digitare il codice seguente nel pannello Editor di Visual Studio Code.

string pangram = "The quick brown fox jumps over the lazy dog.";
Console.WriteLine(pangram.Contains("fox"));
Console.WriteLine(pangram.Contains("cow"));

Salvare il file di codice e quindi usare Visual Studio Code per compilare ed eseguire il codice.

Verrà visualizzato l'output seguente.
```
True
False
```

Che cos'è la negazione logica?

Il termine "negazione logica" si riferisce all'operatore di negazione unario !. Alcuni chiamano questo operatore "operatore not". Quando si inserisce l'operatore ! prima di un'espressione condizionale (o qualsiasi codice valutato in true o false), questo forza il codice a invertire la valutazione dell'operando. Quando viene applicata la negazione logica, la valutazione produce true se l'operando restituisce false e false se l'operando restituisce true.

Ecco un esempio che può aiutare a notare il collegamento tra queste idee. Le due righe di codice seguenti generano lo stesso risultato. La seconda riga è più compatta.

// These two lines of code will create the same output

Console.WriteLine(pangram.Contains("fox") == false);
Console.WriteLine(!pangram.Contains("fox"));

Usare l'operatore di negazione logica

Usare l'operatore di commento riga // per impostare come commento tutto il codice del passaggio precedente,

Digitare il codice seguente nel pannello Editor di Visual Studio Code.

string pangram = "The quick brown fox jumps over the lazy dog.";
Console.WriteLine(!pangram.Contains("fox"));
Console.WriteLine(!pangram.Contains("cow"));

Salvare il file di codice e quindi usare Visual Studio Code per compilare ed eseguire il codice.

Verrà visualizzato l'output seguente.
```
False
True
```

Confronto tra operatore di disuguaglianza e negazione logica

L'operatore di disuguaglianza != include un carattere !, ma non deve essere confuso con la negazione logica. L'operatore di disuguaglianza restituisce true se gli operandi non sono uguali e false se gli operandi sono uguali. Per gli operandi dei tipi predefiniti, l'espressione x != y produce lo stesso risultato dell'espressione !(x == y) (un esempio di negazione logica).

L'esempio di codice seguente illustra l'uso dell'operatore !=:

int a = 7;
int b = 6;
Console.WriteLine(a != b); // output: True
string s1 = "Hello";
string s2 = "Hello";
Console.WriteLine(s1 != s2); // output: False

Riepilogo

Ecco le principali lezioni apprese finora sulla valutazione delle espressioni booleane:

Esistono diversi tipi di espressioni che restituiscono true o false.
Valutare l'uguaglianza usando l'operatore ==.
Per valutare l'uguaglianza delle stringhe, è necessario considerare la possibilità che le stringhe usino in modo diverso le lettere maiuscole e minuscole e gli spazi iniziali o finali. A seconda dei casi, usare i metodi helper ToLower() o ToUpper() e il metodo helper Trim() per aumentare le probabilità che due stringhe siano uguali.
Valutare la disuguaglianza usando l'operatore !=.
Valutare le operazioni di tipo maggiore di, minore di e simili usando operatori di confronto come >, <, >= e <=.
Se un metodo restituisce un valore booleano, può essere usato come espressione booleana.
Usare l'operatore di negazione logica ! per restituire l'opposto di un'espressione specificata.

Commenti e suggerimenti

Questa pagina è stata utile?

Esercizio - Valutare un'espressione

Verifica delle conoscenze

Commenti e suggerimenti