Salida

Cambia la palabra entre las comillas y la pantalla cambia con ella. El tipo de enseñanza sigue siendo Pine, y la llamada de escritura sigue siendo Console.WriteLine. La vez anterior las comillas tenían pine, así que la pantalla era pine. Pon otra palabra entre esas mismas comillas, añade una segunda línea de escritura y luego mira qué hace la pantalla cuando una línea de escritura no termina la línea. No estás instalando el SDK otra vez. Las notas de la página anterior no están en esta demo salvo que tú las vuelvas a poner.

La palabra entre las comillas

Abre el archivo Pine y busca Console.WriteLine("pine");. La pantalla muestra la palabra entre las comillas. Las comillas mismas no son letras para la pantalla. Marcan dónde empieza esa palabra y dónde termina. Cambia la palabra. Deja el resto de la línea como está: Console.WriteLine se queda, la comilla de apertura se queda, la de cierre se queda y el punto y coma se queda. Solo cambian las letras entre las comillas. Donde el archivo tenía pine, escribe leaf, todo en minúsculas. La línea ahora es Console.WriteLine("leaf");. Guarda el archivo. El nombre de la clase sigue siendo Pine, porque la línea public class Pine sigue nombrando el tipo. Esta página no renombra el tipo.

El archivo que guardas

Conserva esta forma de enseñanza. Tiene una línea de escritura, y esa línea lleva leaf entre las comillas. En este archivo no hay nota. Todavía no hay una segunda línea de escritura.

Léelo desde arriba y decide qué puede recibir la pantalla. La línea using System; prepara nombres cortos y no escribe la pantalla. La línea de clase es public class Pine. Esa línea nombra el tipo. No escribe la pantalla. La siguiente línea es public static void Main(). Ahí empieza el tiempo de ejecución. Ninguna de esas palabras son letras para la pantalla. Dentro de Main hay un comando: Console.WriteLine("leaf");. Console.WriteLine es el comando de escritura. Las comillas llevan leaf. El punto y coma termina el comando. El tiempo de ejecución ejecuta ese comando porque está dentro de Main y no detrás de //. La pantalla recibe leaf. No recibe las comillas, ni el punto y coma, ni la palabra Console, ni la palabra Main.

Ejecútalo con dotnet run en la carpeta del proyecto. La pantalla muestra leaf. Una línea. Sin comillas. Sin punto y coma. La palabra pine no está en la pantalla, porque pine ya no está entre las comillas. Si la pantalla sigue mostrando pine, las comillas todavía contienen pine. Mira las letras entre las comillas antes de ejecutar otra vez. No reinstalas el .NET SDK por una pantalla que todavía dice pine.

La pantalla copia las letras entre las comillas tal como están. Console.WriteLine("Leaf"); escribe Leaf, con L mayúscula. Console.WriteLine("leaf"); escribe leaf, con l minúscula. El archivo que guardas usa la l minúscula, así que su pantalla es leaf y no Leaf. Un espacio también es una letra que la pantalla puede mostrar, si escribes el espacio dentro de las comillas. Console.WriteLine("leaf stem"); escribe una línea, leaf stem, con el espacio que pusiste entre las dos palabras. Las comillas siguen sin aparecer. Es una línea de escritura, así que es una línea de pantalla, aunque haya dos palabras dentro. Un par de comillas vacío es distinto. Console.WriteLine(""); escribe una línea sin letras y luego termina esa línea. La pantalla se ve en blanco. El comando sí se ejecutó. Las comillas simplemente no llevaban nada. Esa línea en blanco no es el archivo que guardas. El archivo que guardas lleva leaf.

Una segunda línea

Una línea de escritura da una línea de pantalla. Una segunda línea de pantalla necesita una segunda línea de escritura. Debajo de Console.WriteLine("leaf"); añade Console.WriteLine("stem");. Cada comando tiene sus propias comillas y su propio punto y coma. leaf se queda en el primer par. stem, todo en minúsculas, va en el segundo. El tiempo de ejecución ejecuta el primer comando, termina esa línea, luego ejecuta el segundo comando y también termina esa línea. El orden de la pantalla es el orden del archivo. El comando que escribiste primero es la línea que la pantalla muestra primero.

Este es el segundo archivo. Estás mirando dos líneas de pantalla. El archivo que guardabas tenía una línea de escritura y la pantalla era leaf. Este tiene dos líneas de escritura. Úsalo cuando quieras ver esta pantalla y luego vuelve a la línea de escritura única si quieres el archivo que esta página guarda.

Ejecuta dotnet run. La pantalla muestra leaf, y la siguiente línea de la pantalla es stem. Dos líneas. leaf está arriba porque Console.WriteLine("leaf"); es el primer comando de escritura. stem está debajo porque Console.WriteLine("stem"); es el segundo. Las comillas no están en ninguna línea. Si stem está arriba y leaf debajo, las dos líneas de escritura del archivo están en ese orden intercambiado. La pantalla no elige un orden propio. Vuelve a poner el comando stem debajo del comando leaf, guarda y ejecuta otra vez. No necesitas un tipo nuevo de comando para la segunda línea. Necesitas un segundo Console.WriteLine, con su propia palabra entre sus propias comillas.

Write no termina la línea

