Comparaison

bool match = 4 == 4; range le mot true, et Console.WriteLine(match) écrit true. L'écran tient sur une ligne. Les deux signes égaux se trouvent entre les deux quatre dans le fichier, et ils ne sont pas sur cette ligne. Gardez la classe publique nommée Pine.

Deux signes égaux posent une question

Ouvrez le fichier Pine. Le nom de la classe reste Pine. Cette page ne renomme pas le type. Supprimez int total si cette ligne est encore là, y compris 4 + 9, 9 / 4, 10 % 3, et tout signe qui combine deux nombres en un entier. Supprimez string[] plants si cette ligne est encore là. Supprimez string plant si cette ligne est encore là. Supprimez int count 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 d'interrogation. Supprimez toute ligne ReadLine. Le fichier que vous gardez n'attend pas, n'a pas total, ni plants, ni plant, ni count, 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 à la question.

Dans Main, la ligne de rangement est bool match = 4 == 4;. bool est le mot de type. Il dit que ce nom porte l'un des deux mots, true ou false. match est le nom, et il commence par un m minuscule. Le premier signe = range. À droite de ce premier = se trouvent deux entiers et un signe d'interrogation. Le premier nombre est 4. Le signe d'interrogation est deux signes égaux écrits ensemble sans espace entre eux : ==. Le second nombre est 4. Il n'y a pas de guillemets autour de l'un ou l'autre 4. 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 d'interrogation ne combine pas 4 et 4 en un nombre plus grand. Il demande si le nombre de gauche correspond au nombre de droite. Quand ils correspondent, le mot rangé est true. Quand ils ne correspondent pas, le mot rangé est false.

Un signe égal et deux signes égaux ne font pas le même travail. Un signe égal range une valeur sous un nom. Deux signes égaux demandent si deux valeurs correspondent. bool match = 4 == 4; a les deux. Le premier = range. Le == interroge. Si vous écrivez un seul signe égal là où l'interrogation doit être, comme dans bool match = 4 = 4;, le build écrit une erreur. Cette ligne essaie de ranger deux fois d'une façon que cette page n'enseigne pas. Gardez deux signes égaux pour l'interrogation. Gardez un signe égal pour le rangement. La page opérateurs utilisait un signe entre deux nombres pour fabriquer un troisième nombre, comme 4 + 9. Cette page utilise un signe d'interrogation entre deux nombres qui tiennent déjà chacun pour soi. L'interrogation ne fabrique pas un troisième entier. Elle fabrique true ou false.

La ligne d'écriture est le nom nu : Console.WriteLine(match);. Pas de guillemets, et pas de signe d'interrogation sur cette ligne. C# lit le nom match, é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, m, a, t, c, h, ne sont pas à l'écran. bool n'est pas à l'écran. Les deux signes égaux ne sont pas à l'écran. Le chiffre 4 n'est pas à l'écran. 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, match. Une ligne de rangement qui écrit 4, puis deux signes égaux, puis 4, sans guillemets autour de chaque nombre. Une ligne d'écriture, et cette ligne utilise le nom nu. Il n'y a pas de ligne total, pas de ligne plants, 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 match = 4 == 4; range le mot true. Il n'écrit rien. Console.WriteLine(match); écrit true et termine la ligne. Une ligne à l'écran. Pas de guillemets. Pas de seconde ligne. Il n'y a pas de ligne int total dans le fichier que vous gardez, et il n'y a pas de ligne qui range un entier combiné.

Exécutez avec dotnet run. Le programme écrit true. Il n'attend pas que vous tapiez. Les deux nombres et le signe d'interrogation étaient déjà dans le fichier. Si dotnet run attend, ReadLine est encore dans le fichier. Supprimez cette ligne et gardez bool match = 4 == 4; 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 match, la ligne d'écriture a des guillemets autour du nom : Console.WriteLine("match");. Ces guillemets marquent des lettres, donc le mot rangé n'est pas écrit. Si l'écran montre 13, le fichier opérateurs est encore en place. Supprimez int total et le signe plus. Si l'écran montre 4, une ligne d'écriture peut encore imprimer un entier au lieu du nom bool. Le fichier que vous gardez écrit le mot porté par match. Si l'écran montre false, les deux nombres sur la ligne de rangement ne correspondent pas, ce qui est le second fichier de cette page, pas le fichier que vous gardez. Si l'écran montre 4 == 4 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 d'interrogation. bool match = true; écrit aussi true. L'écran peut sembler identique. Le fichier ne l'est pas. Le fichier que vous gardez a 4, puis ==, puis 4. Quand vous jugez cette page, cherchez les deux signes égaux entre les deux nombres. Ne jugez pas le fichier à partir de l'écran seul.

