Vetores

string[] plants = { "leaf", "mint" }; guarda duas palavras sob um nome, e Console.WriteLine(plants[0]) escreve leaf. A tela é uma linha. mint não está nessa linha, e não há segunda linha. Mantenha a classe pública chamada Pine.

Um nome guarda duas palavras

Abra o arquivo Pine. O nome da classe continua Pine. Esta página não renomeia o tipo. Apague string plant = null se essa linha ainda estiver lá. Apague plant.Length. Apague int count se essa linha ainda estiver lá, incluindo (int), 40.0, 40.9 e 40. Apague double weight se ainda estiver. Apague bool ripe se ainda estiver, incluindo true e false. Apague qualquer linha ReadLine. O arquivo que você guarda não tem espera, nem count, nem weight, nem ripe, nem um plant sozinho que guarda null. A palavra só é escrita pela linha de escrita que escolhe uma posição.

Dentro de Main, a linha de guardar é string[] plants = { "leaf", "mint" };. string[] é a palavra de tipo. Os colchetes fazem parte desse tipo. Eles dizem que este nome pode guardar mais de uma palavra. plants é o nome, e começa com p minúsculo. O sinal = guarda. As chaves guardam as palavras. Cada palavra está nas suas aspas. Uma vírgula fica entre as palavras. leaf é a primeira palavra. mint é a segunda. O ponto e vírgula termina a linha. Esta linha guarda duas palavras. Não escreve a tela. Guardar não é escrever. A tela fica em branco até o fim desta linha. Essas duas palavras não são o número 0, e não são a palavra null. Nada espera fora da tela sob um segundo nome. As duas palavras estão sob plants.

As palavras que você põe dentro das chaves são as posições. Duas palavras entre aspas fazem duas posições. Você não inventa uma terceira palavra no arquivo que guarda. string[] plants = { "leaf", "mint", "stem" }; guarda três palavras. Esse arquivo é permitido, e não é o arquivo que você guarda. string[] plants = { leaf, mint }; trata leaf e mint como nomes. Este arquivo não tem esses nomes. O build escreve um erro. string[] plants = { "leaf" "mint" }; não tem vírgula. O build escreve um erro. A vírgula separa as duas palavras. string[] plants = { 40, 9 }; pede a este tipo para guardar inteiros. As palavras do arquivo que você guarda são leaf e mint, não dígitos. O build escreve um erro. A palavra de tipo com colchetes, nesta página, guarda palavras entre aspas.

A linha de escrita escolhe uma posição: Console.WriteLine(plants[0]);. Os colchetes depois do nome guardam um número. Esse número é 0. A posição 0 é a primeira palavra, porque a contagem das posições começa em 0, não em 1. Não há aspas em volta de 0. Não há ponto, e não há Length. C# lê plants, lê o número 0, escreve a palavra dessa posição, e termina a linha. Para o arquivo que você guarda, essa palavra é leaf. As letras do nome, p, l, a, n, t, s, não estão na tela. string não está na tela. As chaves não estão na tela. A vírgula não está na tela. mint não está na tela. A palavra leaf está na tela, uma linha. Salve o arquivo.

O arquivo que você guarda

Mantenha esta forma de ensino. Uma palavra de tipo, string[]. Um nome, plants. Duas palavras nas chaves, leaf depois mint, cada uma entre aspas, com uma vírgula entre elas. Uma linha de escrita, e essa linha escolhe a posição 0. Sem Length, e sem segunda linha de escrita.

Leia de cima. using System; prepara nomes curtos. public class Pine nomeia o tipo. public static void Main() é onde o runtime começa. A linha de guardar é string[] plants = { "leaf", "mint" };. Não escreve nada. Console.WriteLine(plants[0]); escreve leaf e termina a linha. Uma linha na tela. Sem segunda linha. Não há linha int no arquivo que você guarda, e não há linha que guarda null.

