Opérateurs logiques

bool both = true && true; range le mot true, et Console.WriteLine(both) écrit true. L'écran tient sur une ligne. Les deux esperluettes se trouvent entre les deux mots true dans le fichier, et elles ne sont pas sur cette ligne. Gardez la classe publique nommée Pine.

Deux esperluettes veulent les deux côtés true

Ouvrez le fichier Pine. Le nom de la classe reste Pine. Cette page ne renomme pas le type. Supprimez bool match si cette ligne est encore là, y compris 4 == 4, 4 == 9, et tout signe d'interrogation entre deux entiers. Supprimez int total si cette ligne est encore là. Supprimez string[] plants si cette ligne est encore là. Supprimez bool ripe si cette ligne est encore là avec un true ou un false nu et sans signe de combinaison. Supprimez toute ligne ReadLine. Le fichier que vous gardez n'attend pas, n'a pas match, ni total, ni plants, ni de ligne ripe nue. Le mot n'est écrit que par la ligne d'écriture qui utilise le nom qui porte la réponse combinée.

Dans Main, la ligne de rangement est bool both = true && true;. bool est le mot de type. Il dit que ce nom porte l'un des deux mots, true ou false. both est le nom, et il commence par un b minuscule. Le premier signe = range. À droite de ce premier = se trouvent deux mots true ou false et un signe de combinaison. Le premier mot est true, toutes les lettres minuscules, sans guillemets. Le signe de combinaison est deux esperluettes écrites ensemble sans espace entre elles : &&. Le second mot est true, toutes les lettres minuscules, sans guillemets. Le point-virgule termine la ligne. Cette ligne range un mot. Elle n'écrit pas l'écran. Ranger n'est pas écrire. L'écran reste vide jusqu'à la fin de cette ligne. Le signe de combinaison ne demande pas si deux entiers correspondent. Il ne fabrique pas un troisième entier. Il regarde deux réponses déjà true ou false, et il en fait une seule réponse.

Deux esperluettes veulent dire que les deux côtés doivent être true. Quand le côté gauche est true et le côté droit est true, le mot combiné est true. Quand l'un des deux côtés est false, le mot combiné est false. bool both = true && false; range false. bool both = false && true; range false. bool both = false && false; range false. Le fichier que vous gardez utilise true && true, donc le mot rangé est true.

Un signe de combinaison n'est pas le même travail qu'un signe d'interrogation. La page comparaison plaçait == entre deux entiers. Cette interrogation fabriquait true ou false à partir des nombres. Cette page place && entre deux valeurs déjà true ou false. La page opérateurs plaçait + entre deux entiers pour fabriquer un troisième entier. && ne fabrique pas un troisième entier. Si vous écrivez bool both = 4 && 9;, le build écrit une erreur dans la forme de leçon de cette page, parce que les côtés que cette page garde sont true ou false, pas des entiers nus. Gardez true et false des deux côtés pour le fichier que vous gardez.

La ligne d'écriture est le nom nu : Console.WriteLine(both);. Pas de guillemets, et pas de signe de combinaison sur cette ligne. C# lit le nom both, écrit le mot que ce nom porte, et termine la ligne. Pour le fichier que vous gardez, ce mot est true. Les lettres du nom, b, o, t, h, ne sont pas à l'écran. bool n'est pas à l'écran. Les deux esperluettes ne sont pas à l'écran. Les mots true séparés ne sont pas à l'écran comme deux lignes. Le mot true est à l'écran, sur une ligne. Enregistrez le fichier.

Le fichier que vous gardez

Gardez cette forme d'enseignement. Un mot de type, bool. Un nom, both. Une ligne de rangement qui écrit true, puis deux esperluettes, puis true, sans guillemets autour de chaque mot. Une ligne d'écriture, et cette ligne utilise le nom nu. Il n'y a pas de ligne match, pas de ligne total, et pas de seconde ligne d'écriture.

