JS++ | Variables y tipos de datos

En este tutorial, introduciremos variables en JS++. Comencemos con un ejemplo. Cree una nueva carpeta y asígnele el nombre «Variables». Luego cree un nuevo archivo y asígnele el nombre «Variables.jspp». Escribe el siguiente código:

external $;
    
string firstString = "This is a string.";
int firstInt = 1;
double firstDouble = 1.1;
bool firstBool = true;

$("#string_content").text(firstString);
$("#int_content").text(firstInt);
$("#double_content").text(firstDouble);
$("#bool_content").text(firstBool);

Guarde Variables.jspp en su carpeta Variables. Luego crea un segundo archivo llamado «Variables.html» y escribe lo siguiente:

<!DOCTYPE html>
<title>Variables program</title>
<body>

<p id="string_content"></p>
<p id="int_content"></p>
<p id="double_content"></p>
<p id="bool_content"></p>

<script src="http://code.jquery.com/jquery-1.12.4.min.js"></script>
<script src="Variables.jspp.js"></script>

</body>
</html>

Guarde Variables.html en su carpeta Variables. Compile Variables.jspp y luego abra Variables.html en un navegador. Si todo funcionó, su documento debería mostrar los valores de las cuatro variables en Variables.jspp.

Variables y tipos

Cuando declaramos nuestras variables en Variables.jspp, le dimos a cada una de ellas un tipo: string, int, doubley bool. El hecho de que pueda usar tales variables escritas es una característica importante de JS++ y representa una diferencia clave con JavaScript. En JavaScript, declara una variable con la varpalabra clave y dichas variables no se escriben. La misma variable puede contener primero una string, por ejemplo, luego un número y luego un valor booleano. En JS++, por el contrario, cuando declaras que una variable pertenece a un tipo dado, le dices al compilador que la variable contendrá solo datos de ese tipo en particular. Entonces, por ejemplo, stringlas variables contienen secuencias de caracteres, intlas variables contienen números enteros, doublelas variables contienen números de punto flotante,boollas variables contienen valores lógicos (verdadero y falso), y así sucesivamente.

¿Qué sucede si su programa asigna accidentalmente el tipo de valor incorrecto a una variable escrita? Esto da como resultado una falla de compilación, no un error de tiempo de ejecución. Por ejemplo, mire de nuevo la línea:
```
bool firstBool = true;
```
Supongamos que cambia esto a:
```
bool firstBool = "This is a string, not a bool.";
```
Su programa ya no se compilará. Si lo intenta, el compilador se quejará de que no puede convertir un stringarchivo bool.

¿Por qué es mejor que un problema de este tipo provoque un error de compilación, en lugar de un error de tiempo de ejecución ? La respuesta es que hace que el error sea más fácil de detectar y corregir en una etapa anterior de desarrollo. Se vuelve menos probable que el error permanezca oculto en alguna parte compleja de su código, solo para emerger en una etapa crucial después de que su programa se haya puesto en marcha. Esto puede ser especialmente útil en grandes proyectos y equipos. En este sentido, JS++ ofrece una ventaja sobre JavaScript, que no revela errores de este tipo en tiempo de compilación, ya que no utiliza variables tipeadas.

Nota: JS ++ no lo obliga a usar variables escritas. Todavía puede usar variables sin tipo si lo desea, tal como lo haría en JavaScript; más sobre esto en el Capítulo 9. Sin embargo, cuando usa variables con tipo, se garantiza que sus valores serán del tipo correcto si el programa compila.

Los cuatro tipos que usamos en Variables.jspp – string, int, doubley bool– se encuentran entre los tipos de datos primitivos de JS++.
Puede encontrar una lista completa de ellos aquí: Tipos de datos primitivos de JS++

Con respecto a los tipos de datos primitivos numéricos, vale la pena señalar que JS++ contiene no solo inty double sino también byte, short, unsigned inty unsigned short(los tipos sin signo solo pueden contener números positivos). Estos tipos varían tanto en la cantidad de memoria que utilizan como en el rango de números que pueden contener.

Con respecto a los tipos de datos textuales, JS ++ contiene chartambién string: en el caso de que sepa que una variable debe contener un solo carácter individual, sería apropiado declarar su variable como un carácter. En términos más generales, la amplia variedad de tipos de datos primitivos en JS ++ le brinda una gran flexibilidad para seleccionar el tipo de variable más apropiado para sus propósitos.

Los tipos de datos de JS++ no se limitan a sus primitivos. Por ejemplo, también hay tipos de funciones, tipos de arrays, tipos de devolución de llamada y tipos definidos por el usuario. Examinaremos todo esto en tutoriales posteriores. En este tutorial, sin embargo, el enfoque permanecerá en los tipos primitivos.
Declaración e inicialización de variables

En Variables.jspp, declaramos las cuatro variables en sentencias separadas, pero inicializamos cada variable en el mismo estado en que la declaramos. Sin embargo, no es necesario introducir variables como esa. Por ejemplo, puede declarar una variable en una declaración y luego inicializarla más tarde:
```
bool firstBool;
// ...
firstBool = true;
```
También puede declarar varias variables del mismo tipo en una sola declaración:
```
char firstChar, secondChar, thirdChar;
```
Y puede inicializar varias variables del mismo tipo cuando las declara:
```
char firstChar = `a`, secondChar = `b`, thirdChar = `c`;
```
¿Qué sucede si se accede a una variable después de que se haya declarado pero antes de que se haya inicializado? Para ver, cambiemos el código de Variables.jspp:
```
external $;
    
string firstString;
int firstInt;
double firstDouble;
bool firstBool;

$("#string_content").text(firstString);
$("#int_content").text(firstInt);
$("#double_content").text(firstDouble);
$("#bool_content").text(firstBool);
```
Si compila este código y luego abre Variables.html en un navegador, verá que cada una de las variables se establece en un valor predeterminado: firstStringse establece en «» (string vacía) firstInty firstDoublese establece en 0, mientras que firstBoolse establece a falso Puede ver una lista completa de los valores predeterminados para los tipos de datos primitivos de JS++ a través del enlace anterior.
Variables y alcance

El alcance de una variable es la parte del programa donde esa variable es visible (accesible por su nombre). En JS++, el alcance de una variable está determinado por el bloque de código (una sección de código dentro de un par de llaves) donde se declara: la variable se vuelve visible inmediatamente después de la declaración desde cualquier lugar posterior en el mismo bloque. Por ejemplo, considere:
```
{
    string firstString;
    firstString = "Another string.";
}
```
Aquí no hay problema, ya que el valor de firstStringse modifica después de firstStringhaber sido declarado pero dentro del mismo bloque. Por el contrario, considere:
```
{
    string firstString;
}

firstString = "Another string.";
```
Ahora hay un problema: este código no se compilará porque firstStringno se ve fuera del bloque donde se declara.

¿Cómo funciona el alcance cuando una variable se declara fuera de cada bloque de código explícito (es decir, cada bloque definido por un par de llaves)? En este caso, la variable es visible desde cualquier parte del archivo después de haberla declarado. Esto también se aplica a los casos en los que un archivo no contiene ningún bloque de código explícito, como en Variables.jspp.

Publicación traducida automáticamente

Artículo escrito por CharlesKozenyPelling y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Variables y tipos

Declaración e inicialización de variables

Variables y alcance

Deja una respuesta Cancelar la respuesta