Ejercicio: Impresión de valores literales

10 minutos

En este ejercicio imprimiremos mensajes que contengan otros tipos de datos y aprenderemos por qué los tipos de datos son tan importantes en C#.

¿Qué es un valor literal?

Un valor literal es un valor constante que nunca cambia. Anteriormente se ha mostrado una cadena de literales en la consola de salida. Es decir, el objetivo literalmente era que esa cadena de caracteres alfanuméricos H, e, l, l, o, etc. se mostrara en la consola de salida.

El tipo de datos de cadena se usa siempre que se tienen palabras, frases o datos alfanuméricos para presentación, no cálculo. ¿Qué otros tipos de datos literales se pueden imprimir en la salida?

Ejercicio: Impresión de distintos tipos de datos literales

Hay muchos tipos de datos en C#, Aunque para empezar solo es necesario conocer unos cinco o seis tipos de datos, ya que cubren la mayoría de los escenarios. Vamos a mostrar una instancia literal de tipo de datos en la salida.

Nota:

Es posible que observe que, al empezar a trabajar en la ventana de código, se colorea una sintaxis determinada en diferentes colores para indicar palabras clave, operadores, tipos de datos, etc. Empiece a observar los colores. Puede ayudarle a detectar errores de sintaxis a medida que escribe caracteres y a comprender el código de forma más eficaz.

Uso de literales de caracteres

Si únicamente queremos imprimir un carácter alfanumérico en la pantalla, podemos crear un literal char; para ello, escribiríamos un carácter alfanumérico entre comillas simples. char se usa como abreviatura de carácter. En C#, este tipo de datos se denomina oficialmente "char", pero con frecuencia se conoce como "carácter".

Agregue la siguiente línea de código en el editor de código:
```
Console.WriteLine('b');
```
Observe el código que ha escrito.

Observe que la letra b está entre comillas simples 'b'. Las comillas simples crean un literal de carácter. Recuerde que el uso de comillas dobles crea un tipo de datos string.
Presione el botón verde Ejecutar para ejecutar el código. Deberíamos ver el resultado siguiente en la ventana de salida:
```
b
```

Si escribe el código siguiente:

Console.WriteLine('Hello World!');

Se obtiene el siguiente error:

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

Observe las comillas simples que rodean Hello World!. Cuando se usan comillas simples, el compilador de C# espera un solo carácter. Sin embargo, en este caso, se usó la sintaxis literal de caracteres, pero en su lugar se proporcionaron 12 caracteres.

Al igual que con el tipo de datos string, usamos char siempre que tengamos un solo carácter alfanumérico para presentación (no cálculo).

Uso de literales enteros

Si queremos mostrar un número entero (sin fracciones) en la consola de salida, podemos usar literal int. El término int es la abreviatura de entero, que puede que recuerde de cuando ha estudiado matemáticas. En C#, este tipo de datos se denomina oficialmente "int", pero se conoce con frecuencia como "entero". Un literal int no requiere otros operadores, como string o char.

Agregue la siguiente línea de código en el editor de código:
```
Console.WriteLine(123);
```
Presione el botón verde Ejecutar para ejecutar el código. Deberíamos ver el resultado siguiente en la consola de salida:
```
123
```

Uso de literales de punto flotante

Un número de punto flotante es uno que contiene decimales, por ejemplo, 3,14159. C# admite tres tipos de datos para representar números decimales: float, double y decimal. Cada tipo admite distintos grados de precisión.

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

Aquí, la precisión refleja el número de dígitos decimales precisos.

