VARIABLES
Todos los programas necesitan, en algún momento, almacenar
números o datos ingresado por el usuario. Estos datos son almacenados en
variables, y en C++ como en otros lenguajes estas variables deben tener un
tipo.
Los tipos de variables
Existen varios tipos de variables, y cada uno corresponde a
un tamaño máximo de un número, un carácter o incluso una verdad. Cuanto mayor
sea el número que pueda admitir, mas espacio en memoria ocupará.
1.1 bool
Por lo general utiliza 1 byte de memoria,
valores: true o false.
1.2 char
Utiliza generalmente 1 byte de memoria,
permite almacenar un carácter, valores; 256 caracteres.
1.3 unsigned short int
Utiliza generalmente 2 bytes de memoria,
valores: de 0 a 65 535
1.4 short int
Utiliza generalmente 2 bytes de memoria,
valores: de -32768 a 32767.
1.5 unsigned long int
Utiliza generalmente 4 bytes de memoria,
valores: de 0 a 4 294 967 295.
1.6 long int
Utiliza generalmente 4 bytes de memoria,
valores: de -2 147 483 648 a 2 147 483 647.
1.7 int (16 bits)
Utiliza generalmente 2 bytes de memoria,
valores: de -32 768 a 32 767.
1.8 int (32 bits)
Utiliza generalmente 4 bytes de memoria,
valores: de -2 147 483 648 a 2 147 483 647.
1.9 unsigned int (16 bits)
Utiliza generalmente 2 bytes de memoria,
valores: de 0 a 65 535.
1.10 unsigned int (32 bits)
Utiliza generalmente 2 bytes de memoria,
valores: de 0 a 4 294 967 295.
1.11 double
Utiliza generalmente 8 bytes de memoria,
valores: de 2.2e-308 a 3.4e-38.
1.12 float
Utiliza generalmente 4 bytes de memoria, valores: de 1.2e-308 a 3.4e-38.
Atención!
El tamaño de las variables en memoria puede variara de un PC a otro.
El tamaño de las variables en memoria puede variara de un PC a otro.
VARIABLE SHORT:
short denota un tipo de datos integrales que almacena los
valores de acuerdo con el tamaño y el rango que se muestran en la siguiente
tabla.|
Tipo
|
Distancia
|
tamaño
|
Tipo de Framework
.NET
|
short |
-32,768 a 32,767
|
Entero de 16 bits con
signo
|
System.Int16
|
LITERALES:
Puede declarar e inicializar una
variable
short asignando un literal decimal, un literal hexadecimal
o (comenzando con C # 7) un literal binario. Si el literal entero está
fuera del rango de short (es decir, si es menor que Int16.MinValue o
mayor que Int16.MaxValue ), se produce un error de compilación.
En el siguiente ejemplo, los
enteros equivalentes a 1,034 que se representan como literales decimales,
hexadecimales y binarios se convierten implícitamente de int a valores
short .short shortValue1 = 1034; Console.WriteLine(shortValue1); short shortValue2 = 0x040A;
Console.WriteLine(shortValue2); short shortValue3 = 0b0100_00001010; Console.WriteLine(shortValue3); // The example displays the following output: // 1034 // 1034 // 1034
Nota
Utiliza el prefijo
0x o 0X para denotar un literal hexadecimal y el
prefijo 0b o 0B para denotar un literal binario. Los literales decimales no
tienen prefijo.
Comenzando con C # 7, se han
agregado un par de características para mejorar la legibilidad.
·
C # 7.0 permite el
uso del carácter de subrayado,
_ , como un separador de dígitos.
·
C # 7.2 permite
_ ser utilizado como un separador de dígitos para un literal
binario o hexadecimal, después del prefijo. No se permite que un literal decimal tenga un guion bajo
inicial.
Algunos ejemplos se muestran a
continuación.
short shortValue1 = 1_034; Console.WriteLine(shortValue1);
short shortValue2 = 0b00000100_00001010; Console.WriteLine(shortValue2); short shortValue3 = 0b_00000100_00001010; // C# 7.2 onwards Console
.WriteLine(shortValue3); // The example displays the following output: // 1034 // 1034 // 1034
Resolución
de sobrecarga del compilador
Se debe usar un yeso cuando se
invocan métodos sobrecargados. Considere, por ejemplo, los siguientes métodos sobrecargados
que usan parámetros
short e int :public static void SampleMethod(int i) {} public static void SampleMethod(short s) {}
Usar el lanzamiento
short garantiza que se llame al tipo correcto, por ejemplo:SampleMethod(5); // Calling the method with the int parameter SampleMethod((short)5); // Calling the method with the short parameter
COMVERSIONES
Hay una conversión predefinida
de
short a int , largo , flotante , doble o decimal .
No se pueden convertir
implícitamente los tipos numéricos no literales de mayor tamaño de
almacenamiento a
short (consulte la Tabla de tipos integrales para
los tamaños de almacenamiento de los tipos integrales). Considere, por ejemplo, las
siguientes dos variables short y :short x = 5, y = 12;
La siguiente declaración de
asignación produce un error de compilación porque la expresión aritmética en el
lado derecho del operador de asignación se evalúa como int por defecto.
short z = x + y; // Compiler error CS0266: no conversion from int to short
Para solucionar este problema, usa
un molde:
short z = (short)(x + y); // Explicit conversion
También es posible utilizar las
siguientes declaraciones, donde la variable de destino tiene el mismo tamaño de
almacenamiento o un tamaño de almacenamiento mayor:
int m = x + y; long n = x + y;
No hay conversión implícita de
tipos de punto flotante a
short . Por ejemplo, la siguiente declaración genera un error de
compilación a menos que se use un molde explícito:short x = 3.0; // Error: no implicit conversion from double short y = (short)3.0; // OK: explicit conversion
Para obtener información sobre
expresiones aritméticas con tipos mixtos de coma float y tipos integrales,
vea float y doublé.
VARIABLE INT:
int denota un tipo integral que almacena valores de
acuerdo con el tamaño y rango que se muestra en la siguiente tabla.|
Tipo
|
Distancia
|
tamaño
|
Tipo de Framework
.NET
|
Valor por defecto
|
int |
-2,147,483,648 a
2,147,483,647
|
Entero de 32 bits con
signo
|
0
|
Puede declarar e inicializar una
variable
int asignando un literal decimal, un literal hexadecimal
o (comenzando con C # 7) un literal binario. Si el literal entero está
fuera del rango de int (es decir, si es menor que Int32.MinValue o
mayor que Int32.MaxValue ), se produce un error de compilación.
En el siguiente ejemplo, los
enteros iguales a 90,946 que se representan como literales decimales,
hexadecimales y binarios se asignan a valores
int.int intValue1 = 90946; Console.WriteLine(intValue1); int intValue2 = 0x16342;
Console.WriteLine(intValue2); int intValue3 = 0b0001_0110_0011_0100_0010; Console.WriteLine(intValue3); // The example displays the following output: // 90946 // 90946 // 90946
Nota
Utiliza el prefijo
0x o 0X para denotar un literal hexadecimal y el
prefijo 0b o 0B para denotar un literal binario. Los literales decimales no
tienen prefijo.
Comenzando con C # 7, se han
agregado un par de características para mejorar la legibilidad.
·
C # 7.0 permite el
uso del carácter de subrayado,
_ , como un separador de dígitos.
·
C #
7.2 permite
_ ser
utilizado como un separador de dígitos para un literal binario o hexadecimal,
después del prefijo. No se
permite que un literal decimal tenga un guion bajo inicial.
Algunos ejemplos se muestran a
continuación.
int intValue1 = 90_946; Console.WriteLine(intValue1); int intValue2 = 0x0001_6342;
Console.WriteLine(intValue2); int intValue3 = 0b0001_0110_0011_0100_0010; Console.WriteLine(intValue3); int intValue4 = 0x_0001_6342; // C# 7.2 onwards Console.WriteLine(intValue4); int intValue5 = 0b_0001_0110_0011_0100_0010; // C# 7.2
onwards Console.WriteLine(intValue5); //
The example displays the following output: // 90946 // 90946 // 90946 // 90946 // 90946
Los literales enteros también
pueden incluir un sufijo que denota el tipo, aunque no hay un sufijo que denote
el tipo
int . Si un literal entero no tiene sufijo, su tipo es el primero
de los siguientes tipos en que se puede representar su valor:
1.
int
2. uint
3. largo
4. ulong
En estos ejemplos, el literal 90946
es de tipo
int .
Conversiones
// '123' is an int, so an implicit conversion takes place here: float f = 123;
Hay una conversión implícita
predefinida de sbyte , byte , short , ushort o char a
int . Por ejemplo, la siguiente declaración de asignación producirá
un error de compilación sin conversión:long aLong = 22; int i1 = aLong; // Error: no implicit conversion from long. int i2 =
(int)aLong; // OK: explicit conversion.
Observe también que no hay
conversión implícita de tipos de punto flotante a
int . Por ejemplo, la siguiente declaración genera un error de
compilación a menos que se use un molde explícito:
C#Copy
int x = 3.0; // Error: no implicit conversion from double. int y = (int)3.0; // OK:
explicit conversion.
VARIABLE LONG
Conserva números enteros de 64 bits
(8 bytes) con un valor comprendido entre -9,223,372,036,854,775,808 y
9,223,372,036,854,775,807 (9.2 ... E + 18).
Observaciones
Use el tipo de datos
Long para contener números enteros que son demasiado
grandes para caber en el tipo de datos Integer .
El valor predeterminado de
Long es 0.
Asignaciones literales
Puede declarar e inicializar una
variable
Long asignándola un literal decimal, un literal
hexadecimal, un literal octal o (comenzando con Visual Basic 2017) un literal
binario. Si
el literal entero está fuera del rango de Long (es decir,
si es menor que Int64.MinValue o mayor que Int64.MaxValue , se produce un error de
compilación.
En el siguiente ejemplo, los
enteros equivalentes a 4,294,967,296 que se representan como literales
decimales, hexadecimales y binarios se asignan a valores
Long .Dim longValue1 As Long = 4294967296 Console.WriteLine(longValue1) Dim longValue2
As Long = &H100000000 Console.WriteLine(longValue2) Dim longValue3
As Long = &B1_0000_0000_0000_0000_0000_0000_0000_0000 Console.WriteLine(longValue3)
' The example displays the following output: ' 4294967296 ' 4294967296 ' 4294967296
Nota
Usas el prefijo
&h o &H para denotar un literal hexadecimal, el prefijo &b o &B para denotar un literal binario, y el prefijo &o o &O para denotar un literal octal. Los literales decimales no
tienen prefijo.
A partir de Visual Basic 2017,
también puede usar el carácter de subrayado,
_ , como un separador de dígitos para mejorar la legibilidad,
como se muestra en el siguiente ejemplo.Dim longValue1 As Long = 4_294_967_296 Console.WriteLine(longValue1) Dim longValue2
As Long = &H1_0000_0000 Console.WriteLine(longValue2) Dim longValue3
As Long = &B1_0000_0000_0000_0000_0000_0000_0000_0000 Console.WriteLine(longValue3)
' The example displays the following output: ' 4294967296 ' 4294967296 ' 4294967296
A partir de Visual Basic 15.5,
también puede usar el carácter de subrayado (
_ ) como un separador principal entre el prefijo y los
dígitos hexadecimales, binarios u octales. Por ejemplo:Dim number As Long = &H_0FAC_0326_1489_D68C
Para utilizar el carácter de
subrayado como separador principal, debe agregar el siguiente elemento a su
archivo de proyecto de Visual Basic (* .vbproj):
<PropertyGroup> <LangVersion>15.5</LangVersion> </PropertyGroup>
Los literales numéricos también
pueden incluir el tipo de letra
L para indicar el tipo de datos Long , como se muestra en el siguiente ejemplo.Dim number = &H_0FAC_0326_1489_D68CL
Consejos
de programación
·
Consideraciones
interoperativas. Si está interactuando con componentes no escritos para .NET
Framework, por ejemplo, Automatización u objetos COM, recuerde que
Long tiene un
ancho de datos diferente (32 bits) en otros entornos. Si está pasando un argumento de 32 bits a dicho componente,
declare como Integer lugar de Long en su nuevo
código de Visual Basic.
·
Ensanchamiento El tipo de datos
Long se amplía
a Decimal , Single o Double . Esto significa que puede convertir Long a
cualquiera de estos tipos sin encontrar un error System.OverflowException .
·
Escriba
Caracteres. Agregar el carácter de tipo literal
L a un literal
lo fuerza al tipo de datos Long . Al agregar el carácter del tipo de identificador & a
cualquier identificador lo fuerza a Long .
VARIABLE
FLOAT
La palabra clave
float significa un tipo simple que almacena valores de coma
flotante de 32 bits. La siguiente tabla muestra la precisión y el rango aproximado
para el tipo de float .|
Tipo
|
Rango aproximado
|
Precisión
|
Tipo de Framework
.NET
|
float |
-3.4 × 10 38 a
+3.4 × 10 38
|
7 dígitos
|
De forma predeterminada, un literal
numérico real en el lado derecho del operador de asignación se trata como doble . Por lo tanto, para
inicializar una variable flotante, use el sufijo
f o F , como en el
siguiente ejemplo:float x = 3.5F;
Si no usa el sufijo en la
declaración anterior, obtendrá un error de compilación porque está tratando de
almacenar un valor doble en una variable
float .
Conversiones
Puede mezclar tipos integrales
numéricos y tipos de coma flotante en una expresión. En este caso, los tipos
integrales se convierten a tipos de punto flotante. La evaluación de la expresión se realiza de acuerdo con las
siguientes reglas:
·
Si
uno de los tipos de punto flotante es el doble , la expresión se
evalúa como doble o bool en expresiones relacionales o
booleanas.
·
Si
no hay un tipo doble en la expresión, la expresión se
evalúa como
float o bool en expresiones relacionales o
booleanas.
Una expresión de coma flotante
puede contener los siguientes conjuntos de valores:
·
Cero
positivo y negativo
·
Infinito
positivo y negativo
·
Valor
Not-a-Number (NaN)
·
El
conjunto finito de valores distintos de cero
Ejemplo
En el siguiente ejemplo, se
incluyen un int , un short y un
float en una expresión matemática que da un resultado
de float . (Recuerde que float es un alias
para el tipo System.Single ). Observe que no hay un doble en
la expresión.class FloatTest { static void Main() { int x = 3; float y = 4.5f; short z = 5; var
result = x * y / z; Console.WriteLine("The result is {0}", result); Type type = result.GetType(); Console.WriteLine("result is of type {0}", type.ToString()); } } /* Output: The result is 2.7 result is of type System.Single //'float' is alias for 'Single' */
TIPOS DE DATO DOUBLE
Contiene números de punto flotante
de doble precisión IEEE de 64 bits (8 bytes) firmados que tienen un valor de
-1.79769313486231570E + 308 a -4.94065645841246544E-324 para valores negativos
y de 4.94065645841246544E-324 a 1.79769313486231570E + 308 para positivo
valores. Los
números de doble precisión almacenan una aproximación de un número real.
Observaciones
El tipo de datos
Double proporciona las magnitudes más grandes y más pequeñas
posibles para un número.
El valor predeterminado de
Double es 0.
Consejos
de programación
·
Precisión. Cuando trabaje con números de
coma flotante, recuerde que no siempre tienen una representación precisa en la
memoria. Esto podría conducir a resultados
inesperados de ciertas operaciones, como la comparación de valores y el
operador
Mod . Para obtener más
información, vea Solucionar problemas de tipos de datos .
·
Zeros que se
arrastran. Los tipos de datos de punto flotante no tienen ninguna
representación interna de caracteres finales cero. Por ejemplo, no distinguen entre 4.2000 y 4.2. En consecuencia, los caracteres finales cero no aparecen
cuando visualiza o imprime valores de coma flotante.
·
Escriba
Caracteres. Al agregar el carácter de tipo literal
R a un literal,
se fuerza al tipo de datos Double . Por ejemplo, si un valor entero es seguido por R , el valor
cambia a Double .' Visual Basic expands the 4 in the statement Dim dub As Double = 4R to 4.0: Dim dub As Double = 4.0R
Al agregar el carácter
# tipo de identificador a cualquier identificador, se
fuerza a Double . En el siguiente ejemplo, la variable num se escribe
como un Double :Dim num# = 3
·
Tipo de marco El tipo correspondiente en
.NET Framework es la estructura System.Double
VARIABLES BYTE
Mantiene enteros sin signo de 8
bits (1 byte) que varían en valor de 0 a 255.
Observaciones
Use el tipo de datos
Byte para contener datos binarios.
El valor predeterminado de
Byte es 0.
Asignaciones literales
Puede declarar e inicializar una
variable de
Byte asignándole un literal decimal, un literal
hexadecimal, un literal octal o (comenzando con Visual Basic 2017) un literal
binario. Si
el literal integral está fuera del rango de un Byte (es decir,
si es menor que Byte.MinValue o mayor que Byte.MaxValue ), se produce un error de
compilación.
En el siguiente ejemplo, los
enteros equivalentes a 201 que se representan como literales decimales,
hexadecimales y binarios se convierten implícitamente de valores enteros a valores de
byte .Dim byteValue1 As Byte = 201 Console.WriteLine(byteValue1) Dim byteValue2
As Byte = &H00C9 Console.WriteLine(byteValue2) Dim byteValue3 As Byte
= &B1100_1001 Console.WriteLine(byteValue3) ' The example displays the following output: ' 201 ' 201 ' 201
Nota
Usas el prefijo
&h o &H para denotar un literal hexadecimal, el prefijo &b o &B para denotar un literal binario, y el prefijo &o o &O para denotar un literal octal. Los literales decimales no
tienen prefijo.
A partir de Visual Basic 2017,
también puede usar el carácter de subrayado, como un separador de dígitos
para mejorar la legibilidad, como se muestra en el siguiente ejemplo.
Dim byteValue3 As Byte = &B1100_1001 Console.WriteLine(byteValue3)
' The example displays the following output: ' 201
A partir de Visual Basic 15.5,
también puede usar el carácter de subrayado como un separador principal entre
el prefijo y los dígitos hexadecimales, binarios u octales. Por ejemplo:
Dim number As Byte = &H_6A
Para utilizar el carácter de subrayado
como separador principal, debe agregar el siguiente elemento a su archivo de
proyecto de Visual Basic (* .vbproj):
<PropertyGroup> <LangVersion>15.5</LangVersion> </PropertyGroup>
Consejos de programación
·
Números
negativos. Como
Byte es un tipo sin signo, no puede representar un número
negativo. Si utiliza el operador unario
negativo ( - ) en una expresión que evalúa escribir Byte , Visual
Basic convierte primero la expresión en Short .
·
Conversiones
de formato. Cuando Visual Basic lee o escribe archivos, o cuando llama a
DLL, métodos y propiedades, puede convertir automáticamente entre formatos de
datos. Los datos binarios almacenados en
las variables y matrices de
Byte se
conservan durante dichas conversiones de formato. No debe usar una variable String para
datos binarios, porque su contenido puede estar dañado durante la conversión
entre formatos ANSI y Unicode.
·
Ensanchamiento El tipo de datos
Byte se amplía
a Short , Short UShort , Integer , UInteger , Long , ULong Long , Decimal , Single o Double . Esto significa que puede convertir Byte a
cualquiera de estos tipos sin encontrar un error System.OverflowException .
·
Escriba
Caracteres.
Byte no tiene
carácter de tipo literal o carácter de tipo identificador.
Ejemplo
En el siguiente ejemplo,
b es una variable de Byte . Las afirmaciones demuestran el rango de la variable y la
aplicación de operadores de desplazamiento de bit hacia ella.
VBCopy
' The valid range of a Byte variable is 0 through 255. Dim b As Byte b = 30 '
The following statement causes an error because the value is too large. 'b = 256 '
The following statement causes an error because the value is negative. 'b = -5 '
The following statement sets b to 6. b = CByte(5.7) ' The following statements apply
bit-shift operators to b. ' The initial value of b is 6. Console.WriteLine(b) ' Bit shift to
the right divides the number in half. In this ' example, binary 110 becomes 11. b >>= 1 '
The following statement displays 3. Console.WriteLine(b) ' Now shift back to the original
position, and then one more bit ' to the left. Each shift to the left doubles the value. In this '
example, binary 11 becomes 1100. b <<= 2 ' The following statement displays 12. Console.
WriteLine(b)
VARIABLE CHAR:
Mantiene puntos de código sin signo
de 16 bits (2 bytes) que varían en valor de 0 a 65535. Cada punto de código , o código de carácter, representa un único carácter
Unicode.
Observaciones
Utilice el tipo de datos
Char cuando necesite contener solo un carácter y no
necesite la sobrecarga de String . En algunos casos, puede usar Char() , una
matriz de elementos Char , para contener múltiples caracteres.
El valor predeterminado de
Char es el personaje con un punto de código de 0.
Personajes Unicode
Los primeros 128 puntos de código
(0-127) de Unicode corresponden a las letras y símbolos en un teclado estándar
de EE. UU. Estos primeros 128 puntos de código son los mismos que define
el conjunto de caracteres ASCII. Los
segundos 128 puntos de código (128-255) representan caracteres especiales, como
letras del alfabeto en latín, acentos, símbolos de moneda y fracciones. Unicode utiliza los puntos de código restantes (256-65535)
para una amplia variedad de símbolos, incluidos caracteres textuales, signos
diacríticos y símbolos matemáticos y técnicos en todo el mundo.
Puede usar métodos como IsDigit e IsPunctuation en una variable
Char para determinar su clasificación Unicode.
Conversiones de tipo
Visual Basic no convierte
directamente entre
Char y los tipos numéricos. Puede usar la función Asc o AscW para convertir un valor Char en un Integer que
represente su punto de código. Puede usar
la función Chr o ChrW para convertir un valor Integer en
un Char que tenga ese punto de código.
Si el interruptor de comprobación
de tipo ( declaración de opción estricta ) está
activado, debe anexar el carácter de tipo literal a un literal de cadena de un
solo carácter para identificarlo como el tipo de datos
Char . El siguiente ejemplo lo ilustra.Option Strict On Dim charVar As Char ' The following statement attempts to convert a String literal to Char. ' Because Option Strict is On, it generates a compiler error. charVar = "Z" ' The following statement succeeds because it specifies a Char literal. charVar = "Z"C
CONSEJOS
DE PROGRAMACION
·
Números
negativos.
Char es un tipo
sin signo y no puede representar un valor negativo. En cualquier caso, no debe usar Char para
mantener valores numéricos.
·
Consideraciones
interoperativas. Si interactúa con componentes no escritos para .NET
Framework, por ejemplo, Automatización u objetos COM, recuerde que los tipos de
caracteres tienen un ancho de datos diferente (8 bits) en otros entornos. Si pasa un argumento de 8 bits a dicho componente, declarelo
como
Byte lugar de Char en su nuevo
código de Visual Basic.
·
Ensanchamiento El tipo de datos
Char se amplía
a String . Esto significa
que puede convertir Char en String y no
encontrará un error System.OverflowException .
·
Escriba
Caracteres. Agregar el carácter de tipo literal
C a un literal
de cadena de un solo carácter lo fuerza al tipo de datos Char . Char no tiene
carácter de tipo de identificador.
·
Tipo de
marco El
tipo correspondiente en .NET Framework es la estructura System.Char .
VARIABLE BOLEAN:
Tiene valores que solo pueden
ser
True o False . Las palabras clave True y False corresponden
a los dos estados de variables Boolean .
Observaciones
Utilice el tipo de datos
Boolean (Visual Basic) para contener valores de dos estados como verdadero
/ falso, sí / no o encendido / apagado.
El valor predeterminado de
Boolean es False .Boolean valores Boolean no se almacenan como números, y los valores
almacenados no pretenden ser equivalentes a números. Nunca debe escribir código
que dependa de valores numéricos equivalentes para True y False . Siempre que sea posible, debe restringir el uso de
variables Boolean a los valores lógicos para los que están diseñadas.
Conversiones de tipo
Cuando Visual Basic convierte
valores de tipo de datos numéricos a
Boolean , 0 se convierte en False y todos los demás valores se convierten en True . Cuando Visual Basic convierte valores Boolean en tipos
numéricos, False convierte en 0 y True convierte
en -1.
Al convertir entre valores
Boolean y tipos de datos numéricos, tenga en cuenta que los
métodos de conversión de .NET Framework no siempre producen los mismos
resultados que las palabras clave de conversión de Visual Basic. Esto se debe a que la
conversión de Visual Basic conserva el comportamiento compatible con las
versiones anteriores. Para obtener más
información, consulte "El tipo booleano no se convierte al tipo numérico
de forma precisa" en Solución de problemas de tipos de
datos .
Consejos de programación
·
Números
negativos.
Boolean no es un
tipo numérico y no puede representar un valor negativo. En cualquier caso, no debe usar Booleanpara mantener
valores numéricos.
·
Escriba
Caracteres.
Boolean no tiene
carácter de tipo literal o carácter de tipo identificador.
Ejemplo
En el siguiente ejemplo,
runningVB es una variable Boolean , que almacena una configuración simple de sí / no.Dim runningVB As Boolean ' Check to see if program is running on Visual Basic engine.If scriptEngine = "VB" Then runningVB = True End If
VARIABLES STRING:
Mantiene secuencias de puntos de
código de 16 bits sin signo (2 bytes) que varían en valor de 0 a 65535.
Cada punto de código , o código de carácter,
representa un único carácter Unicode. Una cadena puede contener de 0 a aproximadamente dos mil
millones (2 ^ 31) caracteres Unicode.
Observaciones
Use el tipo de datos
String para contener varios caracteres sin la sobrecarga de
administración de arreglos de Char() , una matriz de elementos Char .
El valor predeterminado de
String es Nothing (una referencia nula). Tenga en cuenta que esto no
es lo mismo que la cadena vacía (valor "" ).
Personajes Unicode
Los primeros 128 puntos de código
(0-127) de Unicode corresponden a las letras y símbolos en un teclado estándar
de EE. UU. Estos primeros 128 puntos de código son los mismos que define
el conjunto de caracteres ASCII. Los
segundos 128 puntos de código (128-255) representan caracteres especiales, como
letras del alfabeto en latín, acentos, símbolos de moneda y fracciones. Unicode usa los puntos de código restantes (256-65535) para
una amplia variedad de símbolos. Esto
incluye caracteres textuales, signos diacríticos y símbolos matemáticos y
técnicos en todo el mundo.
Puede utilizar métodos como IsDigit e IsPunctuation en un carácter individual
en una variable
String para determinar su clasificación Unicode.
Requisitos de formato
Debe incluir un literal
String entre comillas ( " " ). Si debe incluir una comilla
como uno de los caracteres en la cadena, use dos comillas contiguas ( "" ). El siguiente ejemplo lo ilustra.Dim j As String = "Joe said ""Hello"" to me." Dim h As String = "Hello" ' The following messages all display the same thing: ' "Joe said "Hello" to me." MsgBox(j) MsgBox("Joe said " & """" & h & """" & " to me.") MsgBox("Joe said """ & h & """ to me.")
Tenga en cuenta que las comillas
contiguas que representan una comilla en la cadena son independientes de las
comillas que comienzan y terminan el literal
String .
Manipulaciones de cuerdas
Una vez que asigna una cadena a una
variable
String , esa cadena es inmutable , lo que significa que no puede cambiar su longitud o
contenido.Cuando modifica una cadena de cualquier manera, Visual Basic crea una
nueva cadena y abandona la cadena anterior. La variable String apunta a
la nueva cadena.
Puede manipular el contenido de una
variable
String usando una variedad de funciones de cadena. El siguiente ejemplo ilustra
la función izquierdaDim S As String = "Database" ' The following statement sets S to a new string containing "Data". S = Microsoft.VisualBasic.Left(S, 4)
Una cadena creada por otro
componente puede rellenarse con espacios iniciales o finales. Si recibe una cadena de este
tipo, puede usar las funcionesTrim , LTrim y RTrim para eliminar estos espacios.
Para obtener más información acerca
de las manipulaciones de cadenas, vea Cadenas .
Consejos de programación
·
Números
negativos. Recuerde que los caracteres mantenidos por
String no tienen
firma y no pueden representar valores negativos. En cualquier caso, no debe usar String para
mantener valores numéricos.
·
Consideraciones
interoperativas. Si está interactuando con componentes no escritos para .NET
Framework, por ejemplo, Automatización u objetos COM, recuerde que los
caracteres de cadena tienen un ancho de datos diferente (8 bits) en otros
entornos. Si está pasando un argumento de
cadena de caracteres de 8 bits a dicho componente, grábelo como
Byte() , una
matriz de elementos de Byte , en lugar de String en su
nuevo código de Visual Basic.
·
Escriba
Caracteres. Agregar el carácter de tipo de identificador
$ a cualquier
identificador lo fuerza al tipo de datos String . String no tiene
un carácter de tipo literal. Sin embargo,
el compilador trata los literales entre comillas ( " " )
como String .