Lisez depuis le haut. using System; prépare les noms courts. public class Pine nomme le type. public static void Main() est l'endroit où l'exécution démarre. bool both = true && true; range le mot true. Il n'écrit rien. Console.WriteLine(both); écrit true et termine la ligne. Une ligne à l'écran. Pas de guillemets. Pas de seconde ligne. Il n'y a pas de ligne bool match dans le fichier que vous gardez, et il n'y a pas de ligne qui demande si 4 correspond à 4.

Exécutez avec dotnet run. Le programme écrit true. Il n'attend pas que vous tapiez. Les deux mots true et le signe de combinaison étaient déjà dans le fichier. Si dotnet run attend, ReadLine est encore dans le fichier. Supprimez cette ligne et gardez bool both = true && true; et la seule ligne d'écriture. Le programme se termine après la ligne d'écriture. L'écran montre true. Une ligne. Pas de guillemets. Si l'écran montre both, la ligne d'écriture a des guillemets autour du nom : Console.WriteLine("both");. Ces guillemets marquent des lettres, donc le mot rangé n'est pas écrit. Si l'écran montre true à partir de bool match = 4 == 4;, le fichier comparaison est encore en place. Supprimez la ligne match. Si l'écran montre false, un côté de && est false, ce qui est permis pour vérifier, et ce n'est pas le fichier que vous gardez. Si l'écran montre true && true comme lettres, la ligne d'écriture a des guillemets autour de ces caractères. Vous ne réinstallez pas le kit SDK .NET pour un écran qui montre la mauvaise ligne.

Un écran qui montre true ne prouve pas à lui seul le signe de combinaison. bool both = true; écrit aussi true. L'écran peut sembler identique. Le fichier ne l'est pas. Le fichier que vous gardez a true, puis &&, puis true. Quand vous jugez cette page, cherchez les deux esperluettes entre les deux mots true. Ne jugez pas le fichier à partir de l'écran seul.

Les espaces autour du signe de combinaison sont permis. bool both = true&&true; sans espaces range encore true, et le build n'écrit pas d'erreur. bool both = true && true; avec des espaces range encore true. Le fichier que vous gardez utilise des espaces autour du signe, parce que le signe est plus facile à voir ainsi. Les espaces ne sont pas une seconde valeur. Un espace entre les deux esperluettes n'est pas permis. bool both = true & & true; fait écrire une erreur au build. Gardez les deux esperluettes ensemble en &&. Une esperluette seule n'est pas le signe que cette page garde. bool both = true & true; n'est pas le fichier que vous gardez. Le build peut écrire une erreur, ou la ligne n'est pas la leçon que cette page enseigne. Écrivez deux esperluettes.

Des guillemets autour de true le transforment en lettres. bool both = "true" && true; demande à C# de combiner des lettres avec un mot true ou false d'une façon que cette page n'enseigne pas. Le build écrit une erreur. Supprimez les guillemets. Les deux côtés de &&, sur cette page, sont les mots true ou false sans guillemets. Console.WriteLine(true && true); sans aucun nom both écrit aussi true. L'écran peut sembler identique. Le fichier que vous gardez range d'abord la réponse combinée sous un nom, puis écrit ce nom.

Le nom doit exister avant qu'une ligne l'utilise. Si Console.WriteLine(both); est écrit au-dessus de bool both = true && true;, le build écrit une erreur. Placez la ligne de rangement au-dessus de la ligne d'écriture. N'écrivez pas bool une seconde fois pour le même nom. Une ligne ultérieure peut remplacer le mot sans réécrire bool, une fois que both existe déjà : both = true && true;. Cette forme est permise. Elle n'est pas obligatoire. Le fichier que vous gardez crée le nom et range la réponse combinée sur une ligne.

Quand un côté est false

