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ê queria literalmente aquela sequência de caracteres alfanuméricos H, e, l, l, o e assim por diante, 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

Há 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 como saída.

Um editor de código C# está disponível para uso direto no navegador: C# Code Editor. Este editor fornece um ambiente leve para escrever, executar e testar código C# sem a necessidade de instalar qualquer software no seu computador local.

Usar literais de caracteres

Se tu quisesses apenas um único caractere alfanumérico impresso no ecrã, poderias criar um literal de caracteres colocando um caractere alfanumérico entre aspas simples ('). O termo char é a abreviação de caractere. Em C#, esse tipo de dados é oficialmente chamado de "char", mas frequentemente referido como um "caractere".

Abra o Editor de Códigos C# em uma nova janela ou guia do navegador.

Você pode posicionar as janelas do navegador lado a lado para que possa consultar estas instruções enquanto trabalha no Editor de Códigos C#.
Adicione a seguinte linha de código no editor de código:
```
Console.WriteLine('b');
```
Observe o código que introduziu.

Note que a letra b está rodeada por aspas 'b' simples. Aspas simples criam um literal de caractere. Lembre-se de que o uso de aspas duplas cria um tipo de string dados.
Pressione o botão ▶️ Executar para executar o seu código. Você deve ver o seguinte resultado na janela de saída:
```
b
```

Se inserires o seguinte código:

Console.WriteLine('Hello World!');

Você receberia o seguinte erro:

CS1012: Too many characters in character literal

Note as aspas 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 é uma abreviação de inteiro, que se 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 ▶️ Executar para executar o seu código. Você deve ver o seguinte resultado no console de saída:
```
123
```

Use literais de ponto 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 de sufixo literal. O sufixo literal diz ao compilador que pretende trabalhar com um valor do tipo float. Você pode usar minúsculas f ou maiúsculas F como sufixo literal para um float.
Pressione o botão ▶️ Executar para executar o seu código. Você deve ver o seguinte resultado no console de saída:
```
0.25
```
Observe que o float tipo de dados é o 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 double literal, basta inserir um número decimal. O compilador assume como padrão um double literal quando um número decimal é inserido sem um sufixo literal.
Pressione o botão ▶️ Executar para executar o seu 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 decimal, acrescente a letra m após o número. Neste contexto, o m é chamado de sufixo literal. O sufixo literal diz ao compilador que pretende trabalhar com um valor do tipo decimal. Você pode usar minúsculas m ou maiúsculas M como sufixo literal para um decimal.
Pressione o botão ▶️ Executar para executar o seu código. Você deve ver o seguinte resultado no console de saída:
```
12.39816
```

Usar literais booleanos

Se quisesses imprimir um valor representando true ou false, poderias usar um literal booleano.

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 ▶️ Executar para executar o seu 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.

Por que enfatizar os tipos de dados?

Os tipos de dados desempenham um papel central no 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 designers do C# acreditavam que podem ajudar os desenvolvedores a evitar bugs comuns de software impondo tipos de dados. Você verá esse conceito se desdobrar à medida que aprender mais sobre 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 você precisar executar uma operação matemática em valores numéricos, você deve usar um 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 você raramente executa cálculos matemáticos em números de telefone e códigos postais, você deve preferir usar um tipo de string dados ao trabalhar com eles.

O mesmo se pode dizer de bool. Se precisar trabalhar com as palavras "true" e "false" na sua aplicação, usaria um string. No entanto, se você precisa trabalhar com o conceito de true ou false ao realizar uma avaliação, você usa um bool.

É importante saber que esses valores podem assemelhar-se aos seus equivalentes literais de sequências de caracteres. Em outras palavras, você pode pensar que estas afirmaçõ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 subjacente int ou bool serão diferentes do respetivo 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

Comentários

Esta página foi útil?