Les espaces autour du signe d'interrogation sont permis. bool match = 4==4; sans espaces range encore true, et le build n'écrit pas d'erreur. bool match = 4 == 4; avec des espaces range encore true. Le fichier que vous gardez utilise des espaces autour du signe d'interrogation, parce que le signe est plus facile à voir ainsi. Les espaces ne sont pas une seconde valeur. Un espace entre les deux signes égaux n'est pas permis. bool match = 4 = = 4; fait écrire une erreur au build. Gardez les deux signes égaux ensemble en ==.

Le nom doit exister avant qu'une ligne l'utilise. Si Console.WriteLine(match); est écrit au-dessus de bool match = 4 == 4;, 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 match existe déjà : match = 4 == 4;. Cette forme est permise. Elle n'est pas obligatoire. Le fichier que vous gardez crée le nom et range la réponse sur une ligne.

Quand les nombres ne correspondent pas

Changez seulement le second nombre. Gardez le mot de type bool. Gardez le nom match. Gardez le signe d'interrogation en deux signes égaux. bool match = 4 == 9; demande si 4 correspond à 9. Ils ne correspondent pas. Le mot rangé est false. La ligne d'écriture reste Console.WriteLine(match);. L'écran montre false. Une ligne. Le nom match n'est pas à l'écran. Les chiffres 4 et 9 ne sont pas à l'écran. Le signe d'interrogation n'est pas à l'écran.

C'est le second fichier. Ce n'est pas le fichier que vous gardez. Exécutez dotnet run. L'écran montre false. Une ligne. Il ne montre pas 4. Il ne montre pas 9. Il ne montre pas 4 == 9 comme lettres. Si l'écran montre true, vous êtes encore sur le fichier que vous gardez, où les deux nombres sont 4. Mettez ce second fichier en place seulement quand vous voulez voir false d'une interrogation qui ne correspond pas. Après avoir vu false, remettez le fichier gardé : bool match = 4 == 4; et un Console.WriteLine(match);. L'écran gardé est true, une ligne.

Le signe d'interrogation ne corrige pas les nombres. Il ne change pas 9 en 4. Il répond seulement. true signifie que les deux côtés correspondent. false signifie qu'ils ne correspondent pas. La page vrai et faux rangeait true ou false en écrivant le mot lui-même. Cette page range true ou false en interrogeant avec un signe. Les deux pages utilisent le même mot de type, bool. Les deux pages écrivent les mêmes deux mots à l'écran. La forme du fichier est différente. Le fichier que vous gardez sur cette page a le signe d'interrogation et deux entiers.

Autres signes d'interrogation

Deux signes égaux ne sont pas le seul signe d'interrogation. Un signe qui demande si les nombres ne sont pas les mêmes s'écrit comme un point d'exclamation et un signe égal ensemble : !=. bool match = 4 != 9; range true, parce que 4 et 9 ne sont pas les mêmes. bool match = 4 != 4; range false, parce que les nombres sont les mêmes. Cette exécution est permise, et ce n'est pas le fichier que vous gardez. Exécutez dotnet run. Pour 4 != 9, l'écran montre true. Après avoir vu cette ligne, remettez le fichier gardé.

Un signe qui demande si le nombre de gauche est plus grand s'écrit >. bool match = 9 > 4; range true. bool match = 4 > 9; range false. bool match = 4 > 4; range false, parce que 4 n'est pas plus grand que 4. Un signe qui demande si le nombre de gauche est plus petit s'écrit <. bool match = 4 < 9; range true. bool match = 9 < 4; range false. bool match = 4 < 4; range false.

