Matrices

string[] plants = { "leaf", "mint" }; guarda dos palabras bajo un nombre, y Console.WriteLine(plants[0]) escribe leaf. La pantalla es una línea. mint no está en esa línea, y no hay segunda línea. Mantén el nombre público del tipo Pine.

Un nombre guarda dos palabras

Abre el archivo Pine. El nombre del tipo sigue siendo Pine. Esta página no renombra el tipo. Borra string plant = null si esa línea sigue ahí. Borra plant.Length. Borra int count si sigue, incluidos (int), 40.0, 40.9 y 40. Borra double weight si sigue. Borra bool ripe si sigue, incluidos true y false. Borra cualquier línea ReadLine. El archivo que conservas no tiene espera, ni count, ni weight, ni ripe, ni un plant solo que guarda null. La palabra solo la escribe la línea de escritura que elige una ranura.

Dentro de Main, la línea de guardado es string[] plants = { "leaf", "mint" };. string[] es la palabra de tipo. Los corchetes forman parte de ese tipo. Dicen que este nombre puede guardar más de una palabra. plants es el nombre y empieza con p minúscula. El = guarda. Las llaves guardan las palabras. Cada palabra va entre sus comillas. Una coma separa las palabras. leaf es la primera palabra. mint es la segunda. El punto y coma cierra la línea. Esta línea guarda dos palabras. No escribe en pantalla. Guardar no es escribir. La pantalla queda en blanco con esta línea. Las dos palabras no son el número 0 ni la palabra null. Nada espera fuera de pantalla bajo un segundo nombre. Ambas palabras están bajo plants.

Las palabras que escribes dentro de las llaves son las ranuras. Dos palabras entre comillas hacen dos ranuras. No inventas una tercera palabra en el archivo que conservas. string[] plants = { "leaf", "mint", "stem" }; guarda tres palabras. Ese archivo está permitido y no es el que conservas. string[] plants = { leaf, mint }; trata leaf y mint como nombres. Este archivo no tiene esos nombres. El build escribe un error. string[] plants = { "leaf" "mint" }; no tiene coma. El build escribe un error. La coma separa las dos palabras. string[] plants = { 40, 9 }; pide a este tipo que guarde enteros. Las palabras en tu archivo conservado son leaf y mint, no dígitos. El build escribe un error. La palabra de tipo con corchetes, en esta página, guarda palabras entre comillas.

La línea de escritura elige una ranura: Console.WriteLine(plants[0]);. Los corchetes después del nombre guardan un número. Ese número es 0. La ranura 0 es la primera palabra, porque el conteo de ranuras empieza en 0, no en 1. No hay comillas alrededor de 0. No hay punto ni Length. C# lee plants, lee el número 0, escribe la palabra de esa ranura y termina la línea. En el archivo que conservas, esa palabra es leaf. Las letras del nombre, p, l, a, n, t, s, no están en pantalla. string no está en pantalla. Las llaves no. La coma no. mint no. La palabra leaf sí, en una línea. Guarda el archivo.

El archivo que conservas

Conserva esta forma de enseñanza. Una palabra de tipo, string[]. Un nombre, plants. Dos palabras en llaves, leaf y luego mint, cada una entre comillas, con una coma entre ellas. Una línea de escritura, y esa línea elige la ranura 0. Sin Length, sin segunda línea de escritura.

Léelo de arriba abajo. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde arranca el runtime. La línea de guardado es string[] plants = { "leaf", "mint" };. No escribe nada. Console.WriteLine(plants[0]); escribe leaf y termina la línea. Una línea en pantalla. Sin segunda. En el archivo que conservas no hay línea int ni línea que guarde null.

Ejecútalo con dotnet run. El programa escribe leaf. No espera a que escribas. Las palabras ya estaban en el archivo antes de ejecutar. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y conserva string[] plants = { "leaf", "mint" }; y la única línea de escritura. El programa termina tras la línea de escritura. La pantalla muestra leaf. Una línea. Si la pantalla muestra mint, la línea de escritura eligió la ranura 1, o la primera palabra en las llaves es mint. Mira el archivo. El que conservas tiene leaf primero y plants[0] en la línea de escritura. Si la pantalla muestra plant, la línea de escritura tiene comillas alrededor de otro nombre. Si muestra las letras plants[0], la línea tiene comillas alrededor de esas letras: Console.WriteLine("plants[0]");. Esas comillas marcan letras, así que no se escribe la palabra guardada. Si muestra null, sigue el archivo null o las ranuras se crearon sin palabras en las llaves. El archivo que conservas tiene leaf y mint dentro de las llaves. Si muestra 40, 40.0 o 4, sigue el archivo de casting, de números o una pregunta con Length. Borra esa línea. Si muestra true o false, ripe sigue en el archivo. Si muestra una línea en blanco y no leaf, una línea de guardado tiene comillas vacías. Eso no es el archivo que conservas. No reinstalas el .NET SDK solo porque la pantalla muestre la línea equivocada.

Una pantalla con leaf no demuestra los corchetes por sí sola. string plant = "leaf"; también escribe leaf. La pantalla puede verse igual. El archivo no. El archivo que conservas tiene string[], llaves, coma y plants[0] en la línea de escritura. Cuando juzgues esta página, busca los corchetes en la palabra de tipo y el número 0. No juzgues el archivo solo por la pantalla.

La otra palabra está en 1

La segunda palabra está en el archivo y la línea de escritura conservada no la escribe. Para ver mint, el número entre corchetes es 1. La ranura 1 es la segunda palabra, porque la 0 fue la primera. Esta ejecución está permitida y no es el archivo que conservas.