Execute com dotnet run. O programa escreve leaf. Não espera você digitar. As palavras estavam no arquivo antes da execução. Se dotnet run espera, ReadLine ainda está no arquivo. Apague essa linha e mantenha string[] plants = { "leaf", "mint" }; e a única linha de escrita. O programa termina depois da linha de escrita. A tela mostra leaf. Uma linha. Se a tela mostra mint, a linha de escrita pegou a posição 1, ou a primeira palavra nas chaves é mint. Olhe o arquivo. O arquivo que você guarda tem leaf primeiro e plants[0] na linha de escrita. Se a tela mostra plant, a linha de escrita tem aspas em volta de outro nome. Se a tela mostra as letras plants[0], a linha de escrita tem aspas em volta dessas letras: Console.WriteLine("plants[0]");. Essas aspas marcam letras, então a palavra guardada não é escrita. Se a tela mostra null, o arquivo null ainda está no lugar, ou as posições foram criadas sem palavras nas chaves. O arquivo que você guarda tem leaf e mint nas chaves. Se a tela mostra 40, ou 40.0, ou 4, o arquivo de casting, o de números, ou uma pergunta Length ainda está no lugar. Apague essa linha. Se a tela mostra true ou false, ripe ainda está no arquivo. Se a tela mostra uma linha em branco e não a palavra leaf, uma linha de guardar ainda tem aspas vazias. Esse não é o arquivo que você guarda. Você não reinstala o .NET SDK por uma tela com a linha errada.

Uma tela que mostra leaf não prova, sozinha, os colchetes. string plant = "leaf"; também escreve leaf. A tela pode parecer igual. O arquivo não. O arquivo que você guarda tem string[], chaves, vírgula, e a linha de escrita tem plants[0]. Quando julgar esta página, procure colchetes na palavra de tipo e procure o número 0. Não julgue o arquivo só pela tela.

A outra palavra fica na posição 1

A segunda palavra está no arquivo, e a linha de escrita guardada não a escreve. Para ver mint, o número entre colchetes é 1. A posição 1 é a segunda palavra, porque a posição 0 foi a primeira. Esta execução é permitida, e não é o arquivo que você guarda.

Execute dotnet run. A tela mostra mint. Uma linha. leaf não está nessa linha. A linha de guardar não mudou. Só o número entre colchetes mudou. 1 não significa « a primeira palavra ». A primeira palavra ainda é leaf, na posição 0. Depois de ver mint, volte plants[0]. O arquivo que você guarda escreve leaf.

Leia a tabela diante de uma execução, não no lugar de uma. Para 0, o build não escreve erro e dotnet run escreve leaf. Para 1, o build não escreve erro e dotnet run escreve mint. Para 2, o build não escreve erro e a execução escreve erro, porque essa posição não estava nas chaves. Para string plants = { "leaf", "mint" }; sem colchetes na palavra de tipo, o build escreve erro, então você não executa. Depois de cada verificação, volte o arquivo guardado: string[], chaves, leaf depois mint, e plants[0]. A tela guardada é leaf, uma linha.

O nome tem de existir antes de uma linha usá-lo. Se Console.WriteLine(plants[0]); fica acima da linha de guardar, o build escreve erro. Coloque a linha de guardar acima da linha de escrita. Não escreva string[] uma segunda vez para o mesmo nome. Uma linha depois pode trocar uma palavra sem escrever string[] de novo, quando plants já existe: plants[0] = "stem";. Essa linha só troca a palavra na posição 0. A posição 1 ainda guarda mint. É permitido. Não é o arquivo que você guarda. O arquivo que você guarda tem uma linha de guardar, e essa linha diz leaf depois mint.

