Variables

Console.WriteLine(plant) escribe leaf, y la línea de escritura no tiene comillas. La palabra leaf está en la línea de guardado, bajo el nombre plant. Hasta ahora la palabra iba entre comillas en la propia línea de escritura, así que otra pantalla significaba editar esa línea. Las comillas pasan a la línea que guarda la palabra. La pantalla sigue mostrando leaf. Mantén la clase pública llamada Pine. No estás instalando el SDK otra vez.

Un nombre guarda las letras

Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Dentro de Main, encima de la línea de escritura, añade una línea que crea un nombre y guarda una palabra en él: string plant = "leaf";. La palabra clave string dice que este nombre guarda letras. plant es el nombre y empieza con p minúscula. El signo = guarda la palabra. Las comillas llevan leaf, todo en minúsculas, la misma palabra que la página anterior puso en la línea de escritura. El punto y coma termina esta línea. Luego cambia la línea de escritura para que ya no tenga comillas. Queda Console.WriteLine(plant);. El nombre plant va desnudo. No hay comilla antes de la p ni después de la t. Guarda el archivo.

El archivo que guardas

Conserva esta forma de enseñanza. El nombre plant guarda leaf. La línea de escritura usa ese nombre y no lleva comillas.

Léelo desde arriba y decide qué puede recibir la pantalla. using System; prepara nombres cortos y no escribe la pantalla. public class Pine nombra el tipo. No escribe la pantalla. public static void Main() es donde empieza el tiempo de ejecución. Ninguna de esas palabras son letras para la pantalla. La siguiente línea es la que crea el nombre. string plant = "leaf"; guarda las letras l, e, a, f en el nombre plant. Esa línea no escribe esas letras en la pantalla. Guardar no es escribir. La pantalla sigue en blanco durante esa línea. La línea siguiente, Console.WriteLine(plant);, es la línea de escritura. C# lee el nombre plant, toma las letras que ese nombre guarda, las escribe y termina la línea. La pantalla muestra leaf. Una línea. Sin comillas. Las letras del nombre, plant, no están en la pantalla. Console no está en la pantalla. El punto y coma no está en la pantalla.

Ejecútalo con dotnet run. La pantalla muestra leaf. Si la pantalla muestra plant, la línea de escritura tiene comillas alrededor de plant. El archivo que guardas no. Si la pantalla sigue mostrando una palabra entre comillas de la página anterior, la línea de escritura sigue usando comillas en lugar del nombre desnudo. Mira las letras entre las comillas en la línea string y mira si la línea de escritura usa el nombre desnudo. No reinstalas el .NET SDK por una pantalla que muestra la palabra equivocada.

Línea de guardado y línea de escritura

Mantén las dos tareas fáciles de distinguir.

Cambia la palabra, deja la línea de escritura

El punto del nombre es que la línea de escritura puede quedarse fija mientras cambia la palabra guardada. Debajo de la primera línea de escritura, guarda una palabra nueva en el mismo nombre y luego escribe el nombre otra vez. La nueva línea de guardado es plant = "stem";. No empieza con string. plant ya existe, así que esta línea solo reemplaza las letras que el nombre guarda. leaf se reemplaza por stem, todo en minúsculas. La siguiente línea de escritura es otra vez Console.WriteLine(plant);. Tiene la misma forma que la primera línea de escritura. La pantalla ahora tiene dos líneas, porque cada WriteLine termina su línea. La primera línea es leaf, de las letras que el nombre guardaba en ese momento. La segunda línea es stem, de las letras que el nombre guarda después de plant = "stem";.

Este es el segundo archivo. No es el archivo que guardas. El archivo que guardas tiene una línea de guardado y una de escritura, y su pantalla es leaf. Usa esta segunda forma cuando quieras ver el cambio de palabra y luego vuelve a poner la única línea de guardado y la única de escritura.

Ejecuta dotnet run. La pantalla muestra leaf, y la siguiente línea de la pantalla es stem. Dos líneas. leaf está arriba porque el primer Console.WriteLine(plant); corre mientras plant todavía guarda leaf. stem está debajo porque el segundo Console.WriteLine(plant); corre después de plant = "stem";. El nombre plant no está en ninguna línea de pantalla. Si ambas líneas de pantalla dicen leaf, falta la segunda línea de guardado o todavía dice "leaf". Si ambas dicen stem, la primera línea de guardado ya dice "stem", o la primera línea de escritura está debajo del cambio. La pantalla sigue el orden de las líneas del archivo.

No escribas string una segunda vez para el mismo nombre. string plant = "stem"; debajo de una línea que ya creó plant es otro error. Esa línea intenta crear plant otra vez. La compilación escribe un error y no se queda en silencio. La reparación es borrar el segundo string y dejar plant = "stem";. El nombre se crea una vez. Las líneas posteriores solo cambian las letras que guarda. En el archivo que guardas no hay segunda línea de guardado en absoluto.

Comillas alrededor del nombre escriben el nombre

La línea de escritura en el archivo que guardas es Console.WriteLine(plant); sin comillas. Si pones comillas alrededor del nombre, la línea es Console.WriteLine("plant");. Esas comillas hacen lo que hacían en la página anterior. Marcan letras para la pantalla. Las letras entre ellas son p, l, a, n, t. C# no busca el nombre, porque una palabra entre comillas no es un nombre. El nombre plant puede seguir guardando leaf en la línea de arriba, y la pantalla sigue mostrando plant. La palabra guardada leaf no se escribe, porque la línea de escritura nunca usó el nombre.

Este es el tercer archivo. No es el archivo que guardas. Consérvalo el tiempo suficiente para ver la única línea plant y luego quita las comillas de la línea de escritura otra vez.

Ejecuta dotnet run. La pantalla muestra plant. Una línea. Sin comillas. No leaf. No stem. Si querías leaf, la línea de escritura tiene que ser el nombre desnudo Console.WriteLine(plant);. Las comillas pertenecen a la línea de guardado, alrededor de leaf, no alrededor del nombre en la línea de escritura. Mantén los hábitos restantes de Java con String mapeados a la palabra clave de C# string en esta página. Mantén inventar rutas de ASP.NET fuera de esta página.

El nombre tiene que existir primero

C# lee el archivo de arriba abajo. La línea que crea el nombre tiene que estar encima de la línea que usa el nombre. Si pones primero Console.WriteLine(plant); y solo después escribes string plant = "leaf";, la línea de escritura nombra plant antes de que plant exista. La compilación escribe un error. No se queda en silencio. No hay pantalla en la que confiar mientras la compilación escribe un error. La reparación es volver a poner la línea string encima de la línea de escritura.

Este cuarto archivo es el orden roto. No es el archivo que guardas. Consérvalo solo hasta que la compilación escriba el error y luego vuelve a poner la línea string arriba.

La pantalla es la palabra que el nombre guarda

Ya puedes guardar una palabra en un nombre y escribir esa palabra sin ponerla en la línea de escritura. string plant = "leaf"; guarda leaf. Console.WriteLine(plant); escribe leaf y termina la línea. Más adelante plant = "stem"; cambia la palabra guardada, y un WriteLine posterior del mismo nombre escribe stem. Las comillas alrededor del nombre escriben las letras del nombre en su lugar. La línea de creación tiene que estar encima de la primera línea que usa el nombre. La página siguiente lee una palabra que escribes mientras el programa corre y la guarda en un nombre, para que la pantalla pueda mostrar letras que no estaban entre comillas en el archivo.