Ejecuta dotnet run. La pantalla muestra mint. Una línea. leaf no está en esa línea. La línea de guardado no cambió. Solo cambió el número entre corchetes. 1 no significa «la primera palabra». La primera sigue siendo leaf, en la ranura 0. Después de ver mint, vuelve a plants[0]. El archivo que conservas escribe leaf.

Lee la tabla contra una ejecución, no en lugar de una. Para 0, el build no escribe error y dotnet run escribe leaf. Para 1, el build no escribe error y dotnet run escribe mint. Para 2, el build no escribe error y la ejecución escribe un error, porque esa ranura no estaba en las llaves. Para string plants = { "leaf", "mint" }; sin corchetes en la palabra de tipo, el build escribe un error, no ejecutas. Tras cada comprobación, vuelve al archivo conservado: string[], llaves, leaf luego mint, y plants[0]. La pantalla conservada es leaf, una línea.

El nombre tiene que existir antes de que una línea lo use. Si Console.WriteLine(plants[0]); está encima de la línea de guardado, 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. Una línea posterior puede reemplazar una palabra sin volver a escribir string[], cuando plants ya existe: plants[0] = "stem";. Esa línea solo reemplaza la palabra en la ranura 0. La ranura 1 sigue con mint. Está permitido. No es el archivo que conservas. El que conservas tiene una línea de guardado que dice leaf y luego mint.

string[] plants; sin llaves ni palabras, 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 palabras. Pon las llaves en la línea de creación, como en el archivo que conservas. string[] plants = { "leaf" }; guarda una palabra. plants[0] escribe leaf. plants[1] es una ranura que no escribiste, así que la ejecución escribe un error tras un build en silencio. Ese archivo de una palabra no es el conservado. Falta de espacio no pega el tipo en uno nuevo que falle: string[]plants sigue guardando las dos palabras y el build no escribe error. El archivo que conservas tiene espacio tras string[]. string [] plants con espacio antes de plants sigue guardando las dos palabras. plants[ 0 ] con espacios dentro de los corchetes sigue escribiendo leaf. El conservado no tiene espacio extra, pero ese espacio no es un segundo valor.

Las llaves no son paréntesis. string[] plants = ( "leaf", "mint" ); hace que el build escriba un error. Las palabras van dentro de { y }, no de ( y ). La línea de escritura no es una llamada con paréntesis alrededor del número. Console.WriteLine(plants(0)); hace que el build escriba un error. El número va dentro de [ y ]. El nombre sigue siendo plants con p minúscula. string[] Plants con P mayúscula es otro nombre. Puede guardar las palabras y no es el del archivo que conservas. Vuelve a poner la p minúscula.

Una coma tras la última palabra no añade ranura. string[] plants = { "leaf", "mint", }; sigue guardando dos palabras. El build no escribe error. plants[0] sigue escribiendo leaf y plants[1] sigue con mint. No hay tercera palabra. El archivo que conservas no tiene coma tras mint, pero esa coma extra no es un tercer valor. new no hace falta. string[] plants = new string[] { "leaf", "mint" }; también guarda las dos palabras y plants[0] sigue escribiendo leaf. El conservado no escribe new. string[] plants = new string[2]; crea dos ranuras sin palabras dentro. Entonces plants[0] escribe null. Esas ranuras no guardan letras. No es el archivo conservado. Las palabras leaf y mint tienen que estar dentro de las llaves.

Una ranura que no escribiste

Dos palabras hacen dos ranuras, numeradas 0 y 1. El número 2 es una tercera ranura. No escribiste una tercera palabra. El tercer archivo pregunta por esa ranura.

Este es el tercer 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. El número 2 no hace fallar el build. El programa no escribe leaf, ni mint, ni 2, ni null. La ejecución escribe un error. No necesitas las palabras exactas del error. Las llaves guardaron dos palabras, así que no hay tercera palabra que escribir. plants[-1] no sirve para elegir la última palabra. El build no escribe error y la ejecución sí. Los números que encajan con el archivo conservado son solo 0 y 1. Si la pantalla muestra mint, el número entre corchetes es 1 y la segunda palabra sigue ahí. Tras ver el error, vuelve al archivo conservado.

Un nombre sin ranuras es otro fallo, y la pantalla no es la palabra null. string[] plants = null; no guarda ranuras. El build no escribe error. Console.WriteLine(plants[0]); hace que la ejecución escriba un error después. No escribe null ni leaf. Los corchetes en la línea de escritura piden una ranura y este nombre no tiene. Ese archivo no es el conservado. El que conservas tiene llaves, y guardan leaf y mint.

Ya puedes guardar dos palabras bajo un nombre y escribir la primera. string[] plants = { "leaf", "mint" }; guarda leaf y mint. Console.WriteLine(plants[0]); escribe leaf y termina la línea. plants[1] escribe mint, y no es el archivo que conservas. plants[2] deja el build en silencio y hace que la ejecución escriba un error. Un nombre string sin corchetes no puede guardar las llaves. La página siguiente deja estos corchetes. Mira un signo escrito entre dos enteros.

La pantalla es la primera palabra

El archivo que conservas escribe leaf. El nombre en la línea de escritura es plants, y plants no está en pantalla. El número entre corchetes es 0. mint es la segunda palabra y sigue en el archivo mientras la pantalla muestra leaf. Un número de ranura que no escribiste no es el archivo conservado. Comillas alrededor de plants[0] escriben letras, no la palabra de la ranura.