TypeScript - Variables

Una variable, por definición, es "un espacio con nombre en la memoria" que almacena valores. En otras palabras, actúa como un contenedor de valores en un programa. Las variables de TypeScript deben seguir las reglas de nomenclatura de JavaScript:

• Los nombres de las variables pueden contener alfabetos y dígitos numéricos.

• No pueden contener espacios ni caracteres especiales, excepto el subrayado (_) y el signo de dólar ($).

• Los nombres de las variables no pueden comenzar con un dígito.

Una variable debe declararse antes de ser utilizada. Utilizar elvar palabra clave para declarar variables.

Declaración de variable en TypeScript

La sintaxis de tipo para declarar una variable en TypeScript es incluir dos puntos (:) después del nombre de la variable, seguido de su tipo. Al igual que en JavaScript, usamos elvar palabra clave para declarar una variable.

Cuando declaras una variable, tienes cuatro opciones:

• Declare su tipo y valor en una declaración.

• Declare su tipo pero no su valor. En este caso, la variable se establecerá como indefinida.

• Declare su valor pero no su tipo. El tipo de variable se establecerá en el tipo de datos del valor asignado.

• No declare ni el valor ni el tipo. En este caso, el tipo de datos de la variable será cualquiera y se inicializará como indefinido.

La siguiente tabla ilustra la sintaxis válida para la declaración de variables como se discutió anteriormente:

S.No.	Sintaxis y descripción de declaración de variable
1.	var name:string = ”mary” La variable almacena un valor de tipo cadena
2.	var name:string; La variable es una variable de cadena. El valor de la variable se establece en indefinido de forma predeterminada
3.	var name = ”mary” El tipo de variable se infiere del tipo de datos del valor. Aquí, la variable es del tipo cadena
4.	var name; El tipo de datos de la variable es cualquiera. Su valor se establece en indefinido de forma predeterminada.

Ejemplo: variables en TypeScript

var name:string = "John"; 
var score1:number = 50;
var score2:number = 42.50
var sum = score1 + score2 
console.log("name"+name) 
console.log("first score: "+score1) 
console.log("second score: "+score2) 
console.log("sum of the scores: "+sum)

Al compilar, generará el siguiente código JavaScript.

//Generated by typescript 1.8.10
var name = "John";
var score1 = 50;
var score2 = 42.50;
var sum = score1 + score2;
console.log("name" + name);
console.log("first score: " + score1);
console.log("second score : " + score2);
console.log("sum of the scores: " + sum);

La salida del programa anterior se da a continuación:

name:John 
first score:50 
second score:42.50 
sum of the scores:92.50

El compilador de TypeScript generará errores, si intentamos asignar un valor a una variable que no es del mismo tipo. Por lo tanto, TypeScript sigue Strong Typing. La sintaxis de tipado fuerte asegura que los tipos especificados en cada lado del operador de asignación (=) sean los mismos. Es por eso que el siguiente código dará como resultado un error de compilación:

var num:number = "hello"     // will result in a compilation error

Aserción de tipo en TypeScript

TypeScript permite cambiar una variable de un tipo a otro. TypeScript se refiere a este proceso como Type Assertion . La sintaxis consiste en poner el tipo de destino entre los símbolos <> y colocarlo delante de la variable o expresión. El siguiente ejemplo explica este concepto:

Ejemplo

var str = '1' 
var str2:number = <number> <any> str   //str is now of type number 
console.log(typeof(str2))

Si pasa el puntero del mouse sobre la declaración de aserción de tipo en Visual Studio Code, muestra el cambio en el tipo de datos de la variable. Básicamente, permite que la afirmación del tipo S al T tenga éxito si S es un subtipo de T o T es un subtipo de S.

La razón por la que no se llama "conversión de tipos" es que la conversión generalmente implica algún tipo de soporte en tiempo de ejecución, mientras que las "afirmaciones de tipo" son puramente una construcción en tiempo de compilación y una forma de proporcionar sugerencias al compilador sobre cómo desea que su código funcione. ser analizado.

Al compilar, generará el siguiente código JavaScript.

"use strict";
var str = '1';
var str2 = str; //str is now of type number 
console.log(typeof (str2));

Producirá la siguiente salida:

string

Escritura inferida en TypeScript

Dado que Typecript está fuertemente tipado, esta característica es opcional. TypeScript también fomenta la escritura dinámica de variables. Esto significa que TypeScript anima a declarar una variable sin un tipo. En tales casos, el compilador determinará el tipo de variable en función del valor que se le asigne. TypeScript encontrará el primer uso de la variable dentro del código, determinará el tipo al que se ha establecido inicialmente y luego asumirá el mismo tipo para esta variable en el resto del bloque de código.

Lo mismo se explica en el siguiente fragmento de código:

Ejemplo: escritura inferida

var num = 2;    // data type inferred as  number 
console.log("value of num "+num); 
num = "12";
console.log(num);

En el fragmento de código anterior:

• El código declara una variable y establece su valor en 2. Tenga en cuenta que la declaración de variable no especifica el tipo de datos. Por lo tanto, el programa utiliza la escritura inferida para determinar el tipo de datos de la variable, es decir, asigna el tipo del primer valor al que se establece la variable. En este caso,num se establece en el número de tipo.

• Cuando el código intenta establecer el valor de la variable en cadena. El compilador arroja un error porque el tipo de variable ya está establecido en número.

Producirá la siguiente salida:

error TS2011: Cannot convert 'string' to 'number'.

Alcance variable de TypeScript

El alcance de una variable especifica dónde se define la variable. La disponibilidad de una variable dentro de un programa está determinada por su alcance. Las variables de TypeScript pueden tener los siguientes ámbitos:

• Global Scope- Las variables globales se declaran fuera de las construcciones de programación. Se puede acceder a estas variables desde cualquier lugar dentro de su código.

• Class Scope - Estas variables también se denominan fields. Los campos o variables de clase se declaran dentro de la clase pero fuera de los métodos. Se puede acceder a estas variables utilizando el objeto de la clase. Los campos también pueden ser estáticos. Se puede acceder a los campos estáticos utilizando el nombre de la clase.

• Local Scope - Las variables locales, como su nombre indica, se declaran dentro de las construcciones como métodos, bucles, etc. Las variables locales son accesibles solo dentro de la construcción donde se declaran.

El siguiente ejemplo ilustra los ámbitos de las variables en TypeScript.

Ejemplo: alcance variable

var global_num = 12          //global variable 
class Numbers { 
   num_val = 13;             //class variable 
   static sval = 10;         //static field 
   
   storeNum():void { 
      var local_num = 14;    //local variable 
   } 
} 
console.log("Global num: "+global_num)  
console.log(Numbers.sval)   //static variable  
var obj = new Numbers(); 
console.log("Global num: "+obj.num_val)

Al transpilar, se genera el siguiente código JavaScript:

var global_num = 12;              //global variable 
var Numbers = (function () {
   function Numbers() {
      this.num_val = 13;          //class variable 
   }
   Numbers.prototype.storeNum = function () {
      var local_num = 14;        //local variable 
   };
   Numbers.sval = 10;            //static field 
   return Numbers;
}());

console.log("Global num: " + global_num);
console.log(Numbers.sval);       //static variable  

var obj = new Numbers();
console.log("Global num: " + obj.num_val);

Producirá la siguiente salida:

Global num: 12
10
Global num: 13

Si intenta acceder a la variable local fuera del método, se produce un error de compilación.

error TS2095: Could not find symbol 'local_num'.