El valor null

string plant = null; no guarda letras, y Console.WriteLine(plant) escribe null. La pantalla es una línea. No hay comillas alrededor de null, y no hay dígito en esa línea. Mantén el nombre de la clase pública Pine.

El nombre no guarda letras

Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Borra int count si esa línea sigue ahí, incluido (int), 40.0, 40.9 y 40. Borra double weight si sigue ahí. Borra bool ripe si sigue ahí, incluido true y false. Borra plant.Length y toda línea que pregunte algo después de un punto. Borra cualquier línea ReadLine. El archivo que conservas no tiene espera, ni count, ni weight, ni ripe, ni paréntesis. La palabra solo la escribe la línea de escritura que usa el nombre.

Dentro de Main, la línea de guardado es string plant = null;. string es la palabra de tipo. Dice que este nombre puede guardar letras, o puede no guardar ninguna. plant es el nombre y empieza con p minúscula. El = guarda. La palabra es null, todas minúsculas: n, u, l, l. No hay N mayúscula. No hay comillas alrededor de null. No hay dígito. El punto y coma cierra la línea. Esta línea no guarda letras. No escribe la pantalla. Guardar no es escribir. La pantalla sigue en blanco con esta línea. null no es un atajo para escribir el número 0. null no es la palabra leaf solo porque las letras no salgan en pantalla. No hay nada guardado. Las letras de leaf no esperan dentro de este nombre.

En esta página, este tipo guarda letras entre comillas, como leaf, o la palabra null sin comillas. No inventes una tercera palabra. string plant = none; trata none como nombre. Este archivo no tiene un nombre none. El build escribe un error. string plant = empty; hace lo mismo. La palabra que puedes escribir con este tipo y sin comillas es null. El archivo que conservas usa null.

La línea de escritura es el nombre desnudo: Console.WriteLine(plant);. Sin comillas, sin punto. C# lee el nombre plant, escribe lo que ese nombre guarda y termina la línea. En el archivo que conservas, el nombre no guarda letras, así que la línea de escritura escribe la palabra null. Las letras del nombre, p, l, a, n, t, no están en pantalla. string no está en pantalla. Console no está en pantalla. La palabra null sí está en pantalla, en una línea. Guarda el archivo.

El archivo que conservas

Conserva esta forma de enseñanza. Una palabra de tipo, string. Un nombre, plant. Una palabra, null, todo minúsculas, sin comillas, sin dígito. Una línea de escritura, y usa el nombre desnudo. No hay Length.

Léelo desde arriba. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde arranca el runtime. La palabra string en la línea de guardado posterior es la que importa aquí. string plant = null; no guarda letras. No escribe nada. Console.WriteLine(plant); escribe null y termina la línea. Una línea en pantalla. Sin comillas. Sin segunda línea. En el archivo que conservas no hay línea int.

Ejecútalo con dotnet run. El programa escribe null. No espera a que escribas. La palabra ya estaba en el archivo. Si dotnet run espera, aún hay ReadLine en el archivo. Borra esa línea y conserva string plant = null; y la única línea de escritura. El programa termina tras la línea de escritura. La pantalla muestra null. Una línea. Sin comillas. Si la pantalla muestra plant, la línea de escritura tiene comillas alrededor del nombre: Console.WriteLine("plant");. Esas comillas marcan las letras p, l, a, n, t, así que no se escribe lo guardado. Si la pantalla muestra leaf, la línea de guardado aún dice "leaf". Borra comillas y letras y escribe null sin comillas. Si la pantalla muestra 40, 40.0 o 4, el archivo de conversión o de números sigue ahí. Borra la línea int y los paréntesis. Si la pantalla muestra true o false, ripe sigue en el archivo. Si la pantalla muestra una línea en blanco y no la palabra null, la línea de guardado tiene comillas vacías: string plant = "";. Eso no es el archivo que conservas. El archivo que conservas tiene la palabra null sin comillas. No reinstalas el .NET SDK porque la pantalla muestre la línea equivocada.

Una pantalla con null no prueba el archivo por sí sola. string plant = "null"; con comillas alrededor de esas cuatro letras también escribe null, porque las comillas guardan n, u, l, l. La pantalla puede verse igual. El archivo no. El archivo que conservas tiene string y null sin comillas. Cuando juzgues esta página, busca la palabra de tipo y la ausencia de comillas. No juzgues el archivo solo por la pantalla.

Las comillas guardan las letras null

Comillas alrededor de la palabra son letras, no el nombre vacío. string plant = "null"; guarda cuatro letras. El build no escribe error. dotnet run escribe null. Esa ejecución está permitida y no es el archivo que conservas. El archivo que conservas no tiene comillas, así que el nombre no guarda letras. Al reparar el archivo conservado, quita las comillas hasta que la línea vuelva a ser string plant = null;. No borres la palabra null con ellas.

