Chaînes

string plant = "leaf"; range les quatre lettres leaf, et Console.WriteLine(plant) écrit leaf. Les guillemets restent dans le fichier. Ils ne sont pas à l’écran. La page précédente rangeait le nombre entier 4 sans guillemets autour. Ici, c’est la paire de guillemets qui tient les lettres, et une paire manquante fait écrire une erreur au build. Gardez la classe publique nommée Pine. Vous ne réinstallez pas le SDK.

Les guillemets tiennent les lettres

Ouvrez le fichier Pine. Le nom de la classe reste Pine. Cette page ne renomme pas le type. La dernière page gardait int count = 4; sans guillemets et sans clavier. Cette page ne garde pas ce nombre. Supprimez la ligne int si elle est encore là. Supprimez toute ligne ReadLine. Le fichier que vous gardez n’a ni attente ni ligne de nombre entier. Les lettres ne sont écrites que par la ligne d’écriture qui utilise le nom.

Dans Main, la ligne de rangement est string plant = "leaf";. string est le mot de genre. Il dit que ce nom tient des lettres. plant est le nom, et il commence par un petit p. Le signe = range les lettres. Ensuite vient la paire. Le premier guillemet ouvre les lettres. Les quatre lettres sont l, e, a, f, dans cet ordre, toutes petites. Le second guillemet ferme les lettres. Rien d’autre n’est entre ces deux guillemets : pas d’espace, pas de lettre en plus, pas de second mot. Le point-virgule termine la ligne. Cette ligne n’écrit pas l’écran. Ranger n’est pas écrire. L’écran reste vide pendant cette ligne. Les guillemets font partie de la ligne de rangement. Ils ne font pas partie de la valeur que le nom tient après que la ligne a rangé.

La ligne d’écriture est le nom nu : Console.WriteLine(plant);. Pas de guillemets. C# lit le nom plant, écrit les lettres que ce nom tient, et termine la ligne. Pour le fichier que vous gardez, ces lettres sont l, e, a, f. Les marques de guillemets ne sont pas à l’écran. Les lettres du nom, p, l, a, n, t, ne sont pas à l’écran. string n’est pas à l’écran. Console n’est pas à l’écran. Le point-virgule n’est pas à l’écran. Enregistrez le fichier.

Le fichier que vous gardez

Gardez cette forme d’enseignement. Un mot de genre, string. Un nom, plant. Une paire de guillemets. Quatre lettres entre eux, leaf. Une ligne d’écriture, et cette ligne utilise le nom nu.

Lisez-le depuis le haut. using System; prépare les noms courts. public class Pine nomme le type. public static void Main() est l’endroit où le runtime démarre. Aucun de ces mots n’est les lettres à l’écran. La ligne de rangement est string plant = "leaf";. Cette ligne range les lettres. Elle n’écrit rien. Console.WriteLine(plant); est la seule ligne d’écriture. Elle écrit leaf et termine la ligne. Une ligne. Aucune marque de guillemet sur cette ligne d’écran.

Exécutez avec dotnet run. Le programme écrit leaf. Il n’attend pas que vous tapiez. Les lettres étaient déjà dans le fichier. Si dotnet run attend, le fichier a encore ReadLine. Supprimez cette ligne et gardez string plant = "leaf";. L’écran montre leaf, une ligne, quatre lettres, sans marques de guillemets. Si l’écran montre plant, la ligne d’écriture a des guillemets autour du nom : Console.WriteLine("plant");. Ces guillemets marquent les lettres p, l, a, n, t. C# ne cherche pas le nom, donc le leaf rangé n’est pas écrit. Le fichier que vous gardez a le nom nu sur la ligne d’écriture, et les guillemets autour de leaf sur la ligne de rangement. Si l’écran montre 4, le fichier a encore le nombre entier de la page précédente. Le fichier que vous gardez a leaf, pas 4. Vous ne réinstallez pas le .NET SDK pour un écran qui montre la mauvaise ligne.

Une majuscule entre les guillemets est rangée comme cette majuscule. string plant = "Leaf"; ferait écrire Leaf à la ligne d’écriture, avec un grand L. Le fichier que vous gardez ne fait pas cela. Il utilise quatre petites lettres. Jugez l’écran d’après les lettres qui sont vraiment entre les guillemets, pas d’après un mot que vous aviez seulement l’intention d’écrire.

Un espace est l’une des lettres

La ligne d’écriture peut rester en place pendant que les lettres entre les guillemets changent. Sous la première ligne d’écriture, rangez un nouvel ensemble de lettres dans le même nom, puis écrivez le nom à nouveau. La nouvelle ligne de rangement est plant = "leaf stem";. Elle ne commence pas par string. plant existe déjà, donc cette ligne remplace seulement les lettres que le nom tient. Entre les guillemets cette fois il y a neuf caractères : l, e, a, f, un espace, s, t, e, m. L’espace en est un. Ce n’est pas une coupure en deux lignes de rangement, et il n’est pas effacé quand l’écran est écrit. La ligne d’écriture suivante est encore Console.WriteLine(plant);. L’écran a maintenant deux lignes. La première est leaf, d’après les lettres que le nom tenait à ce moment. La seconde est leaf stem, d’après les lettres que le nom tient après plant = "leaf stem";. Un espace se place entre leaf et stem sur cette seconde ligne. Les deux mots ne sont pas sur deux lignes séparées.