Un signe qui demande si le nombre de gauche est plus grand ou le même s'écrit >=. Le signe égal est collé au signe plus grand sans espace. bool match = 4 >= 4; range true. bool match = 9 >= 4; range true. bool match = 4 >= 9; range false. Un signe qui demande si le nombre de gauche est plus petit ou le même s'écrit <=. bool match = 4 <= 4; range true. bool match = 4 <= 9; range true. bool match = 9 <= 4; range false. Le signe égal supplémentaire signifie « ou le même ». Ce n'est pas une seconde interrogation séparée. Ne mettez pas d'espace à l'intérieur de >= ni à l'intérieur de <=. bool match = 4 > = 4; fait écrire une erreur au build.

Lisez le tableau à côté d'une exécution, pas à la place. Pour l'interrogation gardée, le build n'écrit pas d'erreur et dotnet run écrit true. Pour des nombres qui ne correspondent pas avec ==, l'écran est false. Pour != avec 4 et 9, l'écran est true. Pour 9 > 4, l'écran est true. Pour 4 < 9, l'écran est true. Pour 4 >= 4, l'écran est true. Pour 4 <= 9, l'écran est true. Après chaque vérification, remettez le fichier gardé : bool match = 4 == 4; et Console.WriteLine(match);. L'écran gardé est true, une ligne.

Des guillemets autour d'un nombre le transforment en lettres. bool match = "4" == 4; demande à C# de comparer des lettres avec un entier d'une façon que cette page n'enseigne pas. Le build écrit une erreur. Supprimez les guillemets. Les deux côtés du signe d'interrogation, sur cette page, sont des entiers sans guillemets. Console.WriteLine(4 == 4); sans nom match du tout écrit aussi true. L'écran peut sembler identique. Le fichier que vous gardez range la réponse sous un nom d'abord, puis écrit ce nom. Quand vous jugez cette page, cherchez bool match et le signe d'interrogation sur la ligne de rangement.

Cette page compare des entiers. Elle ne compare pas des lettres sous guillemets avec == comme leçon gardée. Une page ultérieure enseigne une autre façon de demander si deux groupes de lettres correspondent. Si l'écran montre leaf, ou mint, plants ou plant est encore dans le fichier. Supprimez ces lignes. Si l'écran montre 13, total est encore dans le fichier. Supprimez cette ligne. Les signes logiques qui combinent deux réponses true ou false, comme &&, appartiennent à la page suivante. Cette page range une interrogation et une réponse.

Écrire le signe d'interrogation comme des lettres n'interroge pas. Console.WriteLine("4 == 4"); écrit les caractères 4, espace, =, =, espace, 4. L'écran montre 4 == 4. Ce n'est pas le mot true. Le build reste silencieux. Les guillemets empêchent le signe de fonctionner comme interrogation. Le fichier que vous gardez n'a pas de guillemets autour des nombres, et la ligne d'écriture n'a pas de guillemets autour du nom.

Vous pouvez maintenant ranger true ou false en demandant si deux entiers correspondent, et écrire ce mot. bool match = 4 == 4; range true. Console.WriteLine(match); écrit true et termine la ligne. bool match = 4 == 9; écrit false. Un signe égal range. Deux signes égaux interrogent. D'autres signes d'interrogation écrivent true ou false pour plus grand, plus petit, ou pas les mêmes. La page suivante laisse une seule interrogation. Elle regarde les signes qui combinent deux réponses true ou false en une réponse.

L'écran est true ou false

Le fichier que vous gardez écrit true. Le nom sur la ligne d'écriture est match, et match n'est pas à l'écran. Les deux signes égaux sont dans le fichier, et ils ne sont pas à l'écran. 4 et 4 sont dans le fichier, et ils ne sont pas à l'écran comme chiffres. Les nombres qui ne correspondent pas, et les autres signes d'interrogation, ne sont pas le fichier que vous gardez. Des guillemets autour de l'interrogation écrivent des lettres, pas le mot-réponse.