Saída

Mude a palavra entre as aspas e a tela muda com ela. O tipo de ensino ainda é Pine, e a chamada de escrita ainda é Console.WriteLine. Da última vez as aspas tinham pine, então a tela era pine. Coloque outra palavra entre essas aspas, adicione uma segunda linha de escrita, e depois veja o que a tela faz quando uma linha de escrita não termina a linha. Você não está instalando o SDK de novo. As notas da página anterior ficam fora desta demo, a menos que você as coloque de volta.

A palavra entre as aspas

Abra o arquivo Pine e encontre Console.WriteLine("pine");. A tela mostra a palavra entre as aspas. As aspas em si não são letras para a tela. Elas marcam onde essa palavra começa e onde termina. Mude a palavra. Deixe o resto da linha como está: Console.WriteLine fica, a aspa de abertura fica, a aspa de fechamento fica, e o ponto e vírgula fica. Só as letras entre as aspas mudam. Onde o arquivo tinha pine, escreva leaf, tudo em letras minúsculas. A linha agora é Console.WriteLine("leaf");. Salve o arquivo. O nome da classe ainda é Pine, porque a linha public class Pine ainda nomeia o tipo. Esta página não renomeia o tipo.

O arquivo que você guarda

Guarde esta forma de ensino. Ela tem uma linha de escrita, e essa linha segura leaf entre as aspas. Não há nota neste arquivo. Ainda não há segunda linha de escrita.

Leia de cima e decida o que a tela pode receber. A linha using System; prepara nomes curtos e não escreve a tela. A linha da classe é public class Pine. Essa linha nomeia o tipo. Não escreve a tela. A linha seguinte é public static void Main(). É onde o runtime começa. Nenhuma dessas palavras é letra para a tela. Dentro de Main há um comando: Console.WriteLine("leaf");. Console.WriteLine é o comando de escrita. As aspas seguram leaf. O ponto e vírgula termina o comando. O runtime roda esse comando porque ele fica dentro de Main e não está atrás de //. A tela recebe leaf. Não recebe as aspas, o ponto e vírgula, a palavra Console, nem a palavra Main.

Rode com dotnet run na pasta do projeto. A tela mostra leaf. Uma linha. Sem aspas. Sem ponto e vírgula. A palavra pine não está na tela, porque pine não está mais entre as aspas. Se a tela ainda mostra pine, as aspas ainda contêm pine. Olhe as letras entre as aspas antes de rodar de novo. Você não reinstala o .NET SDK por uma tela que ainda diz pine.

A tela copia as letras entre as aspas, e copia como estão. Console.WriteLine("Leaf"); escreve Leaf, com L maiúsculo. Console.WriteLine("leaf"); escreve leaf, com l minúsculo. O arquivo que você guarda usa o l pequeno, então a tela dele é leaf e não Leaf. Um espaço também é uma letra que a tela pode mostrar, se você digitar o espaço dentro das aspas. Console.WriteLine("leaf stem"); escreve uma linha, leaf stem, com o espaço que você pôs entre as duas palavras. As aspas ainda não aparecem. Esta é uma linha de escrita, então é uma linha de tela, mesmo com duas palavras dentro. Um par de aspas vazio é diferente. Console.WriteLine(""); escreve uma linha sem letras, e depois termina essa linha. A tela parece em branco. O comando rodou. As aspas simplesmente não seguravam nada. Essa linha em branco não é o arquivo que você guarda. O arquivo que você guarda segura leaf.

Uma segunda linha

Uma linha de escrita dá uma linha de tela. Uma segunda linha de tela precisa de uma segunda linha de escrita. Sob Console.WriteLine("leaf"); adicione Console.WriteLine("stem");. Cada comando tem suas próprias aspas e seu próprio ponto e vírgula. leaf fica no primeiro par de aspas. stem, tudo em minúsculas, vai no segundo par. O runtime roda o primeiro comando, termina essa linha, depois roda o segundo e termina essa linha também. A ordem da tela é a ordem do arquivo. O comando que você escreveu primeiro é a linha que a tela mostra primeiro.

Este é o segundo arquivo. Você está olhando duas linhas de tela. O arquivo que você guardava tinha uma linha de escrita e a tela era leaf. Este tem duas linhas de escrita. Use-o quando quiser ver esta tela, depois coloque de volta a linha de escrita única se quiser o arquivo que esta página guarda.

Rode dotnet run. A tela mostra leaf, e a próxima linha da tela é stem. Duas linhas. leaf está em cima porque Console.WriteLine("leaf"); é o primeiro comando de escrita. stem está embaixo porque Console.WriteLine("stem"); é o segundo. As aspas não estão em nenhuma das linhas. Se stem está em cima e leaf embaixo, as duas linhas de escrita no arquivo estão nessa ordem trocada. A tela não escolhe uma ordem própria. Coloque o comando stem de volta sob o comando leaf, salve e rode de novo. Você não precisa de um tipo novo de comando para a segunda linha. Precisa de um segundo Console.WriteLine, com a própria palavra entre as próprias aspas.

Write não termina a linha

