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 em C#.

O que é um valor literal?

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

Use o tipo de dados cadeia de caracteres sempre que você tiver palavras alfanuméricas, frases ou dados para apresentação, e não para 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, enquanto está começando, você precisa conhecer apenas cinco ou seis tipos de dados, pois eles cobrem a maioria dos cenários. Vamos exibir uma instância literal do tipo de dados na saída.

Observação

Talvez você observe, quando começar a trabalhar na janela de código, que ele atribui cores diferentes a determinadas sintaxes para indicar palavras-chave, operadores, tipos de dados e assim por diante. Comece a observar as cores. Elas podem ajudar você a identificar erros de sintaxe ao inserir caracteres e 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 é a abreviação de caractere em inglês. Em C#, o nome oficial desse tipo de dados é "char", mas ele é frequentemente chamado de "caractere".

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

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

Se você inserir o seguinte código:

Console.WriteLine('Hello World!');

Você verá o seguinte erro:

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

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

Assim como o tipo de dados string, você deve usar char sempre que tiver apenas um caractere alfanumérico para apresentação (e não para cálculo).

Usar literais de inteiros

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

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

Usar literais de ponto flutuante

Um número de ponto flutuante é um número que contém decimais, por exemplo, 3,14159. O C# dá suporte a três tipos de dados para representar números decimais: float, double e 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 casas decimais utilizadas.

Adicione a linha de código a seguir 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 é chamado de sufixo literal. O sufixo literal informa ao compilador que você deseja trabalhar com um valor do tipo float. Você pode usar f em letras minúsculas ou F em maiúsculas como o sufixo literal para float.
Pressione o botão verde Executar para executar o seu código. O seguinte resultado deverá ser exibido no console de saída:
```
0.25
```
Observe que o tipo de dados float é o menos preciso, portanto, é melhor usar esse tipo de dados para valores fracionários fixos a fim de evitar erros de computação inesperados.
Adicione a linha de código a seguir 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 o double literal quando um número decimal é inserido sem um sufixo literal.
Pressione o botão verde Executar para executar o seu código. O seguinte resultado deverá ser exibido na janela de saída:
```
2.625
```
Adicione a linha de código a seguir 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 de sufixo literal. O sufixo literal informa ao compilador que você deseja trabalhar com um valor do tipo decimal. Você pode usar m em letras minúsculas ou M em maiúsculas como o sufixo literal para decimal.
Pressione o botão verde Executar para executar o seu código. O seguinte resultado deverá ser exibido no console de saída:
```
12.39816
```

Usar literais de boolianos

Se quiser imprimir um valor representando true ou false, você pode usar um bool literal.

O termo bool é a abreviação de Boolean. Em C#, o nome oficial é "bool", mas os desenvolvedores frequentemente usam o termo "booliano" para se referir a esse tipo.

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

Os literais de bool representam a ideia de verdadeiro ou falso. Você usa bastante valores bool quando começa a adicionar lógica de decisão aos aplicativos criados. Você avalia as expressões para ver se são verdadeiras ou falsas.

Por que enfatizar tipos de dados?

Os tipos de dados desempenham um papel fundamental em C#. De fato, a ênfase nos tipos de dados é uma das principais características que distingue o C# de outras linguagens, como Python e JavaScript. Os designers de C# acreditavam que poderiam ajudar os desenvolvedores a evitar bugs de software comuns impondo tipos de dados. Você verá esse conceito de desenvolver à medida que aprender mais sobre C#.

Os tipos de dados definem as funcionalidades

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

Suponha que você precisasse 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ê reside, esses dados podem ser compostos por caracteres numéricos. No entanto, como raramente executa cálculos matemáticos em números de telefone e códigos postais, você deve preferir usar um tipo de dados string ao trabalhar com eles.

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

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

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 lição é que há muitos tipos de dados, mas você vai se concentrar em apenas alguns deles por enquanto:

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

Continuar