Sortie

Changez le mot entre les guillemets et l’écran change avec lui. Le type d’enseignement est encore Pine, et l’appel d’écriture est encore Console.WriteLine. La dernière fois les guillemets tenaient pine, donc l’écran était pine. Mettez un autre mot entre ces guillemets, ajoutez une deuxième ligne d’écriture, puis voyez ce que fait l’écran quand une ligne d’écriture ne termine pas la ligne. Vous ne réinstallez pas le SDK. Les notes de la page précédente restent hors de cette démo, sauf si vous les remettez vous-même.

Le mot entre les guillemets

Ouvrez le fichier Pine et trouvez Console.WriteLine("pine");. L’écran montre le mot entre les guillemets. Les guillemets eux-mêmes ne sont pas des lettres pour l’écran. Ils marquent où ce mot commence et où il finit. Changez le mot. Laissez le reste de la ligne tel quel : Console.WriteLine reste, le guillemet ouvrant reste, le guillemet fermant reste, et le point-virgule reste. Seules les lettres entre les guillemets changent. Là où le fichier avait pine, écrivez leaf, tout en petites lettres. La ligne est maintenant Console.WriteLine("leaf");. Enregistrez le fichier. Le nom de la classe est encore Pine, parce que la ligne public class Pine nomme encore le type. Cette page ne renomme pas le type.

Le fichier que vous gardez

Gardez cette forme d’enseignement. Elle a une ligne d’écriture, et cette ligne tient leaf entre les guillemets. Il n’y a pas de note dans ce fichier. Il n’y a pas encore de deuxième ligne d’écriture.

Lisez-le depuis le haut et décidez ce que l’écran peut recevoir. La ligne using System; prépare des noms courts et n’écrit pas l’écran. La ligne de classe est public class Pine. Cette ligne nomme le type. Elle n’écrit pas l’écran. La ligne suivante est public static void Main(). C’est là que le runtime démarre. Aucun de ces mots n’est une lettre pour l’écran. À l’intérieur de Main il y a une commande : Console.WriteLine("leaf");. Console.WriteLine est la commande d’écriture. Les guillemets tiennent leaf. Le point-virgule termine la commande. Le runtime exécute cette commande parce qu’elle est dans Main et qu’elle n’est pas derrière //. L’écran reçoit leaf. Il ne reçoit pas les guillemets, le point-virgule, le mot Console, ni le mot Main.

Exécutez-le avec dotnet run dans le dossier du projet. L’écran montre leaf. Une ligne. Sans guillemets. Sans point-virgule. Le mot pine n’est pas à l’écran, parce que pine n’est plus entre les guillemets. Si l’écran montre encore pine, les guillemets contiennent encore pine. Regardez les lettres entre les guillemets avant de relancer. Vous ne réinstallez pas le .NET SDK pour un écran qui dit encore pine.

L’écran copie les lettres entre les guillemets, et il les copie telles quelles. Console.WriteLine("Leaf"); écrit Leaf, avec un L majuscule. Console.WriteLine("leaf"); écrit leaf, avec un l minuscule. Le fichier que vous gardez utilise le petit l, donc son écran est leaf et non Leaf. Un espace est aussi une lettre que l’écran peut montrer, si vous tapez l’espace à l’intérieur des guillemets. Console.WriteLine("leaf stem"); écrit une ligne, leaf stem, avec l’espace que vous avez mis entre les deux mots. Les guillemets n’apparaissent toujours pas. C’est une ligne d’écriture, donc une ligne d’écran, même si deux mots sont à l’intérieur. Une paire de guillemets vides est différente. Console.WriteLine(""); écrit une ligne sans lettres, puis termine cette ligne. L’écran paraît vide. La commande a bien tourné. Les guillemets ne tenaient simplement rien. Cette ligne vide n’est pas le fichier que vous gardez. Le fichier que vous gardez tient leaf.

Une deuxième ligne

Une ligne d’écriture donne une ligne d’écran. Une deuxième ligne d’écran a besoin d’une deuxième ligne d’écriture. Sous Console.WriteLine("leaf"); ajoutez Console.WriteLine("stem");. Chaque commande a ses propres guillemets et son propre point-virgule. leaf reste dans la première paire de guillemets. stem, tout en petites lettres, va dans la deuxième paire. Le runtime exécute la première commande, termine cette ligne, puis exécute la deuxième et termine cette ligne aussi. L’ordre de l’écran est l’ordre du fichier. La commande que vous avez écrite en premier est la ligne que l’écran montre en premier.

C’est le deuxième fichier. Vous regardez deux lignes d’écran. Le fichier que vous gardiez avait une ligne d’écriture et l’écran était leaf. Celui-ci a deux lignes d’écriture. Utilisez-le quand vous voulez voir cet écran, puis remettez la ligne d’écriture unique si vous voulez le fichier que cette page garde.

Lancez dotnet run. L’écran montre leaf, et la ligne suivante de l’écran est stem. Deux lignes. leaf est en haut parce que Console.WriteLine("leaf"); est la première commande d’écriture. stem est en dessous parce que Console.WriteLine("stem"); est la deuxième. Les guillemets ne sont sur aucune des deux lignes. Si stem est en haut et leaf en dessous, les deux lignes d’écriture dans le fichier sont dans cet ordre inversé. L’écran ne choisit pas un ordre à lui. Remettez la commande stem sous la commande leaf, enregistrez, et relancez. Vous n’avez pas besoin d’un nouveau type de commande pour la deuxième ligne. Vous avez besoin d’un second Console.WriteLine, avec son propre mot entre ses propres guillemets.

Write ne termine pas la ligne

