Operadores lógicos

bool both = true && true; guarda la palabra true, y Console.WriteLine(both) escribe true. La pantalla es una línea. Los dos ampersands van entre las dos palabras true en el archivo, y no en esa línea. Mantén el nombre de la clase pública Pine.

Dos ampersands piden ambos lados true

Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Borra bool match si esa línea sigue ahí, incluyendo 4 == 4, 4 == 9 y toda marca de pregunta entre dos enteros. Borra int total si sigue. Borra string[] plants si sigue. Borra bool ripe si sigue con un true o false suelto y sin marca de combinación. Borra cualquier línea ReadLine. El archivo que guardas no espera, no tiene match, no tiene total, no tiene plants ni una línea ripe suelta. La palabra solo la escribe la línea de escritura que usa el nombre que guarda la respuesta combinada.

Dentro de Main, la línea de guardado es bool both = true && true;. bool es la palabra de tipo. Dice que este nombre guarda una de dos palabras, true o false. both es el nombre y empieza con b minúscula. El primer = guarda. A la derecha de ese primer = hay dos palabras true o false y una marca de combinación. La primera palabra es true, todas las letras minúsculas, sin comillas. La marca de combinación son dos ampersands juntos sin espacio: &&. La segunda palabra es true, todas las letras minúsculas, sin comillas. El punto y coma termina la línea. Esta línea guarda una palabra. No escribe la pantalla. Guardar no es escribir. La pantalla sigue en blanco con esta línea. La marca de combinación no pregunta si dos enteros coinciden. Tampoco hace un tercer entero. Mira dos respuestas que ya son true o false, y hace una respuesta a partir de ellas.

Dos ampersands significan que ambos lados deben ser true. Cuando el lado izquierdo es true y el derecho es true, la palabra combinada es true. Cuando cualquiera de los lados es false, la palabra combinada es false. bool both = true && false; guarda false. bool both = false && true; guarda false. bool both = false && false; guarda false. El archivo que guardas usa true && true, así que la palabra guardada es true.

Una marca de combinación no hace el mismo trabajo que una marca de pregunta. La página de comparación puso == entre dos enteros. Esa pregunta hizo true o false a partir de los números. Esta página pone && entre dos valores que ya son true o false. La página de operadores puso + entre dos enteros para hacer un tercero. && no hace un tercer entero. Si escribes bool both = 4 && 9;, el build escribe un error en la forma de lección de esta página, porque los lados que esta página guarda son true o false, no enteros sueltos. Mantén true y false en ambos lados para el archivo que guardas.

La línea de escritura es el nombre solo: Console.WriteLine(both);. Sin comillas, y sin marca de combinación en esa línea. C# lee el nombre both, escribe la palabra que ese nombre guarda y termina la línea. En el archivo que guardas esa palabra es true. Las letras del nombre, b, o, t, h, no están en pantalla. bool no está en pantalla. Los dos ampersands no están en pantalla. Las palabras true por separado no están en pantalla como dos líneas. La palabra true sí está en pantalla, en una línea. Guarda el archivo.

El archivo que guardas

Mantén esta forma de enseñanza. Una palabra de tipo, bool. Un nombre, both. Una línea de guardado que escribe true, luego dos ampersands, luego true, sin comillas alrededor de ninguna palabra. Una línea de escritura, y esa línea usa el nombre solo. No hay línea match, no hay línea total ni segunda línea de escritura.

Léelo desde arriba. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde arranca la ejecución. bool both = true && true; guarda la palabra true. No escribe nada. Console.WriteLine(both); escribe true y cierra la línea. Una línea en pantalla. Sin comillas. Sin segunda línea. En el archivo que guardas no hay línea bool match ni línea que pregunte si 4 coincide con 4.

Ejecútalo con dotnet run. El programa escribe true. No espera a que escribas. Las dos palabras true y la marca de combinación ya estaban en el archivo. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y deja bool both = true && true; y la única línea de escritura. El programa termina después de la línea de escritura. La pantalla muestra true. Una línea. Sin comillas. Si la pantalla muestra both, la línea de escritura tiene comillas alrededor del nombre: Console.WriteLine("both");. Esas comillas marcan letras, así que no se escribe la palabra guardada. Si la pantalla muestra true desde bool match = 4 == 4;, el archivo de comparación sigue ahí. Borra la línea match. Si la pantalla muestra false, un lado de && es false; esa prueba está permitida, y no es el archivo que guardas. Si la pantalla muestra las letras true && true, la línea de escritura tiene comillas alrededor de esos caracteres. No reinstales el .NET SDK por una línea mala en pantalla.

Una pantalla que muestra true no prueba sola la marca de combinación. bool both = true; también escribe true. La pantalla puede verse igual. El archivo no. El archivo que guardas tiene true, luego &&, luego true. Al juzgar esta página busca los dos ampersands entre las dos palabras true. No juzgues el archivo solo por la pantalla.