Olhe o fim do comando de escrita que você vinha usando. WriteLine termina com as letras Line. Essas letras são o fim de linha. O comando escreve as letras entre as aspas, e depois termina a linha, então o próximo comando de escrita começa numa linha nova. Write é o mesmo auxiliar de escrita sem essas letras. Console.Write("leaf"); escreve leaf e não termina a linha. O próximo Console.Write começa onde essa palavra parou. Nada no comando insere um espaço por você. Se o primeiro par segura leaf e o segundo segura stem, e nenhum par segura um espaço, a tela mostra leafstem como uma linha só.

Este é o terceiro arquivo. Não é o arquivo que você guarda. Use-o tempo suficiente para ver a linha única leafstem. Os dois comandos são Write, não WriteLine. Não há espaço dentro de nenhum dos pares de aspas.

Rode dotnet run. A tela mostra leafstem. Uma linha. Sem espaço entre leaf e stem. Sem aspas. leaf ainda é o primeiro, porque Console.Write("leaf"); é o primeiro comando, e stem cola depois dele, porque Console.Write("stem"); não começa uma linha nova. Se você vê leaf e depois stem numa segunda linha, os comandos no arquivo são WriteLine, não Write. As letras Line ainda estão no comando, então cada comando terminou a própria linha. Tire Line dos dois comandos se a tela que você quer é a palavra única leafstem.

O programa escreve leafstem e termina sem terminar a linha. O terminal pode desenhar o próprio prompt nessa mesma linha, depois de leafstem. O prompt pertence ao terminal. Não é uma palavra do arquivo Pine, e não faz parte da linha que você está conferindo. Confira as letras entre as aspas: leafstem. Não tente combinar o prompt. Windows e macOS desenham prompts diferentes, e esta página não ensina esses prompts. A linha do programa é a mesma nos dois: leafstem, sem fim de linha depois dela.

Um espaço tem de estar dentro das aspas

Se você quer um espaço nessa mesma linha, o espaço tem de ser uma das letras entre as aspas. O comando de escrita não inventa isso. Mude o primeiro comando para Console.Write("leaf "); com um espaço depois do f, ainda dentro das aspas. Deixe o segundo comando como Console.Write("stem");. O C# escreve leaf, depois escreve o espaço que você pôs depois do f, depois escreve stem, e ainda não termina a linha. A tela mostra leaf stem. O espaço que você vê é o espaço que estava dentro do primeiro par de aspas. Um espaço digitado fora das aspas, entre os dois comandos, é só um vão no arquivo. Não é letra para a tela. Você pode quebrar os dois comandos em duas linhas no arquivo, ou pôr uma linha em branco entre eles, e a tela ainda é uma linha. Quebras de linha no arquivo não são fins de linha na tela. Só o comando que termina linha, WriteLine, termina uma linha de tela. Write nunca termina, não importa como o arquivo esteja espaçado ao redor.

O erro que tira as aspas

A palavra que a tela mostra tem de ficar entre aspas. O erro é apagar as aspas e deixar a palavra nua: Console.WriteLine(leaf);. leaf sem aspas não é uma palavra para a tela. O C# lê isso como um nome, e este arquivo ainda não tem esse nome. A próxima página é sobre nomes. Esta página para nas aspas. Guarde esta quarta forma só o bastante para ver que a build não fica quieta, depois coloque as aspas de volta. Este não é o arquivo que você guarda.

Rode dotnet run ou construa o projeto. Desta vez o compilador escreve um erro. Não fica quieto. O arquivo não está bem, porque leaf não tem aspas e ainda não tem sentido neste arquivo. Você não precisa das palavras exatas desse erro. O fato útil é que a build escreveu uma linha de todo. Quando a build escreve um erro, não há tela nova em que confiar até o arquivo estar bem de novo. Coloque as aspas de volta, para que a linha seja Console.WriteLine("leaf"); outra vez. Salve. Rode de novo. Agora a build fica quieta o bastante para rodar, e a tela mostra leaf. As aspas foram o reparo inteiro. Você não reinstala o SDK, e não remove a linha de escrita. Uma linha de escrita sem aspas não é uma tela em branco de uma nota. Uma nota teria deixado a build quieta. Este erro faz o compilador falar. Mantenha hábitos restantes de Java com System.out.println mapeados aqui para Console.WriteLine, e System.out.print para Console.Write. Mantenha inventar rotas ASP.NET fora desta página.

A tela é a palavra entre aspas

Você agora pode mudar a tela mudando as letras entre as aspas. Console.WriteLine("leaf"); escreve leaf e termina a linha. Um segundo Console.WriteLine escreve a próxima linha, na ordem em que você escreveu os comandos no arquivo. Console.Write escreve as letras dele e não termina a linha, então um Write seguinte continua nessa mesma linha, e um espaço só aparece quando você o põe dentro das aspas. Se a build escreve um erro numa palavra nua, faltam as aspas. Volte o arquivo ao que você guarda quando terminar de olhar leafstem. A linha de escrita no arquivo que você guarda é Console.WriteLine("leaf"); e não há segunda linha de escrita. A próxima página dá um nome a uma palavra, para que uma linha de escrita possa usar esse nome em vez de só uma palavra entre aspas.