TypeScript - Variablen

Eine Variable ist per Definition „ein benannter Bereich im Speicher“, in dem Werte gespeichert werden. Mit anderen Worten, es fungiert als Container für Werte in einem Programm. TypeScript-Variablen müssen den JavaScript-Namensregeln folgen -

Variablennamen können Alphabete und numerische Ziffern enthalten.
Sie dürfen keine Leerzeichen und Sonderzeichen enthalten, außer dem Unterstrich (_) und dem Dollarzeichen ($).
Variablennamen dürfen nicht mit einer Ziffer beginnen.

Eine Variable muss deklariert werden, bevor sie verwendet wird. Verwenden Sie dievar Schlüsselwort zum Deklarieren von Variablen.

Variablendeklaration in TypeScript

Die Typensyntax zum Deklarieren einer Variablen in TypeScript besteht darin, nach dem Variablennamen einen Doppelpunkt (:) gefolgt von seinem Typ einzufügen. Genau wie in JavaScript verwenden wir dievar Schlüsselwort zum Deklarieren einer Variablen.

Wenn Sie eine Variable deklarieren, haben Sie vier Möglichkeiten:

Deklarieren Sie Typ und Wert in einer Anweisung.

Deklarieren Sie den Typ, aber keinen Wert. In diesem Fall wird die Variable auf undefiniert gesetzt.

Deklarieren Sie den Wert, aber keinen Typ. Der Variablentyp wird auf den Datentyp des zugewiesenen Werts gesetzt.

Deklarieren Sie weder Wert noch Typ. In diesem Fall ist der Datentyp der Variablen beliebig und wird auf undefiniert initialisiert.

Die folgende Tabelle zeigt die gültige Syntax für die Variablendeklaration wie oben beschrieben.

S.No.	Syntax und Beschreibung der Variablendeklaration
1.	var name:string = ”mary” Die Variable speichert einen Wert vom Typ string
2.	var name:string; Die Variable ist eine Zeichenfolgenvariable. Der Wert der Variablen ist standardmäßig auf undefiniert gesetzt
3.	var name = ”mary” Der Typ der Variablen wird aus dem Datentyp des Werts abgeleitet. Hier ist die Variable vom Typ string
4.	var name; Der Datentyp der Variablen ist beliebig. Sein Wert ist standardmäßig auf undefiniert gesetzt.

Beispiel: Variablen in 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)

Beim Kompilieren wird folgender JavaScript-Code generiert.

//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);

Die Ausgabe des obigen Programms ist unten angegeben -

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

Der TypeScript-Compiler generiert Fehler, wenn wir versuchen, einer Variablen, die nicht vom gleichen Typ ist, einen Wert zuzuweisen. Daher folgt TypeScript der starken Typisierung. Die Syntax für die starke Eingabe stellt sicher, dass die auf beiden Seiten des Zuweisungsoperators (=) angegebenen Typen identisch sind. Aus diesem Grund führt der folgende Code zu einem Kompilierungsfehler:

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

Typzusicherung in TypeScript

Mit TypeScript können Sie eine Variable von einem Typ in einen anderen ändern. TypeScript bezeichnet diesen Prozess als Type Assertion . Die Syntax besteht darin, den Zieltyp zwischen <> Symbole zu setzen und ihn vor die Variable oder den Ausdruck zu setzen. Das folgende Beispiel erklärt dieses Konzept -

Beispiel

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

Wenn Sie den Mauszeiger über die Typzusicherungsanweisung in Visual Studio Code bewegen, wird die Änderung des Datentyps der Variablen angezeigt. Grundsätzlich ermöglicht es die Behauptung von Typ S zu T erfolgreich, wenn entweder S ein Subtyp von T oder T ein Subtyp von S ist.

Der Grund, warum es nicht als "Typ-Casting" bezeichnet wird, ist, dass das Casting im Allgemeinen eine Art Laufzeitunterstützung impliziert, während "Typ-Zusicherungen" lediglich ein Konstrukt zur Kompilierungszeit sind und eine Möglichkeit für Sie darstellen, dem Compiler Hinweise zu geben, wie Ihr Code aussehen soll analysiert werden.

Beim Kompilieren wird folgender JavaScript-Code generiert.

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

Es wird die folgende Ausgabe erzeugt -

string

Abgeleitete Eingabe in TypeScript

Da Typescript stark typisiert ist, ist diese Funktion optional. TypeScript fördert auch die dynamische Typisierung von Variablen. Dies bedeutet, dass TypeScript das Deklarieren einer Variablen ohne Typ fördert. In solchen Fällen bestimmt der Compiler den Typ der Variablen auf der Grundlage des ihr zugewiesenen Werts. TypeScript findet die erste Verwendung der Variablen im Code, bestimmt den Typ, auf den sie ursprünglich festgelegt wurde, und nimmt dann im Rest Ihres Codeblocks denselben Typ für diese Variable an.

Das gleiche wird im folgenden Code-Snippet erklärt -

Beispiel: Abgeleitete Eingabe

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

Im obigen Code-Snippet -

Der Code deklariert eine Variable und setzt ihren Wert auf 2. Beachten Sie, dass die Variablendeklaration den Datentyp nicht angibt. Daher verwendet das Programm eine abgeleitete Typisierung, um den Datentyp der Variablen zu bestimmen, dh es weist den Typ des ersten Werts zu, auf den die Variable gesetzt ist. In diesem Fall,num wird auf die Typennummer gesetzt.
Wenn der Code versucht, den Wert der Variablen auf string zu setzen. Der Compiler gibt einen Fehler aus, da der Variablentyp bereits auf Nummer gesetzt ist.

Es wird die folgende Ausgabe erzeugt -

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

TypeScript-Variablenbereich

Der Bereich einer Variablen gibt an, wo die Variable definiert ist. Die Verfügbarkeit einer Variablen innerhalb eines Programms wird durch ihren Umfang bestimmt. TypeScript-Variablen können folgende Bereiche haben:

Global Scope- Globale Variablen werden außerhalb der Programmierkonstrukte deklariert. Auf diese Variablen kann von überall in Ihrem Code zugegriffen werden.
Class Scope - Diese Variablen werden auch aufgerufen fields. Felder oder Klassenvariablen werden innerhalb der Klasse, jedoch außerhalb der Methoden deklariert. Auf diese Variablen kann mit dem Objekt der Klasse zugegriffen werden. Felder können auch statisch sein. Auf statische Felder kann über den Klassennamen zugegriffen werden.
Local Scope - Lokale Variablen werden, wie der Name schon sagt, in den Konstrukten wie Methoden, Schleifen usw. deklariert. Auf lokale Variablen kann nur innerhalb des Konstrukts zugegriffen werden, in dem sie deklariert sind.

Das folgende Beispiel zeigt variable Bereiche in TypeScript.

Beispiel: Variabler Bereich

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)

Beim Transpilieren wird der folgende JavaScript-Code generiert:

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);

Es wird die folgende Ausgabe erzeugt -

Global num: 12
10
Global num: 13

Wenn Sie versuchen, auf die lokale Variable außerhalb der Methode zuzugreifen, führt dies zu einem Kompilierungsfehler.

error TS2095: Could not find symbol 'local_num'.