mi sa che c’é qualche ragionamento logico che mi sfugge:
var c = Console.ReadLine();
if (!c.Equals("True")) Console.WriteLine("Fuori");
else Console.WriteLine(c);
var c = Console.ReadLine();
if (c.Equals("True") || c.Equals("False")) Console.WriteLine(c);
else Console.WriteLine("Fuori");
in questi primi due casi funziona come immaginavo
var c = Console.ReadLine();
if (!c.Equals("True") || !c.Equals("False")) Console.WriteLine("Fuori");
else Console.WriteLine(c);
se inverto il risultato aggiungendo la negazione agli Equals, non si comporta come il secondo esempio
mentre nel primo esempio metto la negazioni ma con una sola verifica e funziona come mai?
edit:
negando il primo controllo deve verificare la seconda?
ps cambiando l’operatore di condizione || (Or) con && (And) il risultato è quello atteso
(ma non trovo dov’é la mancanza nel ragionamento usando gli (Or) ||)
L’operatore OR restituisce True se almeno una delle condizioni è verificata:
(True) OR (True) =True
(False) OR (True) =True
(True) OR (False) =True
(False) OR (False) =False
…
(! False) OR (False) =TRUE
int a=1;
int b=4;
bool x;
x = a==1||b==4;
Console.WriteLine(x);
//RESTITUISCE TRUE
x = a!=1||b==4;
Console.WriteLine(x);
//RESTITUISCE TRUE
x = a==1||b!=4;
Console.WriteLine(x);
//Restituisce TRUE
x = a!=1||b!=4;
Console.WriteLine(x);
//RESTITUISCE FALSE
L’operatore And restituisce TRUE solo se entrambe vere.
int a=1;
int b=4;
bool x;
x = a==1&&b==4;
Console.WriteLine(x);
//RESTITUISCE TRUE
x = a!=1&&b==4;
Console.WriteLine(x);
//RESTITUISCE FALSE
x = a==1&&b!=4;
Console.WriteLine(x);
//Restituisce FALSE
x = a!=1&&b!=4;
Console.WriteLine(x);
//RESTITUISCE FALSE
Se in una espressione ci sono più operatori esiste un ordine di priorità: NOT, AND, OR.
La cosa migliore per non incappare in errori (ostici da trovare) è meglio aiutarsi con le parentesi.
Nel tuo caso, se la prima espressione, secondo i valori restituiti erano:
TRUE || FALSE = TRUE
inserendo inserendo l’operatore NOT ad ambo i membri
! TRUE || ! FALSE = TRUE
è equivalente a:
FALSE || TRUE = TRUE
Nel tuo caso, se ho capito bene, devi inserire NOT a tutta l’espressione:
var c = Console.ReadLine();
if !(c.Equals("True") || c.Equals("False")) Console.WriteLine("Fuori");
else Console.WriteLine(c);
Fatta salva la spiegazione di Sergio …
Se ci dici cosa scrivi come input, possiamo ragionare su un caso concreto invece di avvitarci in astrusi ragionamenti ipotetici …
ciao Sergio, in effetti avevo pensato di mettere il punto esclamativo all’inizio con le perentesi
ma mi ero convinto che andava bene ugualmente essendo che nel primo esempio funziona.
ciao Emilio, nessun ragionamento astruso, gli unici valori che vorrei accettare sono “True” e “False”
quindi se il valore è diverso da “True” or “False” non li accetta
ps comprendo che leggendo la sintassi consigliata da Sergio è meglio leggibile
se i valori A e B NON sono uguali a . . . or uguali a . . . fai questo
ma in teoria mi sembrava corretto anche la sintassi come da me dichiarata
se il valore A NON è uguale a . . . or il valore B NON è uguale a . . . fai questo
(si vede che con la doppia negazione si inverte qualche logica “anche se leggendo mi sembrava coerente”)
impostando i due risultati di output in egual modo come indicati sopra
prendendo atto che la sintassi di Sergio torna ciò che avevo in mente
ma mi sfugge il motivo del perché la mia invece non va bene,
leggendola mi sembra comunque coerente tutto qua.
l’unico ragionamento logico fatto è che come già detto bisogna usare And e non Or con la mia sintassi.
Questa if sara’ sempre vera, per ogni possibile input.
Affinche’ la condizione risulti falsa,
visto che abbiamo una OR, entrambi i due valori devono essere falsi.
( Come ha spiegato Sergio )
E per essere falsi, c dovrebbe essere contemporaneamente uguale a True e uguale a False.
Ovviamente cio’ non e’ possibile.
EDIT
Se posso dare un umile consiglio …
Se vuoi andare oltre a quello che sembra leggendola, si puo’ fare cosi’:
Prendi carta e penna, fai i calcoli a mano e vedi subito il risultato.
Fai i passaggi uno per volta e sostituisci i risultati parziali.
Esempio: input = “True”
c.Equals("True") => VERO
!c.Equals("True") => ! VERO => FALSO
c.Equals("False") => FALSO
!c.Equals("False") => ! FALSO => VERO
if (!c.Equals("True") || !c.Equals("False")) => if( FALSO || VERO ) => if( VERO ) => VERO
ma che dite come metodo di comparazione dovendo poi confrontare anche gli eventuali errori di digitalizzazione oppure digitare “nulla” va bene questa tipo di procedura?
avevo provato inizialmente con i vari “parse” oppure “?” o ancora i “convert”
ma non ci sono riuscito, tenendo conto anche del fatto che una volta
che si va a utilizzare il “ReadLine” tutti i valori sono sempre stringa?
questo è lo script:
var c = Console.ReadLine(); //valore bool
if (!(c.Equals("True") || c.Equals("False")) || c.Length == 0) Console.WriteLine("Fuori 3");
else Console.WriteLine(c);
in pratica per come stavo provando con gli altri metodi mi diventava più complesso o sbaglio?
Come al solito non capisco bene cosa vuoi fare …
Ma se vuoi verificare l’input di “False” o “True”, compresi errori di digitalizzazione, la vedo dura …
Cioe’, no. Non necessariamente dura, ma certo piu’ lunga di un paio di istruzioni.
Credo dipenda molto da quali errori vuoi tollerare … e comunque e’ un problema molto interessante.
Ad esempio ho trovato questo:
EDIT:
Per esempio:
/ EDIT
Ma si trova molto altro materiale sul Web.
Comunque, casomai ti interessi, ho provato a scrivere quanto hai scritto tu usando List.Contain …
Console.WriteLine( "?" );
var c = Console.ReadLine();
if( ( new List<string> { "True", "False", "" } ).Contains( c ) )
Console.WriteLine( "Fuori 3" );
else Console.WriteLine(c);
Emilio scusa se replico, (mi sbaglierò) ma in questo caso se scrivo True o False lo script mi fa uscire?
invece l’intenzione del codice è scrivere c se esso è uguale a True o False diversamente esci
edit:
se è come dico, forse la correzione è togliere il terzo valore “” e negando le altre due
(oppure ho preso una svista?)