string[] plants; sem chaves e sem palavras, seguido da linha de escrita, faz o build escrever erro. O nome existiria como tipo, sem palavras ainda. Ponha as chaves na linha de criar, como no arquivo que você guarda. string[] plants = { "leaf" }; guarda uma palavra. plants[0] escreve leaf. plants[1] é uma posição que você não escreveu, então a execução escreve erro depois de um build quieto. Esse arquivo de uma palavra não é o que você guarda. Falta de espaço não cola o tipo num tipo que falha: string[]plants ainda guarda as duas palavras, e o build não escreve erro. O arquivo que você guarda tem espaço depois de string[]. string [] plants com espaço antes de plants ainda guarda as duas palavras. plants[ 0 ] com espaços dentro dos colchetes ainda escreve leaf. O arquivo que você guarda não tem espaço extra, mas esse espaço não é um segundo valor.

As chaves não são parênteses. string[] plants = ( "leaf", "mint" ); faz o build escrever erro. As palavras ficam nas chaves, { e }, não em ( e ). A linha de escrita não é uma chamada com parênteses em volta do número. Console.WriteLine(plants(0)); faz o build escrever erro. O número fica entre colchetes, [ e ]. O nome continua plants, com p minúsculo. string[] Plants com P maiúsculo é outro nome. Pode guardar as palavras, e não é o nome do arquivo que você guarda. Volte o p minúsculo.

Vírgula depois da última palavra não adiciona posição. string[] plants = { "leaf", "mint", }; ainda guarda duas palavras. O build não escreve erro. plants[0] ainda escreve leaf, e plants[1] ainda escreve mint. Não há terceira palavra. O arquivo que você guarda não tem vírgula depois de mint, mas essa vírgula extra não é um terceiro valor. new não é obrigatório. string[] plants = new string[] { "leaf", "mint" }; também guarda as duas palavras, e plants[0] ainda escreve leaf. O arquivo que você guarda não escreve new. string[] plants = new string[2]; cria duas posições sem palavras nelas. Então plants[0] escreve null. Essas posições não guardam letras. Não é o arquivo que você guarda. As palavras leaf e mint têm de ficar dentro das chaves.

Uma posição que você não escreveu

Duas palavras fazem duas posições, numeradas 0 e 1. O número 2 é uma terceira posição. Você não escreveu uma terceira palavra. O terceiro arquivo pede essa posição.

Este é o terceiro arquivo. Não é o que você guarda. Execute dotnet run. O build pode ficar quieto, porque estas linhas podem estar no arquivo. O número 2 não faz o build falhar. O programa não escreve leaf, nem mint, nem 2, nem null. A execução escreve erro. Você não precisa das palavras exatas desse erro. As chaves guardavam duas palavras, então não há terceira palavra para escrever. plants[-1] não é jeito de pegar a última palavra. O build não escreve erro, e a execução escreve erro. Os números que combinam com o arquivo que você guarda são só 0 e 1. Se a tela mostra mint, o número entre colchetes é 1, e a segunda palavra ainda está lá. Depois de ver o erro, volte o arquivo guardado.

Um nome que não guarda posições é outra falha, e a tela não é a palavra null. string[] plants = null; não guarda posições. O build não escreve erro. Console.WriteLine(plants[0]); então faz a execução escrever erro. Não escreve null, e não escreve leaf. Os colchetes na linha de escrita pedem uma posição, e este nome não tem. Esse arquivo não é o que você guarda. O arquivo que você guarda tem chaves, e as chaves guardam leaf e mint.

Agora você pode guardar duas palavras sob um nome e escrever a primeira. string[] plants = { "leaf", "mint" }; guarda leaf e mint. Console.WriteLine(plants[0]); escreve leaf e termina a linha. plants[1] escreve mint, e não é o arquivo que você guarda. plants[2] deixa o build quieto e faz a execução escrever erro. Um nome string sem colchetes não pode guardar chaves. A próxima página deixa estes colchetes. Ela olha um sinal escrito entre dois inteiros.

A tela é a primeira palavra

O arquivo que você guarda escreve leaf. O nome na linha de escrita é plants, e plants não está na tela. O número entre colchetes é 0. mint é a segunda palavra, e fica no arquivo enquanto a tela mostra leaf. Um número de posição que você não escreveu não é o arquivo que você guarda. Aspas em volta de plants[0] escrevem letras, não a palavra na posição.