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 muda. Anteriormente, você exibia uma cadeia de caracteres literal para o console de saída. Em outras palavras, você literalmente queria que a cadeia de caracteres Halfanuméricos , , , , ol, e assim por diante, elfosse exibida no console de saída.

Use o tipo de dados de cadeia de caracteres sempre que tiver palavras, frases ou dados alfanuméricos para apresentação, 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

Existem muitos tipos de dados em C#. Mas, ao começar, você só precisa saber sobre cinco ou seis tipos de dados, pois eles abrangem a maioria dos cenários. Vamos exibir uma instância literal do tipo de dados para a saída.

Nota

Ao começar a trabalhar na janela de código, poderá notar que esta atribui diferentes cores a determinadas sintaxes para indicar palavras-chave, operadores, tipos de dados e mais. Repare nas cores. Ele pode ajudá-lo a identificar erros de sintaxe à medida que você insere caracteres e pode ajudá-lo a entender o código de forma mais eficaz.

Usar literais de caracteres

Se você quisesse apenas um único caractere alfanumérico impresso na tela, você poderia criar um literal de caracteres caracteres cercando um caractere alfanumérico entre aspas simples. O termo char é curto para caráter. Em C#, esse tipo de dados é oficialmente chamado de "char", mas frequentemente referido como um "caractere".

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

Observe que a letra b está entre aspas 'b'simples. Aspas simples criam um literal de caracteres. Lembre-se de que o uso de aspas duplas cria um tipo de string dados.
Pressione o botão verde Run (Executar) para executar o código. Você deve ver o seguinte resultado na janela de saída:
```
b
```

Se você inserir o seguinte código:

Console.WriteLine('Hello World!');

Recebe este 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 um único caractere. No entanto, neste caso, a sintaxe literal do caractere foi usada, mas 12 caracteres foram fornecidos!

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

Usar literais inteiros

Se quiser exibir um valor numérico de número inteiro (sem frações) no console de saída, você pode usar um literal int. O termo int é curto para inteiro, que você pode reconhecer ao estudar matemática. Em C#, esse tipo de dados é oficialmente chamado de "int", mas frequentemente referido como "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 verde Run (Executar) para executar o código. Você deve ver o seguinte resultado no console de saída:
```
123
```

Use literais de vírgula flutuante

Um número de vírgula flutuante é um número que contém um decimal, por exemplo 3,14159. C# suporta três tipos de dados para representar números decimais: float, doublee decimal. Cada tipo suporta vários 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. Neste contexto, o F é chamado um sufixo do literal. O sufixo literal diz ao compilador que você deseja trabalhar com um valor de float tipo. Você pode usar minúsculas f ou maiúsculas F como sufixo literal para um floatarquivo .
Pressione o botão verde Run (Executar) para executar o código. Você deve ver o seguinte resultado no console de saída:
```
0.25
```
Observe que o tipo de dados é o float menos preciso, por isso é melhor usar esse tipo de dados para valores fracionários fixos para evitar erros de cálculo inesperados.
Adicione a seguinte linha de código no editor de código:
```
Console.WriteLine(2.625);
```
Para criar um literal, basta inserir um double número decimal. O compilador assume como padrão um literal quando um número decimal é inserido sem um double sufixo literal.
Pressione o botão verde Run (Executar) para executar o código. Você deve 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 de número decimal, acrescente a letra m após o número. Neste contexto, o m é chamado um sufixo do literal. O sufixo literal diz ao compilador que você deseja trabalhar com um valor de decimal tipo. Você pode usar minúsculas m ou maiúsculas M como sufixo literal para um decimalarquivo .
Pressione o botão verde Run (Executar) para executar o código. Você deve ver o seguinte resultado no console de saída:
```
12.39816
```

Usar literais booleanos

Se você quisesse imprimir um valor representando um ou falseoutro, você poderia usar um true literal bool.

O termo bool é curto para Booleano. Em C#, eles são oficialmente referidos como "bool", mas muitas vezes 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 verde Run (Executar) para executar o código. Você deve 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 elas são verdadeiras ou falsas.

Porque é que damos ênfase aos tipos de dados?

Os tipos de dados desempenham uma função central em C#. Na verdade, a ênfase nos tipos de dados é uma das principais características distintivas do C# em comparação com outras linguagens como JavaScript. Os criadores do C# acreditaram que podiam ajudar os programadores a evitar erros comuns de software através da imposição de tipos de dados. Verá este conceito em ação à medida que sabe mais sobre o C#.

Os tipos de dados definem recursos

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

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

O mesmo pode ser dito de bool. Se precisar de trabalhar com as palavras "true" e "false" na sua aplicação, deve utilizar string. No entanto, se precisar de trabalhar com o conceito de true ou false ao efetuar uma avaliação, utilize bool.

É importante saber que estes valores podem parecer-se com os equivalentes de cadeias literais. Por outras palavras, pode considerar que estas 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 facto é que aquilo que pode fazer com o int ou bool subjacente será diferente do seu equivalente string.

Recapitulação

A principal conclusão é que existem 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 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

Continuar