Mira el final del comando de escritura que has estado usando. WriteLine termina con las letras Line. Esas letras son el fin de línea. El comando escribe las letras entre las comillas y luego termina la línea, así que el siguiente comando de escritura empieza en una línea nueva. Write es el mismo ayudante de escritura sin esas letras. Console.Write("leaf"); escribe leaf y no termina la línea. El siguiente Console.Write empieza donde esa palabra se detuvo. Nada en el comando inserta un espacio por ti. Si el primer par lleva leaf y el segundo lleva stem, y ninguno lleva un espacio, la pantalla muestra leafstem como una sola línea.

Este es el tercer archivo. No es el archivo que guardas. Úsalo lo bastante para ver la línea única leafstem. Ambos comandos son Write, no WriteLine. No hay espacio dentro de ningún par de comillas.

Ejecuta dotnet run. La pantalla muestra leafstem. Una línea. Sin espacio entre leaf y stem. Sin comillas. leaf sigue primero porque Console.Write("leaf"); es el primer comando, y stem se pega después porque Console.Write("stem"); no empieza una línea nueva. Si ves leaf y luego stem en una segunda línea, los comandos del archivo son WriteLine, no Write. Las letras Line siguen en el comando, así que cada comando terminó su línea. Quita Line de ambos comandos si la pantalla que quieres es la palabra única leafstem.

El programa escribe leafstem y termina sin terminar la línea. El terminal puede dibujar su propio indicador en esa misma línea, después de leafstem. El indicador pertenece al terminal. No es una palabra del archivo Pine y no forma parte de la línea que estás comprobando. Comprueba las letras entre las comillas: leafstem. No intentes igualar el indicador. Windows y macOS dibujan indicadores distintos, y esta página no enseña esos indicadores. La línea del programa es la misma en ambos: leafstem, sin fin de línea después.

Un espacio tiene que estar dentro de las comillas

Si quieres un espacio en esa misma línea, el espacio tiene que ser una de las letras entre las comillas. El comando de escritura no lo inventa. Cambia el primer comando a Console.Write("leaf "); con un espacio después de la f, todavía dentro de las comillas. Deja el segundo comando como Console.Write("stem");. C# escribe leaf, luego escribe el espacio que pusiste después de la f, luego escribe stem, y sigue sin terminar la línea. La pantalla muestra leaf stem. El espacio que ves es el espacio que estaba dentro del primer par. Un espacio escrito fuera de las comillas, entre los dos comandos, es solo un hueco en el archivo. No es una letra para la pantalla. Puedes partir los dos comandos en dos líneas del archivo, o poner una línea en blanco entre ellos, y la pantalla sigue siendo una línea. Los saltos de línea del archivo no son fines de línea en la pantalla. Solo el comando que termina la línea, WriteLine, termina una línea de pantalla. Write nunca lo hace, da igual cómo esté espaciado el archivo a su alrededor.

El error que quita las comillas

La palabra que muestra la pantalla tiene que sentarse entre comillas. El error es borrar las comillas y dejar la palabra desnuda: Console.WriteLine(leaf);. leaf sin comillas no es una palabra para la pantalla. C# la lee como un nombre, y este archivo todavía no tiene ese nombre. La página siguiente trata de nombres. Esta página se detiene en las comillas. Conserva esta cuarta forma solo lo bastante para ver que la compilación no se queda en silencio y luego vuelve a poner las comillas. Este no es el archivo que guardas.

Ejecuta dotnet run o compila el proyecto. Esta vez el compilador escribe un error. No se queda en silencio. El archivo no está bien, porque leaf no tiene comillas y aún no tiene significado en este archivo. No necesitas las palabras exactas de ese error. El hecho útil es que la compilación escribió una línea en absoluto. Cuando la compilación escribe un error, no hay pantalla nueva en la que confiar hasta que el archivo vuelva a estar bien. Vuelve a poner las comillas para que la línea sea otra vez Console.WriteLine("leaf");. Guarda. Ejecuta otra vez. Ahora la compilación se queda lo bastante en silencio para ejecutarse, y la pantalla muestra leaf. Las comillas fueron toda la reparación. No reinstalas el SDK y no quitas la línea de escritura. Una línea de escritura sin comillas no es una pantalla en blanco por una nota. Una nota habría dejado la compilación en silencio. Este error hace hablar al compilador. Mantén los hábitos de Java sobrantes con System.out.println mapeados aquí a Console.WriteLine, y System.out.print a Console.Write. Mantén inventar rutas ASP.NET fuera de esta página.

La pantalla es la palabra entre comillas

Ahora puedes cambiar la pantalla cambiando las letras entre las comillas. Console.WriteLine("leaf"); escribe leaf y termina la línea. Un segundo Console.WriteLine escribe la siguiente línea, en el orden en que escribiste los comandos en el archivo. Console.Write escribe sus letras y no termina la línea, así que un Write siguiente continúa en esa misma línea, y un espacio aparece solo cuando lo pones dentro de las comillas. Si la compilación escribe un error en una palabra desnuda, faltan las comillas. Vuelve el archivo al que guardas cuando termines de mirar leafstem. La línea de escritura en el archivo que guardas es Console.WriteLine("leaf"); y no hay segunda línea de escritura. La página siguiente da un nombre a una palabra, para que una línea de escritura pueda usar ese nombre en lugar de solo una palabra entre comillas.