Variables
Console.WriteLine(plant) écrit leaf, et la ligne d’écriture n’a pas de guillemets. Le mot leaf se trouve sur la ligne de rangement, sous le nom plant. Jusqu’ici le mot était entre guillemets sur la ligne d’écriture elle-même, donc un autre écran voulait dire éditer cette ligne. Les guillemets passent sur la ligne qui range le mot. L’écran montre encore leaf. Gardez la classe publique nommée Pine. Vous ne réinstallez pas le SDK.
Un nom tient les lettres
Ouvrez le fichier Pine. Le nom de la classe reste Pine. Cette page ne renomme pas le type. À l’intérieur de Main, au-dessus de la ligne d’écriture, ajoutez une ligne qui crée un nom et y range un mot : string plant = "leaf";. Le mot-clé string dit que ce nom tient des lettres. plant est le nom, et il commence par un petit p. Le signe = range le mot. Les guillemets tiennent leaf, tout en petites lettres, le même mot que la page précédente mettait sur la ligne d’écriture. Le point-virgule termine cette ligne. Ensuite changez la ligne d’écriture pour qu’elle n’ait plus de guillemets. Elle devient Console.WriteLine(plant);. Le nom plant est nu. Il n’y a pas de guillemet avant le p ni après le t. Enregistrez le fichier.
Le fichier que vous gardez
Gardez cette forme d’enseignement. Le nom plant tient leaf. La ligne d’écriture utilise ce nom et ne contient pas de guillemets.
using System;
public class Pine
{
public static void Main()
{
string plant = "leaf";
Console.WriteLine(plant);
}
}
Lisez-le depuis le haut et décidez ce que l’écran peut recevoir. using System; prépare des noms courts et n’écrit pas l’écran. public class Pine nomme le type. Il n’écrit pas l’écran. public static void Main() est l’endroit où le runtime démarre. Aucun de ces mots n’est une lettre pour l’écran. La ligne suivante est celle qui crée le nom. string plant = "leaf"; range les lettres l, e, a, f dans le nom plant. Ces lettres ne sont pas écrites à l’écran par cette ligne. Ranger n’est pas écrire. L’écran reste vide pendant cette ligne. La ligne suivante, Console.WriteLine(plant);, est la ligne d’écriture. C# lit le nom plant, prend les lettres que ce nom tient, les écrit, et termine la ligne. L’écran montre leaf. Une ligne. Sans guillemets. Les lettres du nom, plant, ne sont pas à l’écran. Console n’est pas à l’écran. Le point-virgule n’est pas à l’écran.
Exécutez-le avec dotnet run. L’écran montre leaf. Si l’écran montre plant, la ligne d’écriture a des guillemets autour de plant. Le fichier que vous gardez n’en a pas. Si l’écran montre encore un mot entre guillemets de la page précédente, la ligne d’écriture utilise encore des guillemets au lieu du nom nu. Regardez les lettres entre les guillemets sur la ligne string, et regardez si la ligne d’écriture utilise le nom nu. Vous ne réinstallez pas le .NET SDK pour un écran qui montre le mauvais mot.
Ligne de rangement et ligne d’écriture
Gardez les deux rôles faciles à distinguer.
📊 Variable habits for plant
| Line | Job | Screen |
|---|---|---|
string plant = "leaf"; |
stores letters in the name | nothing from this line |
Console.WriteLine(plant); |
writes the letters the name holds | leaf |
Console.WriteLine("plant"); |
writes the quoted letters | plant |
plant = "stem"; |
replaces the stored letters | nothing from this line alone |
Changez le mot, gardez la ligne d’écriture
L’intérêt du nom, c’est que la ligne d’écriture peut rester en place pendant que le mot rangé change. Sous la première ligne d’écriture, rangez un nouveau mot dans le même nom, puis écrivez le nom encore une fois. La nouvelle ligne de rangement est plant = "stem";. Elle ne commence pas par string. plant existe déjà, donc cette ligne remplace seulement les lettres que le nom tient. leaf est remplacé par stem, tout en petites lettres. La ligne d’écriture suivante est encore Console.WriteLine(plant);. C’est la même forme que la première ligne d’écriture. L’écran a maintenant deux lignes, parce que chaque WriteLine termine sa ligne. La première ligne est leaf, d’après les lettres que le nom tenait à ce moment. La deuxième ligne est stem, d’après les lettres que le nom tient après plant = "stem";.
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 et une ligne d’écriture, et son écran est leaf. Utilisez cette deuxième forme quand vous voulez voir le mot changer, puis remettez la ligne de rangement unique et la ligne d’écriture unique.
using System;
public class Pine
{
public static void Main()
{
string plant = "leaf";
Console.WriteLine(plant);
plant = "stem";
Console.WriteLine(plant);
}
}
Lancez dotnet run. L’écran montre leaf, et la ligne suivante de l’écran est stem. Deux lignes. leaf est en haut parce que le premier Console.WriteLine(plant); s’exécute pendant que plant tient encore leaf. stem est en dessous parce que le second Console.WriteLine(plant); s’exécute après plant = "stem";. Le nom plant n’est sur aucune des deux lignes d’écran. Si les deux lignes d’écran disent leaf, la deuxième ligne de rangement manque ou dit encore "leaf". Si les deux disent stem, la première ligne de rangement dit déjà "stem", ou la première ligne d’écriture est sous le changement. L’écran suit l’ordre des lignes dans le fichier.
N’écrivez pas string une deuxième fois pour le même nom. string plant = "stem";, placé sous une ligne qui a déjà créé plant, est une autre erreur. Cette ligne essaie de créer plant encore une fois. Le build écrit une erreur et ne reste pas silencieux. La réparation est de supprimer le second string et de laisser plant = "stem";. Le nom est créé une fois. Les lignes suivantes ne changent que les lettres qu’il tient. Sur le fichier que vous gardez il n’y a aucune deuxième ligne de rangement.
Les guillemets autour du nom écrivent le nom
La ligne d’écriture dans le fichier que vous gardez est Console.WriteLine(plant); sans guillemets. Si vous mettez des guillemets autour du nom, la ligne devient Console.WriteLine("plant");. Ces guillemets font ce que les guillemets faisaient sur la page précédente. Ils marquent des lettres pour l’écran. Les lettres entre eux sont p, l, a, n, t. C# ne cherche pas le nom, parce qu’un mot entre guillemets n’est pas un nom. Le nom plant peut encore tenir leaf sur la ligne au-dessus, et l’écran montre quand même plant. Le mot rangé leaf n’est pas écrit, parce que la ligne d’écriture n’a jamais utilisé le nom.
C’est le troisième fichier. Ce n’est pas le fichier que vous gardez. Gardez-le assez longtemps pour voir la ligne unique plant, puis retirez les guillemets de la ligne d’écriture.
using System;
public class Pine
{
public static void Main()
{
string plant = "leaf";
Console.WriteLine("plant");
}
}
Lancez dotnet run. L’écran montre plant. Une ligne. Sans guillemets. Pas leaf. Pas stem. Si vous vouliez leaf, la ligne d’écriture doit être le nom nu Console.WriteLine(plant);. Les guillemets appartiennent à la ligne de rangement, autour de leaf, pas à la ligne d’écriture autour du nom. Gardez les habitudes Java restantes de String mappées vers le mot-clé C# string sur cette page. Gardez l’invention de routes ASP.NET hors de cette page.
Le nom doit exister d’abord
C# lit le fichier depuis le haut. La ligne qui crée le nom doit être au-dessus de la ligne qui utilise le nom. Si vous mettez Console.WriteLine(plant); en premier, et seulement ensuite string plant = "leaf";, la ligne d’écriture nomme plant avant que plant existe. 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 ligne string au-dessus de la ligne d’écriture.
Ce quatrième fichier est l’ordre cassé. Ce n’est pas le fichier que vous gardez. Gardez-le seulement jusqu’à ce que le build écrive l’erreur, puis remettez la ligne string en haut.
using System;
public class Pine
{
public static void Main()
{
Console.WriteLine(plant);
string plant = "leaf";
}
}
L’écran est le mot que le nom tient
Vous pouvez maintenant ranger un mot dans un nom et écrire ce mot sans le mettre sur la ligne d’écriture. string plant = "leaf"; range leaf. Console.WriteLine(plant); écrit leaf et termine la ligne. Plus tard plant = "stem"; change le mot rangé, et un WriteLine ultérieur du même nom écrit stem. Des guillemets autour du nom écrivent les lettres du nom à la place. La ligne de création doit être au-dessus de la première ligne qui utilise le nom. La page suivante lit un mot que vous tapez pendant que le programme tourne, et range ce mot dans un nom, pour que l’écran puisse montrer des lettres qui n’étaient pas écrites entre guillemets dans le fichier.
🧠 Testez Vos Connaissances
Testez Vos Connaissances
Mettez-vous au défi avec ce quiz interactif et voyez à quel point vous comprenez le sujet
📝 Instructions
- Lisez chaque question attentivement
- Sélectionnez la meilleure réponse pour chaque question
- Vous pouvez refaire le quiz autant de fois que vous le souhaitez
- Votre progression sera affichée en haut