Lee la tabla junto a una ejecución, no en lugar de una. Para string plant = null;, el build no escribe error y dotnet run escribe null. Para string plant = "null";, el build no escribe error y dotnet run escribe null, y el archivo sigue teniendo comillas. Para string plant = "leaf";, el build no escribe error y dotnet run escribe leaf. Para int count = null;, el build escribe un error, así que no ejecutas. Tras cada comprobación, vuelve a poner string plant = null; sin comillas. La pantalla del archivo conservado es null, una línea.

El nombre debe existir antes de que una línea lo use. Si Console.WriteLine(plant); queda encima de string plant = null;, el build escribe un error. Pon la línea de guardado encima de la de escritura. No escribas string una segunda vez para el mismo nombre. string plant = "leaf"; debajo de una línea que ya creó plant es otro error. El build escribe un error y no se queda en silencio. El nombre se crea una vez. Una línea posterior puede poner letras sin volver a escribir string, cuando plant ya existe: plant = "leaf";. Esa línea solo sustituye lo que guarda el nombre. Está permitido. No es el archivo que conservas. El archivo que conservas tiene una línea de guardado que dice null.

string plant; sin = null, seguido de la línea de escritura, hace que el build escriba un error. El nombre existiría como tipo y aún no guardaría palabra, ni siquiera null. Pon = null en la línea de creación, como en el archivo que conservas. string plant = nullnull; trata nullnull como un nombre. Este archivo no tiene ese nombre. El build escribe un error. La palabra es null; sin espacio no se pega en una tercera palabra que funcione. string plant = null ; con espacio antes del punto y coma sigue siendo null. El build no escribe error y la pantalla sigue siendo null. El archivo que conservas no tiene espacio extra, pero ese espacio no es un segundo valor.

Una mayúscula no es la palabra. string plant = Null; trata Null como nombre, porque la primera letra es N mayúscula. Este archivo no tiene un nombre Null. El build escribe un error. No se queda en silencio. La pantalla no muestra Null, porque no ejecutas mientras el build escribe error. La palabra en el archivo que conservas es null, todo minúsculas. Vuelve a poner las minúsculas.

null no es un entero

Entero es el tipo de la página de números. int count = null; pide a ese tipo que guarde sin letras. null no encaja. El build escribe un error. No convierte null en 0. No escribe null. bool ripe = null; pide al tipo de dos palabras que guarde null. Ese tipo solo guarda true o false. El build escribe un error. No convierte null en false. No hay pantalla que leer, porque no ejecutas mientras el build escribe error. No necesitas el texto exacto de esos errores. Al reparar el archivo conservado, borra las líneas int y bool y escribe de nuevo string plant = null;.

Una pregunta después del nombre es otro fallo, no un fallo de build. El segundo archivo guarda null y luego pregunta cuántas letras guarda ese nombre.

Este es el segundo archivo. No es el que conservas. Ejecuta dotnet run. El build puede quedarse en silencio, porque las líneas están permitidas en el archivo. La palabra null no hace fallar el build, y Length tampoco. El programa no escribe un número. No escribe 4, ni 0, ni null. La ejecución escribe un error. No necesitas el texto exacto. El nombre no guarda letras, así que no hay conteo que escribir. Si la pantalla muestra 4, plant aún guarda leaf, y Length cuenta esas cuatro letras. Borra "leaf" y conserva null, o, para el archivo conservado, borra Length por completo. La línea de escritura del archivo que conservas es Console.WriteLine(plant); sin punto ni Length. Tras ver el error, restaura el archivo conservado.

Ya puedes guardar ninguna letra en un nombre y escribir la palabra null sin comillas y sin dígito. string plant = null; no guarda letras. Console.WriteLine(plant); escribe null y termina la línea. Comillas alrededor de null guardan cuatro letras, y la pantalla puede verse igual, así que juzgas el archivo. int count = null; y bool ripe = null; hacen que el build escriba un error cada uno. Null con N mayúscula es un nombre que este archivo no tiene. plant.Length tras null deja el build en silencio y hace que la ejecución escriba un error. La página siguiente deja este nombre vacío y mira más de un valor bajo un solo nombre — los arrays.

La pantalla es la palabra null

El archivo que conservas escribe null. El nombre en la línea de escritura es plant, y plant no está en pantalla. En ese archivo no hay comillas. Un WriteLine es una línea. La misma pantalla por comillas son cuatro letras, no el archivo conservado. Un dígito no pertenece al archivo que conservas. Una pregunta después del nombre no es el archivo que conservas.