Agregue la siguiente línea de código en el editor de código:
```
Console.WriteLine(0.25F);
```
Para crear un literal decimal float, anexe la letra F después del número. En este contexto, F se denomina sufijo literal. El sufijo literal le indica al compilador que queremos trabajar con un valor de tipo float. Puede usar f en minúsculas o F en mayúsculas como sufijo literal de float.
Presione el botón verde Ejecutar para ejecutar el código. Deberíamos ver el resultado siguiente en la consola de salida:
```
0.25
```
Tenga en cuenta que el tipo de datos float es el menos preciso, por lo que es mejor usar este tipo de datos para los valores fraccionarios fijos y así evitar errores de cálculo imprevistos.
Agregue la siguiente línea de código en el editor de código:
```
Console.WriteLine(2.625);
```
Para crear un literal double, simplemente escriba un número decimal. El compilador tiene como valor predeterminado un literal double cuando se escribe un número decimal sin sufijo literal.
Presione el botón verde Ejecutar para ejecutar el código. Deberíamos ver el resultado siguiente en la ventana de salida:
```
2.625
```
Agregue la siguiente línea de código en el editor de código:
```
Console.WriteLine(12.39816m);
```
Para crear un literal decimal, anexe la letra m después del número. En este contexto, m se denomina sufijo literal. El sufijo literal le indica al compilador que queremos trabajar con un valor de tipo decimal. Puede usar m en minúsculas o M en mayúsculas como sufijo literal de decimal.
Presione el botón verde Ejecutar para ejecutar el código. Deberíamos ver el resultado siguiente en la consola de salida:
```
12.39816
```

Uso de literales booleanos

Si queremos imprimir un valor que represente true o false, podemos usar un literal bool.

El término bool es la abreviatura de booleano. En C#, se conoce oficialmente como "bool", pero a menudo los desarrolladores usan el término "booleano".

Agregue las siguientes línea de código en el editor de código:
```
Console.WriteLine(true);
Console.WriteLine(false);
```
Presione el botón verde Ejecutar para ejecutar el código. Deberíamos ver el resultado siguiente en la consola de salida:
```
True
False
```

Los literales bool representan el concepto de verdad y falsedad. Los valores bool se usan mucho cuando se comienza a agregar lógica de decisión a las aplicaciones. Vamos a evaluar las expresiones para ver si son verdaderas o falsas.

¿Por qué enfatizar los tipos de datos?

Los tipos de datos desempeñan un papel fundamental en C#. De hecho, el énfasis en los tipos de datos es una de las características distintivas de C# en comparación con otros lenguajes como JavaScript. Los diseñadores de C# creían poder ayudar a los desarrolladores a evitar errores comunes de software mediante la aplicación de tipos de datos. A medida que obtenga más información sobre C#, verá cómo se desarrolla este concepto.

Los tipos de datos definen funcionalidades

Antes hemos mencionado que los valores string y char se usan para "presentación, no cálculo". Si necesita realizar una operación matemática con valores numéricos, debe usar un valor int o decimal. Si tenemos datos solo con fines de presentación o manipulación de texto, debemos usar un tipo de datos string o char.

Imagine que necesita recopilar datos de un usuario, como un número de teléfono o un código postal. En función del país o la región donde viva, esos datos pueden ser caracteres numéricos. Pero dado que rara vez realiza cálculos matemáticos con números de teléfono y códigos postales, es preferible usar un tipo de datos string al trabajar con ellos.

Lo mismo puede decirse de bool. Si necesita trabajar con las palabras "true" y "false" en la aplicación, debe usar un valor string. Pero si necesita trabajar con el concepto de true o false al realizar una evaluación, use un valor bool.

Es importante saber que estos valores pueden ser similares a sus equivalentes de literales de cadena. Es decir, puede pensar que estas instrucciones son iguales:

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

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

Sin embargo, solo es similar la salida que se muestra. El hecho es que los tipos de cosas que puede hacer con el valor subyacente int o bool son diferentes a los de su equivalente string.

Resumen

El primer concepto que aprendemos es que hay muchos tipos de datos, pero por ahora nos vamos a centrar en solo unos cuantos:

string para palabras, frases o cualquier dato alfanumérico para presentación, no cálculo
char para un solo carácter alfanumérico
int para un número entero
decimal para un número con un componente fraccionado
bool para un valor true/false

Continuar