Los espacios alrededor de la marca de combinación están permitidos. bool both = true&&true; sin espacios sigue guardando true, y el build no escribe error. bool both = true && true; con espacios sigue guardando true. El archivo que guardas usa espacios alrededor de la marca, porque así se ve mejor. Los espacios no son un segundo valor. Un espacio entre los dos ampersands no está permitido. bool both = true & & true; hace que el build escriba un error. Mantén los dos ampersands juntos como &&. Un ampersand solo no es la marca que esta página guarda. bool both = true & true; no es el archivo que guardas. El build puede escribir un error, o la línea no es la lección que esta página enseña. Escribe dos ampersands.

Las comillas alrededor de true lo convierten en letras. bool both = "true" && true; pide a C# combinar letras con una palabra true o false de un modo que esta página no enseña. El build escribe un error. Quita las comillas. Ambos lados de &&, en esta página, son las palabras true o false sin comillas. Console.WriteLine(true && true); sin ningún nombre both también escribe true. La pantalla puede verse igual. El archivo que guardas guarda primero la respuesta combinada bajo un nombre y luego escribe ese nombre.

El nombre debe existir antes de que una línea lo use. Si Console.WriteLine(both); queda arriba de bool both = true && true;, el build escribe un error. Pon la línea de guardado encima de la de escritura. No escribas bool otra vez para el mismo nombre. Una línea posterior puede cambiar la palabra sin escribir bool otra vez, una vez que both ya existe: both = true && true;. Esa forma está permitida. No es obligatoria. El archivo que guardas crea el nombre y guarda la respuesta combinada en una línea.

Cuando un lado es false

Cambia solo la palabra derecha. Mantén la palabra de tipo bool. Mantén el nombre both. Mantén la marca como dos ampersands. bool both = true && false; tiene un lado izquierdo true y un lado derecho false. Dos ampersands piden ambos lados true. La palabra combinada es false. La línea de escritura sigue siendo Console.WriteLine(both);. La pantalla muestra false. Una línea. El nombre both no está en pantalla. Las palabras true y false por separado no están en pantalla como dos líneas.

Ejecuta dotnet run. La pantalla muestra false. Después de ver false, vuelve al archivo guardado: bool both = true && true; y un Console.WriteLine(both);. La pantalla guardada es true, una línea. Esta ejecución de false es una prueba. No es el archivo que guardas.

Dos pipes piden un lado true

Otra marca de combinación usa dos signos pipe juntos: ||. Dos pipes significan que al menos un lado debe ser true. bool either = true || false; guarda true. bool either = false || true; guarda true. bool either = true || true; guarda true. bool either = false || false; guarda false. El nombre puede ser either. La palabra de tipo sigue siendo bool.

Este es el segundo archivo. No es el que guardas. Ejecuta dotnet run. La pantalla muestra true. Una línea. No muestra false. No muestra las letras true || false. Si la pantalla muestra false, ambos lados pueden seguir siendo false, como en bool either = false || false;. Esa línea está permitida, y no es este segundo archivo. Después de ver true desde true || false, vuelve al archivo guardado: bool both = true && true; y Console.WriteLine(both);.

Dos ampersands y dos pipes no hacen el mismo trabajo. && es estricto. Ambos lados deben ser true. || es abierto. Un lado true basta. El archivo que guardas enseña &&. El segundo archivo solo muestra ||. No dejes || en el archivo guardado. No escribas un pipe solo. bool either = true | false; no es la marca que esta página guarda para la combinación abierta.

Un bang invierte la palabra

Una marca bang se coloca junto a una palabra true o false y la invierte. La marca es !. bool flipped = !true; guarda false. bool flipped = !false; guarda true. No hay segundo lado. El bang no es && y no es ||. No va entre dos palabras. Va junto a una palabra.

Este es el tercer archivo. No es el que guardas. Ejecuta dotnet run. La pantalla muestra false. Una línea. No muestra true. No muestra las letras !true. Si la pantalla muestra true, la línea de guardado puede ser bool flipped = !false;, que invierte false en true. Esa línea está permitida, y no es este tercer archivo. Después de ver false desde !true, vuelve al archivo guardado.

Escribir la marca de combinación como letras no combina. Console.WriteLine("true && true"); escribe los caracteres de ese texto. La pantalla muestra true && true. Eso no es la palabra true de la combinación guardada. El build queda en silencio. Las comillas son lo que impide que la marca funcione como marca. El archivo que guardas no tiene comillas alrededor de las palabras true, y la línea de escritura no tiene comillas alrededor del nombre.

Ya puedes guardar una respuesta true o false hecha de dos respuestas true o false, y escribir esa palabra. bool both = true && true; guarda true. Console.WriteLine(both); escribe true y termina la línea. true && false escribe false. true || false escribe true. !true escribe false. La siguiente página deja estas marcas de combinación solas. Mira if y else, que eligen un camino a partir de una respuesta true o false.

La pantalla es la palabra combinada

El archivo que guardas escribe true. El nombre en la línea de escritura es both, y both no está en pantalla. Los dos ampersands están en el archivo, y no en pantalla. Las dos palabras true están en el archivo, y no en pantalla como líneas separadas. La marca pipe y la marca bang no son el archivo que guardas. Las comillas alrededor de la marca escriben letras, no la palabra combinada.