Exercício – Imprimir valores literais

10 minutos

Neste exercício, você imprimirá mensagens contendo outros tipos de dados e aprenderá por que os tipos de dados são tão importantes no C#.

O que é um valor literal?

Um valor literal é um valor constante que nunca é alterado. Anteriormente, você exibia uma cadeia de caracteres literal no console de saída. Em outras palavras, você literalmente queria que a sequência de caracteres alfanuméricos H, e, l, l, o e assim por diante fosse exibida no console de saída.

Use o tipo de dados de cadeia de caracteres sempre que você tiver palavras alfanuméricas, frases ou dados para apresentação, não cálculo. Que outros tipos de dados literais você pode imprimir na saída?

Exercício – Imprimir diferentes tipos de dados literais

Há muitos tipos de dados em C#. Mas, à medida que você está começando, você só precisa saber sobre cinco ou seis tipos de dados, já que eles abrangem a maioria dos cenários. Vamos exibir uma instância literal do tipo de dados na saída.

Observação

Você pode observar quando começa a trabalhar na janela de código que ele colore determinada sintaxe em cores diferentes para indicar palavras-chave, operadores, tipos de dados e muito mais. Comece a tomar conhecimento das cores. Ele pode ajudá-lo a detectar erros de sintaxe à medida que você insere caracteres e pode ajudá-lo a entender o código com mais eficiência.

Usar literais de caracteres

Se você quiser apenas um caractere alfanumérico impresso na tela, poderá criar um char literal usando um caractere alfanumérico entre aspas simples. O termo char é uma abreviação de caractere. Em C#, esse tipo de dados é oficialmente chamado de "char", mas frequentemente chamado de "caractere".

Adicione a seguinte linha de código no editor de código:
```
Console.WriteLine('b');
```
Observe o código que você inseriu.

Observe que a letra b está entre aspas 'b' simples. As aspas simples criam um caractere literal. Lembre-se de que usar aspas duplas cria um string tipo de dados.
Pressione o botão Executar verde para executar seu código. Você deverá ver o seguinte resultado na janela de saída:
```
b
```

Se você inserir o seguinte código:

Console.WriteLine('Hello World!');

Você obteria o seguinte erro:

(1,19): error CS1012: Too many characters in character literal

Note as aspas simples ao redor de Hello World!. Quando você usa aspas simples, o compilador C# espera um único caractere. No entanto, nesse caso, a sintaxe de caractere literal foi usada, mas foram fornecidos 12 caracteres!

Assim como o string tipo de dados, você usa char sempre que tem um único caractere alfanumérico para apresentação (não cálculo).

Usar literais de inteiros

Se você quiser exibir um valor numérico inteiro (sem frações) no console de saída, poderá usar um literal int. O termo int é uma abreviação de "inteiro", que você pode reconhecer ao estudar matemática. Em C#, esse tipo de dados é oficialmente chamado de "int", mas frequentemente chamado de "inteiro". Um int literal não requer outros operadores como o string ou char.

Adicione a seguinte linha de código no editor de código:
```
Console.WriteLine(123);
```
Pressione o botão Executar verde para executar seu código. Você deverá ver o seguinte resultado no console de saída:
```
123
```

Usar literais de ponto flutuante

Um número de ponto flutuante é um número que contém uma decimal, por exemplo, 3.14159. O C# dá suporte a três tipos de dados para representar números decimais: float, doublee decimal. Cada tipo dá suporte a diferentes graus de precisão.

Float Type    Precision
----------------------------
float         ~6-9 digits
double        ~15-17 digits
decimal        28-29 digits

Aqui, a precisão reflete o número de dígitos além do decimal que são precisos.