C’est le deuxième fichier. Ce n’est pas le fichier que vous gardez. Le fichier que vous gardez a une ligne de rangement, les lettres leaf, et pas d’espace. Utilisez cette deuxième forme quand vous voulez voir l’espace, puis remettez la seule ligne de rangement et la seule ligne d’écriture.

Lancez dotnet run. L’écran montre leaf, et la ligne suivante est leaf stem. Deux lignes. Pas de marques de guillemets. Le nom plant n’est sur aucune des deux. Si la seconde ligne est leafstem, sans écart, l’espace manque entre les guillemets. Si les deux lignes sont leaf, la seconde ligne de rangement manque ou dit encore "leaf". L’écran suit l’ordre des lignes dans le fichier, et il suit les lettres entre les guillemets, espace compris. N’écrivez pas string une seconde fois pour le même nom. string plant = "leaf stem";, placé sous une ligne qui a déjà créé plant, fait écrire une erreur au build. Supprimez le second string et laissez plant = "leaf stem";.

Rien entre les guillemets

Une paire peut être vide. string plant = ""; a le guillemet ouvrant et le guillemet fermant, et aucune lettre entre eux. Le mot de genre est encore string. Le nom est encore plant. Le signe = range encore. Ce qu’il range, c’est aucune lettre. C’est autorisé. Le build n’écrit pas d’erreur pour une paire vide. Console.WriteLine(plant); s’exécute encore. Il écrit les lettres que le nom tient, et il n’y en a aucune, donc la ligne d’écran n’a pas de lettres. La ligne se termine quand même. Le programme se termine quand même. Vous pouvez voir une ligne vide là où leaf aurait été. Cette ligne vide est l’écriture. Ce n’est pas une attente, et ce n’est pas un échec de build.

C’est le troisième fichier. Ce n’est pas le fichier que vous gardez. Le fichier que vous gardez a leaf entre les guillemets. Gardez ce troisième fichier seulement jusqu’à ce que vous ayez vu la ligne vide, puis remettez "leaf" entre les guillemets.

Lancez dotnet run. La paire vide est autorisée, donc le build n’écrit aucune erreur. Le programme écrit une ligne sans lettres et se termine. Il n’attend pas. Si vous voyez encore leaf, les guillemets ont encore leaf entre eux. Après avoir vu la ligne vide, refaites la ligne de rangement string plant = "leaf";.

Sans les guillemets, leaf est un nom

La paire fait le travail. Enlevez les deux guillemets et la ligne devient string plant = leaf;. Il n’y a pas de paire, donc leaf n’est pas des lettres. C# lit leaf comme un nom, et ce fichier n’a pas de nom leaf. Le build écrit une erreur. Il ne reste pas silencieux. Il n’y a pas d’écran à croire pendant que le build écrit une erreur. La réparation est de remettre la paire, pour que la ligne soit à nouveau string plant = "leaf";. Un seul guillemet n’est pas une paire non plus. string plant = "leaf; ouvre les lettres et ne les ferme jamais avant le point-virgule. Le build écrit aussi une erreur pour cette ligne. Remettez le guillemet fermant avant le point-virgule.

Ce quatrième fichier est la paire manquante. Ce n’est pas le fichier que vous gardez. Gardez-le seulement jusqu’à ce que le build écrive l’erreur, puis remettez les guillemets autour de leaf.

Deux morceaux entre guillemets joints avec plus

Une ligne de rangement peut joindre deux morceaux entre guillemets avec +. La ligne string plant = "leaf" + "stem"; a deux paires. La première paire tient leaf. La seconde paire tient stem. Le + joint ces lettres en une seule valeur : leafstem, sans espace, parce qu’aucune paire n’avait d’espace. La ligne d’écriture est encore Console.WriteLine(plant);. L’écran montre leafstem sur une ligne. Ce ne sont pas deux lignes d’écriture. C’est un seul rangement qui construit un ensemble de lettres à partir de deux morceaux entre guillemets.

C’est le cinquième fichier. Ce n’est pas le fichier que vous gardez. Le fichier que vous gardez a une paire et les lettres leaf. Utilisez cette cinquième forme quand vous voulez voir la jointure, puis remettez la paire seule.

L’écran, ce sont les lettres entre les guillemets

Vous pouvez maintenant ranger des lettres dans un nom string et écrire ces lettres sans mettre de guillemets sur la ligne d’écriture. string plant = "leaf"; range leaf. Console.WriteLine(plant); écrit leaf et termine la ligne. Plus loin, plant = "leaf stem"; range l’espace comme l’une des lettres. Des guillemets vides ne rangent aucune lettre et écrivent une ligne vide. Sans les guillemets, leaf est lu comme un nom et le build écrit une erreur. "leaf" + "stem" joint en leafstem. La page suivante reste avec les lettres et regarde des méthodes qui travaillent sur un nom string, par exemple demander combien de lettres il tient.