Regardez la fin de la commande d’écriture que vous avez utilisée. WriteLine se termine par les lettres Line. Ces lettres sont la fin de ligne. La commande écrit les lettres entre les guillemets, puis termine la ligne, donc la commande d’écriture suivante commence sur une ligne neuve. Write est le même aide d’écriture sans ces lettres. Console.Write("leaf"); écrit leaf et ne termine pas la ligne. Le Console.Write suivant commence là où ce mot s’est arrêté. Rien dans la commande n’insère un espace pour vous. Si la première paire tient leaf et la deuxième stem, et qu’aucune paire ne tient d’espace, l’écran montre leafstem comme une seule ligne.

C’est le troisième fichier. Ce n’est pas le fichier que vous gardez. Gardez-le assez longtemps pour voir la ligne unique leafstem. Les deux commandes sont Write, pas WriteLine. Il n’y a pas d’espace à l’intérieur de chaque paire de guillemets.

Lancez dotnet run. L’écran montre leafstem. Une ligne. Sans espace entre leaf et stem. Sans guillemets. leaf est encore en premier, parce que Console.Write("leaf"); est la première commande, et stem est collé juste après, parce que Console.Write("stem"); ne commence pas une nouvelle ligne. Si vous voyez leaf puis stem sur une deuxième ligne, les commandes du fichier sont WriteLine, pas Write. Les lettres Line sont encore sur la commande, donc chaque commande a terminé sa ligne. Enlevez Line des deux commandes si l’écran que vous voulez est le mot unique leafstem.

Le programme écrit leafstem et se termine sans terminer la ligne. Le terminal peut dessiner son propre invite sur cette même ligne, après leafstem. L’invite appartient au terminal. Ce n’est pas un mot du fichier Pine, et ce n’est pas une partie de la ligne que vous contrôlez. Vérifiez les lettres entre les guillemets : leafstem. N’essayez pas de faire correspondre l’invite. Windows et macOS dessinent des invites différentes, et cette page n’enseigne pas ces invites. La ligne du programme est la même sur les deux : leafstem, sans fin de ligne après elle.

Un espace doit être dans les guillemets

Si vous voulez un espace sur cette même ligne, l’espace doit être une des lettres entre les guillemets. La commande d’écriture ne l’invente pas. Changez la première commande en Console.Write("leaf "); avec un espace après le f, encore à l’intérieur des guillemets. Laissez la deuxième commande comme Console.Write("stem");. C# écrit leaf, puis écrit l’espace que vous avez mis après le f, puis écrit stem, et ne termine toujours pas la ligne. L’écran montre leaf stem. L’espace que vous voyez est l’espace qui était dans la première paire de guillemets. Un espace tapé hors des guillemets, entre les deux commandes, n’est qu’un écart dans le fichier. Ce n’est pas une lettre pour l’écran. Vous pouvez casser les deux commandes sur deux lignes dans le fichier, ou mettre une ligne vide entre elles, et l’écran est encore une ligne. Les sauts de ligne dans le fichier ne sont pas des fins de ligne à l’écran. Seule la commande de fin de ligne, WriteLine, termine une ligne d’écran. Write ne le fait jamais, peu importe l’espacement du fichier autour.

L’erreur qui enlève les guillemets

Le mot que l’écran montre doit s’asseoir entre des guillemets. L’erreur est de supprimer les guillemets et de laisser le mot nu : Console.WriteLine(leaf);. leaf sans guillemets n’est pas un mot pour l’écran. C# le lit comme un nom, et ce fichier n’a pas encore ce nom. La page suivante parle des noms. Cette page s’arrête aux guillemets. Gardez cette quatrième forme seulement assez longtemps pour voir que la construction ne reste pas silencieuse, puis remettez les guillemets. Ce n’est pas le fichier que vous gardez.

Lancez dotnet run ou construisez le projet. Cette fois le compilateur écrit une erreur. Il ne reste pas silencieux. Le fichier n’est pas correct, parce que leaf n’a pas de guillemets et n’a pas encore de sens dans ce fichier. Vous n’avez pas besoin des mots exacts de cette erreur. Le fait utile est que la construction a écrit une ligne du tout. Quand la construction écrit une erreur, il n’y a pas de nouvel écran à croire jusqu’à ce que le fichier soit de nouveau correct. Remettez les guillemets, pour que la ligne soit encore Console.WriteLine("leaf");. Enregistrez. Relancez. Maintenant la construction reste assez silencieuse pour s’exécuter, et l’écran montre leaf. Les guillemets étaient toute la réparation. Vous ne réinstallez pas le SDK, et vous n’enlevez pas la ligne d’écriture. Une ligne d’écriture sans guillemets n’est pas un écran vide dû à une note. Une note aurait laissé la construction silencieuse. Cette erreur fait parler le compilateur. Gardez les habitudes Java restantes avec System.out.println mappées ici à Console.WriteLine, et System.out.print à Console.Write. Gardez l’invention de routes ASP.NET hors de cette page.

L’écran est le mot entre guillemets

Vous pouvez maintenant changer l’écran en changeant les lettres entre les guillemets. Console.WriteLine("leaf"); écrit leaf et termine la ligne. Un second Console.WriteLine écrit la ligne suivante, dans l’ordre où vous avez écrit les commandes dans le fichier. Console.Write écrit ses lettres et ne termine pas la ligne, donc un Write suivant continue sur cette même ligne, et un espace n’apparaît que lorsque vous le mettez à l’intérieur des guillemets. Si la construction écrit une erreur sur un mot nu, les guillemets manquent. Remettez le fichier à celui que vous gardez quand vous avez fini de regarder leafstem. La ligne d’écriture dans le fichier que vous gardez est Console.WriteLine("leaf"); et il n’y a pas de deuxième ligne d’écriture. La page suivante donne un nom à un mot, pour qu’une ligne d’écriture puisse utiliser ce nom au lieu d’un seul mot entre guillemets.