Changez seulement le mot de droite. Gardez le mot de type bool. Gardez le nom both. Gardez le signe en deux esperluettes. bool both = true && false; a un côté gauche true et un côté droit false. Deux esperluettes veulent les deux côtés true. Le mot combiné est false. La ligne d'écriture reste Console.WriteLine(both);. L'écran montre false. Une ligne. Le nom both n'est pas à l'écran. Les mots true et false séparés ne sont pas à l'écran comme deux lignes.

Exécutez dotnet run. L'écran montre false. Après avoir vu false, remettez le fichier gardé : bool both = true && true; et un Console.WriteLine(both);. L'écran gardé est true, une ligne. Cette exécution false est une vérification. Ce n'est pas le fichier que vous gardez.

Deux barres veulent un côté true

Un autre signe de combinaison utilise deux barres verticales écrites ensemble : ||. Deux barres veulent dire qu'au moins un côté doit être true. bool either = true || false; range true. bool either = false || true; range true. bool either = true || true; range true. bool either = false || false; range false. Le nom peut être either. Le mot de type reste bool.

C'est le second fichier. Ce n'est pas le fichier que vous gardez. Exécutez dotnet run. L'écran montre true. Une ligne. Il ne montre pas false. Il ne montre pas true || false comme lettres. Si l'écran montre false, les deux côtés peuvent encore être false, comme dans bool either = false || false;. Cette ligne est permise, et ce n'est pas ce second fichier. Après avoir vu true à partir de true || false, remettez le fichier gardé : bool both = true && true; et Console.WriteLine(both);.

Deux esperluettes et deux barres ne font pas le même travail. && est strict. Les deux côtés doivent être true. || est ouvert. Un côté true suffit. Le fichier que vous gardez enseigne &&. Le second fichier montre seulement ||. Ne laissez pas || dans le fichier gardé. N'écrivez pas une seule barre. bool either = true | false; n'est pas le signe que cette page garde pour la combinaison ouverte.

Un bang inverse le mot

Un signe bang se place contre un seul mot true ou false et l'inverse. Le signe est !. bool flipped = !true; range false. bool flipped = !false; range true. Il n'y a pas de second côté. Le bang n'est pas && et n'est pas ||. Il ne se place pas entre deux mots. Il se place contre un seul mot.

C'est le troisième fichier. Ce n'est pas le fichier que vous gardez. Exécutez dotnet run. L'écran montre false. Une ligne. Il ne montre pas true. Il ne montre pas !true comme lettres. Si l'écran montre true, la ligne de rangement peut être bool flipped = !false;, qui inverse false en true. Cette ligne est permise, et ce n'est pas ce troisième fichier. Après avoir vu false à partir de !true, remettez le fichier gardé.

Écrire le signe de combinaison comme des lettres ne combine pas. Console.WriteLine("true && true"); écrit les caractères de ce texte. L'écran montre true && true. Ce n'est pas le mot true de la combinaison gardée. Le build reste silencieux. Les guillemets empêchent le signe de fonctionner comme signe. Le fichier que vous gardez n'a pas de guillemets autour des mots true, et la ligne d'écriture n'a pas de guillemets autour du nom.

Vous pouvez maintenant ranger une réponse true ou false faite à partir de deux réponses true ou false, et écrire ce mot. bool both = true && true; range true. Console.WriteLine(both); écrit true et termine la ligne. true && false écrit false. true || false écrit true. !true écrit false. La page suivante laisse ces signes de combinaison de côté. Elle regarde if et else, qui choisissent un chemin à partir d'une réponse true ou false.

L'écran est le mot combiné

Le fichier que vous gardez écrit true. Le nom sur la ligne d'écriture est both, et both n'est pas à l'écran. Les deux esperluettes sont dans le fichier, et elles ne sont pas à l'écran. Les deux mots true sont dans le fichier, et ils ne sont pas à l'écran comme lignes séparées. Le signe barre et le signe bang ne sont pas le fichier que vous gardez. Des guillemets autour du signe écrivent des lettres, pas le mot combiné.