Adicione a seguinte linha de código no editor de código:
```
Console.WriteLine(0.25F);
```
Para criar um float literal, acrescente a letra F após o número. Nesse contexto, o F é denominado sufixo literal. O sufixo literal informa ao compilador que você deseja trabalhar com um valor do tipo float. Você pode usar um f minúsculo ou um F maiúsculo como sufixo literal para um float.
Pressione o botão Executar verde para executar seu código. Você deverá ver o seguinte resultado no console de saída:
```
0.25
```
Observe que o float tipo de dados é o menos preciso, portanto, é melhor usar esse tipo de dados para valores fracionários fixos para evitar erros de computação inesperados.
Adicione a seguinte linha de código no editor de código:
```
Console.WriteLine(2.625);
```
Para criar um double literal, basta inserir um número decimal. O compilador usa como padrão um double literal quando um número decimal é inserido sem um sufixo literal.
Pressione o botão Executar verde para executar seu código. Você deverá ver o seguinte resultado na janela de saída:
```
2.625
```
Adicione a seguinte linha de código no editor de código:
```
Console.WriteLine(12.39816m);
```
Para criar um literal decimal, acrescente a letra m após o número. Nesse contexto, o m é chamado sufixo literal. O sufixo literal indica ao compilador que você deseja trabalhar com um valor do tipo decimal. Você pode usar tanto a letra minúscula m quanto a letra maiúscula M como sufixo literal para um decimal.
Pressione o botão Executar verde para executar seu código. Você deverá ver o seguinte resultado no console de saída:
```
12.39816
```

Usar literais de boolianos

Se você quisesse imprimir um valor que representasse true ou false, você poderia usar um literal booleano.

O termo bool é curto para Boolean. No C#, eles são oficialmente chamados de "bool", mas geralmente os desenvolvedores usam o termo "Boolean".

Adicione as seguintes linhas de código no editor de código:
```
Console.WriteLine(true);
Console.WriteLine(false);
```
Pressione o botão Executar verde para executar seu código. Você deverá ver o seguinte resultado no console de saída:
```
True
False
```

Os bool literais representam a ideia de verdade e falsidade. Você usará bool valores extensivamente quando começar a adicionar lógica de decisão aos seus aplicativos. Você avaliará as expressões para ver se a expressão é verdadeira ou falsa.

Por que enfatizar tipos de dados?

Os tipos de dados desempenham uma função central no C#. Na verdade, a ênfase nos tipos de dados é um dos principais recursos de distinção do C# em comparação com outras linguagens, como JavaScript. Os designers do C# acreditavam que podem ajudar os desenvolvedores a evitar bugs de software comuns aplicando tipos de dados. Você verá esse conceito se desdobrar à medida que aprender mais sobre C#.

Tipos de dados definem recursos

Anteriormente, você viu que strings e chars são usados para "apresentação, não cálculo". Se você precisar executar uma operação matemática em valores numéricos, deverá usar um int ou decimal. Se você tiver dados usados para apresentação ou manipulação de texto, deverá usar um tipo de dados string ou char.

Suponha que você precise coletar dados de um usuário, como um número de telefone ou código postal. Dependendo do país/região em que você mora, esses dados podem consistir em caracteres numéricos. No entanto, como você raramente executa cálculos matemáticos em números de telefone e códigos postais, você deve preferir usar um string tipo de dados ao trabalhar com eles.

O mesmo pode ser dito de bool. Se você precisar trabalhar com as palavras "true" e "false" em seu aplicativo, usará um string. No entanto, se você precisar trabalhar com o conceito de true ou false ao executar uma avaliação, use um bool.

É importante saber que esses valores podem se parecer com seus literais de cadeias de caracteres equivalentes. Em outras palavras, você pode pensar que essas instruções são as mesmas:

Console.WriteLine("123");
Console.WriteLine(123);

Console.WriteLine("true");
Console.WriteLine(true);

No entanto, é apenas a saída exibida que parece ser semelhante. O fato é que os tipos de coisas que você pode fazer com o int ou bool subjacente serão diferentes de seu string equivalente.

Recapitulação

A principal vantagem é que há muitos tipos de dados, mas você se concentrará em apenas alguns por enquanto:

string para palavras, frases ou quaisquer dados alfanuméricos para apresentação, não para cálculo
char para um único caractere alfanumérico
int para um número inteiro
decimal para um número com um componente fracionário
bool para um true/false valor