Variables de C# y tipos de datos (primitivos)

Variables de C# y tipos de datos (primitivos)

En este tutorial, aprenderemos sobre variables, cómo crear variables en C# y diferentes tipos de datos compatibles con el lenguaje de programación C#.

Una variable es un nombre simbólico dado a una ubicación de memoria. Las variables se utilizan para almacenar datos en un programa de computadora.

---

¿Cómo declarar variables en C#?

Aquí hay un ejemplo para declarar una variable en C#.

int age;

En este ejemplo, una variable edad de tipo int (entero) se declara y solo puede almacenar valores enteros.

Podemos asignar un valor a la variable más adelante en nuestro programa como este:

int age;
... ... ...
age = 24;

Sin embargo, la variable también se puede inicializar con algún valor durante la declaración. Por ejemplo,

int age = 24;

Aquí, una variable edad de tipo int se declara e inicializa a 24 al mismo tiempo.

Como es una variable, también podemos cambiar el valor de las variables. Por ejemplo,

int age = 24;
age = 35;

Aquí, el valor de edad se cambia de 24 a 35.

---

Las variables en C# deben declararse antes de poder usarse. Esto significa que se debe conocer el nombre y el tipo de variable antes de que se les pueda asignar un valor. Esta es la razón por la que C# se denomina lenguaje de tipado estático.

Una vez declarado, el tipo de datos de una variable no se puede cambiar dentro de un ámbito. Un alcance puede pensarse como un bloque de código donde la variable está visible o disponible para usar. Si no entiende la declaración anterior, no se preocupe, aprenderemos sobre los alcances en los capítulos posteriores.

Por ahora recuerde, no podemos hacer lo siguiente en C#:

int age;
age = 24;
... ... ...
float age;

---

Variables tipificadas implícitamente

Alternativamente, en C#, podemos declarar una variable sin conocer su tipo usando var palabra clave. Estas variables se denominan variables locales tipificadas implícitamente .

Variables declaradas usando var la palabra clave debe inicializarse en el momento de la declaración.

var value = 5;

El compilador determina el tipo de variable a partir del valor que se asigna a la variable. En el ejemplo anterior, valor es de tipo int . Esto es equivalente a:

int value;
value = 5;

Puede obtener más información sobre las variables locales tipificadas implícitamente.

---

Reglas para nombrar variables en C#

Hay ciertas reglas que debemos seguir al nombrar una variable. Las reglas para nombrar una variable en C# son:

1. El nombre de la variable puede contener letras (mayúsculas y minúsculas), guión bajo (_) y dígitos únicamente.
2. El nombre de la variable debe comenzar con una letra, un guión bajo o el símbolo @. Por ejemplo,

   Reglas para nombrar variables en C#

   Nombres de variables	Observaciones
   nombre	Válido
   sujeto101	Válido
   _edad	Válido (práctica recomendada para nombrar variables miembro privadas)
   @descanso	Válido (se usa si el nombre es una palabra clave reservada)
   101sujeto	Inválido (Empieza con un dígito)
   tu_nombre	Válido
   tu nombre	No válido (contiene espacios en blanco)

3. C# distingue entre mayúsculas y minúsculas. Significa edad y Edad se refiere a 2 variables diferentes.
4. Un nombre de variable no debe ser una palabra clave de C#. Por ejemplo, if , for , using no puede ser un nombre de variable. Hablaremos más sobre las palabras clave de C# en el próximo tutorial.

---

Prácticas recomendadas para nombrar una variable

1. Elija un nombre de variable que tenga sentido. Por ejemplo, nombre , edad , asunto tiene más sentido que n , a y s .
2. Usar camelCase notación (comienza con letra minúscula) para nombrar variables locales. Por ejemplo, númeroDeEstudiantes , edad , etc.
3. Usar PascalCase o CamelCase (comienza con letra mayúscula) para nombrar variables miembro públicas. Por ejemplo, Nombre , Precio , etc.
4. Utilice un guión bajo (_) seguido de camelCase notación para nombrar variables miembro privadas. Por ejemplo, _bankBalance , _dirección de correo electrónico , etc.

Puede obtener más información sobre las convenciones de nomenclatura en C# aquí.

No se preocupe por las variables de miembro públicas y privadas. Aprenderemos sobre ellos en capítulos posteriores.

---

Tipos de datos primitivos de C#

Las variables en C# se clasifican en términos generales en dos tipos:Tipos de valor y Tipos de referencia . En este tutorial, hablaremos sobre los tipos de datos primitivos (simples), que son una subclase de los tipos de valor.

