TypeScript Type Innference (Typbeurteilung)_Javascript-Kenntnisse

TypeScript ist eine von Microsoft entwickelte Obermenge von JavaScript. TypeScript ist mit JavaScript kompatibel und kann JavaScript-Code laden und dann ausführen. Zu den Verbesserungen von TypeScript im Vergleich zu JavaScript gehören: Das Hinzufügen von Kommentaren, damit der Compiler die unterstützten Objekte und Funktionen versteht, ohne den Overhead zu erhöhen, ist eine traditionelle Ausrichtung.

Warum gibt es TypeScript? JavaScript ist lediglich eine Skriptsprache und nicht für die Entwicklung umfangreicher Webanwendungen konzipiert. JavaScript bietet keine Konzepte von Klassen und Modulen, und TypeScript erweitert JavaScript, um diese Funktionen zu implementieren. Zu den Hauptfunktionen von TypeScript gehören:

TypeScript ist eine von Microsoft eingeführte Open-Source-Sprache und verwendet die Apache-Lizenzvereinbarung

TypeScript ist eine Obermenge von JavaScript

TypeScript fügt optionale Typen, Klassen und Module hinzu

TypeScript wird zu lesbarem Standard-JavaScript kompiliert

TypeScript unterstützt die Entwicklung umfangreicher JavaScript-Anwendungen

TypeScript ist für die Entwicklung umfangreicher Anwendungen konzipiert und garantiert die Kompatibilität von kompiliertem JavaScript-Code

TypeScript erweitert die Syntax von JavaScript, sodass vorhandener JavaScript-Code ohne Änderungen direkt mit TypeScript ausgeführt werden kann

Die TypeScript-Dateierweiterung ist ts und der TypeScript-Compiler kompiliert sie in eine js-Datei

TypeScript-Syntax ist dieselbe wie JScript .NET

TypeScript ist leicht zu erlernen und zu verstehen

Grammatische Merkmale

Kurse

Schnittstellen

Module

Anmerkungen eingeben

Typprüfung zur Kompilierungszeit

Pfeilfunktion (ähnlich dem Lambda-Ausdruck von C#)

Der Unterschied zwischen JavaScript und TypeScript

TypeScript ist eine Obermenge von JavaScript, die die Syntax von JavaScript erweitert, sodass vorhandener JavaScript-Code ohne Änderungen mit TypeScript funktionieren kann. TypeScript bietet eine statische Typprüfung zur Kompilierungszeit durch Typanmerkungen. TypeScript kann vorhandenen JavaScript-Code verarbeiten und nur
verwenden

TypeScript-Code wird kompiliert.

In diesem Abschnitt stellen wir die Typinferenz in TypeScript vor. Wir besprechen, wo Typinferenz erforderlich ist und wie sie durchgeführt wird.

Grundlagen

In TypeScript wird Typinferenz verwendet, um Typinformationen an mehreren Stellen bereitzustellen, an denen Typanmerkungen nicht explizit angegeben sind.

var x = 3;

Der Wert der Variablen „x“ wird als Zahl abgeleitet. Diese Schlussfolgerung erfolgt, wenn Variablen oder Mitglieder initialisiert, Parameterstandardwerte festgelegt und Funktionsrückgabetypen bestimmt werden.

Bester öffentlicher Typ

Wenn eine Typinferenz aus mehreren Ausdrücken erforderlich ist, werden die Typen dieser Ausdrücke verwendet, um einen „besten gemeinsamen Typ“ abzuleiten. Zum Beispiel:

var x = [0, 1, null];

Um den Typ von „x“ im Beispiel abzuleiten, müssen wir den Typ jedes Array-Elements berücksichtigen. Hier haben wir die Wahl zwischen zwei Array-Typen: Zahl und Null. Der beste Common-Type-Algorithmus erfordert die Berücksichtigung aller Kandidatentypen und die Auswahl eines Typs, der mit allen Kandidatentypen kompatibel ist. (Der Typ hier kann Array sein)

Da der beste gemeinsame Typ aus den bereitgestellten Kandidatentypen ausgewählt wird, gibt es Fälle, in denen die Kandidatentypen einen gemeinsamen Typ haben, aber kein einzelner Typ der übergeordnete Typ aller Kandidatentypen ist. Zum Beispiel:

Im Idealfall möchten wir vielleicht, dass zoo vom Typ Animal[] abgeleitet wird, aber da keine Objekte im Array ausschließlich vom Typ Animal sind, können wir diese Schlussfolgerung nicht ziehen. Um dieses Problem zu lösen, müssen wir den Typ explizit bereitstellen, wenn der übergeordnete Typ aller Kandidatentypen nicht abgeleitet werden kann.

class Animal {
name:string;
constructor(theName: string) { this.name = theName; }
}
class Snake extends Animal{
constructor(name: string) { super(name); }
}
class Elephant extends Animal{
constructor(name: string) { super(name); }
}
class Rhino extends Animal {
constructor(name: string) { super(name); }
}
var zoo = [new Rhino(), new Elephant(), new Snake()]; // 这里三个成员的类型分别为：Rhino、Elephant、Snake 他们是最佳公共类型的候选类型，Animal是他们的super type(译为父类型) 

Wenn es keinen besten öffentlichen Typ gibt, ist das Ergebnis der Inferenz die Erzeugung eines leeren Objekts, {}. Da dieser Typ keine Mitglieder enthält, führt der Zugriff auf seine Eigenschaften zu einem Fehler. Dieses Ergebnis ermöglicht es uns immer noch, das Objekt typignorierend zu verwenden, aber der Typ des Objekts kann nicht implizit bestimmt werden und gleichzeitig die Typsicherheit gewährleisten.

var zoo: Animal[] = [new Rhino(), new Elephant(), new Snake()]; 

Kontexttyp (Kontext)

In TypeScript existiert die Typinferenz in einigen Fällen auch „sonst“. Dies wird als „Kontextualisierung“ bezeichnet. Eine kontextbezogene Sortierung erfolgt, wenn der Typ eines Ausdrucks implizit in dem Kontext angegeben wird, in dem er auftritt. Zum Beispiel:

上面的代码将会给出一个类型错误，TypeScript的类型检查器使用Window.onmousedown函数的类型来推断右边的函数表达式类型。当它这么做的时候，便能够推断出参数mouseEvent的类型。 如果这个表达式不在可进行上下文归类的位置，参数mouseEvent 需要给定一个any类型，这样就不会出现错误了。

如果需要上下文归类的表达式内容中包含明确的类型信息，则会忽略上下文归类。我们重写上面的例子：

window.onmousedown = function(mouseEvent: any) { 
console.log(mouseEvent.buton); //<- 现在不会报错了 
}; 

参数明确指定类型的函数表达式将会忽略上下文归类。经过这样的处理就不会报错了，因为没有应用到上下文归类。

上下文归类可应用于许多场景。常见的场景包括函数调用的参数、赋值的等号右边表达式、类型确定、对象成员和数组字面量、返回值语句。上下文类型也作为最佳公共类型的候选类型。例如：

function createZoo(): Animal[] {
return [new Rhino(), new Elephant(), new Snake()];
} 

在这个例子中，最佳公共类型有四个候选类型：Animal,Rhino,Elephant,和Snake。其中，Animal可以作为最佳公共类型。

形式有点像数学中的求最小公倍数...