Los tipos de referencia se tratarán en tutoriales posteriores. Sin embargo, si desea obtener más información sobre los tipos de variables, visite Tipos y variables de C# (documentos oficiales de C#).

Booleano (bool)

• El tipo de datos booleano tiene dos valores posibles:true o false
• Valor predeterminado :false
• Las variables booleanas generalmente se usan para verificar condiciones como en instrucciones if , bucles , etc.

Por ejemplo:

using System;
namespace DataType
{
    class BooleanExample
    {
        public static void Main(string[] args)
        {
            bool isValid = true;
            Console.WriteLine(isValid);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

True

---

Integral con signo

Estos tipos de datos contienen valores enteros (tanto positivos como negativos). Del total de bits disponibles, se utiliza un bit para firmar.

1. sbyte

• Tamaño :8 bits
• Alcance :-128 a 127.
• Valor predeterminado :0

Por ejemplo:

using System;
namespace DataType
{
    class SByteExample
    {
        public static void Main(string[] args)
        {
            sbyte level = 23;
            Console.WriteLine(level);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

23

Intente asignar valores fuera del rango, es decir, menos de -128 o más de 127 y vea qué sucede.

---

2. corto

• Tamaño :16 bits
• Alcance :-32.768 a 32.767
• Valor predeterminado :0

Por ejemplo:

using System;
namespace DataType
{
    class ShortExample
    {
        public static void Main(string[] args)
        {
            short value = -1109;
            Console.WriteLine(value);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

-1109

---

3. int

• Tamaño :32 bits
• Alcance :-231 a 231-1
• Valor predeterminado :0

Por ejemplo:

using System;
namespace DataType
{
    class IntExample
    {
        public static void Main(string[] args)
        {
            int score = 51092;
            Console.WriteLine(score);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

51092

---

4. largo

• Tamaño :64 bits
• Alcance :-263 a 263-1
• Valor predeterminado :0L [L al final representa que el valor es de tipo largo]

Por ejemplo:

using System;
namespace DataType
{
    class LongExample
    {
        public static void Main(string[] args)
        {
            long range = -7091821871L;
            Console.WriteLine(range);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

-7091821871

---

Integral sin signo

Estos tipos de datos solo contienen valores iguales o superiores a 0. Generalmente usamos estos tipos de datos para almacenar valores cuando estamos seguros de que no tendremos valores negativos.

1. byte

• Tamaño :8 bits
• Alcance :0 a 255.
• Valor predeterminado :0

Por ejemplo:

using System;
namespace DataType
{
    class ByteExample
    {
        public static void Main(string[] args)
        {
            byte age = 62;
            Console.WriteLine(level);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

62

---

2. corto

• Tamaño :16 bits
• Alcance :0 a 65.535
• Valor predeterminado :0

Por ejemplo:

using System;
namespace DataType
{
    class UShortExample
    {
        public static void Main(string[] args)
        {
            ushort value = 42019;
            Console.WriteLine(value);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

42019

---

3. uint

• Tamaño :32 bits
• Alcance :0 a 232-1
• Valor predeterminado :0

Por ejemplo:

using System;
namespace DataType
{
    class UIntExample
    {
        public static void Main(string[] args)
        {
            uint totalScore = 1151092;
            Console.WriteLine(totalScore);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

1151092

---

4. largo

• Tamaño :64 bits
• Alcance :0 a 264-1
• Valor predeterminado :0

Por ejemplo:

using System;
namespace DataType
{
    class ULongExample
    {
        public static void Main(string[] args)
        {
            ulong range = 17091821871L;
            Console.WriteLine(range);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

17091821871

---

Coma flotante

Estos tipos de datos contienen valores de coma flotante, es decir, números que contienen valores decimales. Por ejemplo, 12,36, -92,17, etc.

1. flotar

• Tipo de coma flotante de precisión simple
• Tamaño :32 bits
• Alcance :1,5 × 10−45 a 3,4 × 1038
• Valor predeterminado :0.0F [F al final representa que el valor es de tipo flotante]

Por ejemplo:

using System;
namespace DataType
{
    class FloatExample
    {
        public static void Main(string[] args)
        {
            float number = 43.27F;
            Console.WriteLine(number);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

43.27

---

2. doble

• Tipo de punto flotante de precisión doble. ¿Cuál es la diferencia entre punto flotante de precisión simple y doble?
• Tamaño :64 bits
• Alcance :5,0 × 10−324 a 1,7 × 10308
• Valor predeterminado :0.0D [D al final representa que el valor es de tipo doble]

Por ejemplo:

using System;
namespace DataType
{
    class DoubleExample
    {
        public static void Main(string[] args)
        {
            double value = -11092.53D;
            Console.WriteLine(value);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

-11092.53

---

Carácter (carácter)

• Representa un carácter Unicode de 16 bits.
• Tamaño :16 bits
• Valor predeterminado :'\0'
• Alcance :U+0000 ('\u0000') a U+FFFF ('\uffff')

Por ejemplo:

using System;
namespace DataType
{
    class CharExample
    {
        public static void Main(string[] args)
        {
            char ch1 ='\u0042';
            char ch2 = 'x';
            Console.WriteLine(ch1);
            Console.WriteLine(ch2);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

B
x

El valor Unicode de 'B' es '\u0042' , por lo tanto, imprimiendo ch1 imprimirá 'B' .

---

decimales

• El tipo decimal tiene más precisión y un rango más pequeño en comparación con los tipos de punto flotante (doble y flotante). Por lo tanto, es apropiado para cálculos monetarios.
• Tamaño :128 bits
• Valor predeterminado :0.0M [M al final representa que el valor es de tipo decimal]
• Alcance :(-7,9 x 1028 a 7,9 x 1028) / (100 a 28)

Por ejemplo:

using System;
namespace DataType
{
    class DecimalExample
    {
        public static void Main(string[] args)
        {
         decimal bankBalance = 53005.25M;
            Console.WriteLine(bankBalance);
        }
    }
}

Cuando ejecutamos el programa, la salida será:

53005.25

El sufijo M o m debe agregarse al final; de lo contrario, el valor se tratará como un doble y se generará un error.

---

C# Literales

Veamos la siguiente afirmación:

int number = 41;

Aquí,

• int es un tipo de datos
• número es una variable y
• 41 es un literal

Los literales son valores fijos que aparecen en el programa. No requieren ningún cálculo. Por ejemplo, 5 , false , 'w' son literales que aparecen en un programa directamente sin ningún cálculo.

---

Literales booleanos

• true y false son los literales booleanos disponibles.
• Se utilizan para inicializar variables booleanas.

Por ejemplo:

bool isValid = true;
bool isPresent = false;

---

Literales enteros

• Los literales enteros se utilizan para inicializar variables de tipos de datos enteros, es decir, sbyte , short , int , long , byte , ushort , uint y ulong .
• Si un literal entero termina en L o l , es de tipo largo. Para las mejores prácticas, use L (no l ).

  long value1 = 4200910L;
  long value2 = -10928190L;

• Si un literal entero comienza con un 0x , representa el valor hexadecimal. Los números sin prefijos se tratan como valores decimales. La representación octal y binaria no está permitida en C#.

  int decimalValue = 25;
  int hexValue = 0x11c;// decimal value 284

---

Literales de coma flotante

• Los literales de punto flotante se utilizan para inicializar variables de tipos de datos flotantes y dobles.
• Si un literal de punto flotante termina con un sufijo f o F , es de tipo float. Del mismo modo, si termina en d o D , es de tipo doble. Si ninguno de los sufijos está presente, es de tipo double por predeterminado .
• Estos literales contienen e o E cuando se expresan en notación científica.

  double number = 24.67;// double by default
  float value = -12.29F;
  double scientificNotation = 6.21e2;// equivalent to 6.21 x 102 i.e. 621

---

Literales de caracteres y cadenas

• Los literales de caracteres se utilizan para inicializar variables de tipos de datos char.
• Los caracteres literales se encierran entre comillas simples. Por ejemplo, 'x' , 'p' , etc.
• Se pueden representar como caracteres, secuencia de escape hexadecimal, representación Unicode o valores integrales convertidos en char.

  char ch1 = 'R';// character
  char ch2 = '\x0072';// hexadecimal
  char ch3 = '\u0059';// unicode
  char ch4 = (char)107;// casted from integer

• Los literales de cadena son la colección de literales de caracteres.
• Están entre comillas dobles. Por ejemplo, "Hola" , "Programación fácil" , etc

  string firstName = "Richard";
  string lastName = " Feynman";

• C# también admite caracteres de secuencia de escape como:
  

  Carácter	Significado
  \'	Comilla simple
  \"	Comillas dobles
  \\	barra invertida
  \n	Nueva línea
  \r	Retorno de carro
  \t	Pestaña horizontal
  \a	Alerta
  \b	Retroceso