TypeScript Type Innference (jugement de type)_compétences javascript

TypeScript est un sur-ensemble de JavaScript développé par Microsoft. TypeScript est compatible avec JavaScript et peut charger du code JavaScript puis l'exécuter. Les améliorations de TypeScript par rapport à JavaScript incluent : l'ajout de commentaires pour permettre au compilateur de comprendre les objets et les fonctions pris en charge. Le compilateur supprimera les commentaires sans augmenter la surcharge ;

Pourquoi y a-t-il TypeScript

JavaScript n'est qu'un langage de script et n'est pas conçu pour développer des applications Web à grande échelle. JavaScript ne fournit pas les concepts de classes et de modules, et TypeScript étend JavaScript pour implémenter ces fonctionnalités. Les principales fonctionnalités de TypeScript incluent :

TypeScript est un langage open source lancé par Microsoft et utilise le contrat de licence Apache

TypeScript est un sur-ensemble de JavaScript

TypeScript ajoute des types, classes et modules facultatifs

TypeScript se compile en JavaScript standard lisible

TypeScript prend en charge le développement d'applications JavaScript à grande échelle

TypeScript est conçu pour développer des applications à grande échelle et garantit la compatibilité du code JavaScript compilé

TypeScript étend la syntaxe de JavaScript, de sorte que le code JavaScript existant peut s'exécuter directement avec TypeScript sans modification

L'extension du fichier TypeScript est ts, et le compilateur TypeScript le compilera dans un fichier js

La syntaxe TypeScript est la même que celle de JScript .NET

TypeScript est facile à apprendre et à comprendre

Caractéristiques grammaticales

Cours

Interfaces

Modules

Tapez les annotations

Vérification du type au moment de la compilation

Fonction flèche (similaire à l'expression Lambda de C#)

La différence entre JavaScript et TypeScript

TypeScript est un sur-ensemble de JavaScript qui étend la syntaxe de JavaScript afin que le code JavaScript existant puisse fonctionner avec TypeScript sans aucune modification. TypeScript fournit une vérification de type statique au moment de la compilation via des annotations de type. TypeScript peut traiter le code JavaScript existant et utiliser uniquement

Le code TypeScript est compilé.

Dans cette section, nous présenterons l'inférence de type dans TypeScript. Nous verrons où l'inférence de type est nécessaire et comment la faire.

Bases

Dans TypeScript, l'inférence de type sera utilisée pour fournir des informations de type à plusieurs endroits où les annotations de type ne sont pas explicitement spécifiées.

var x = 3

La valeur de la variable "x" est considérée comme étant un nombre. Cette inférence se produit lorsque les variables ou les membres sont initialisés, les valeurs par défaut des paramètres sont définies et les types de retour de fonction sont déterminés.

Meilleur type public

Lorsque l'inférence de type est requise à partir de plusieurs expressions, les types de ces expressions seront utilisés pour déduire un « meilleur type commun ». Par exemple :

var x = [0, 1, nul];

Pour déduire le type de "x" dans l'exemple, nous devons considérer le type de chaque élément du tableau. Ici, nous avons le choix entre deux types de tableaux : nombre et nul. Le meilleur algorithme de type commun nécessite que tous les types candidats soient pris en compte et qu'un type compatible avec tous les types candidats soit sélectionné. (Le type ici peut être Array)

Étant donné que le meilleur type commun est sélectionné parmi les types candidats fournis, il existe des cas où les types candidats partagent un type commun, mais aucun type n'est le type parent de tous les types candidats. Par exemple :

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(译为父类型) 

Idéalement, nous pourrions vouloir que zoo soit déduit qu'il est de type Animal[], mais comme aucun objet du tableau n'est strictement de type Animal, nous ne pouvons pas faire cette inférence. Pour résoudre ce problème, nous devons fournir le type explicitement lorsque le type parent de tous les types candidats ne peut pas être déduit.

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

Lorsqu'il n'y a pas de meilleur type public, le résultat de l'inférence est de produire un objet vide, {}. Étant donné que ce type ne contient aucun membre, l’accès à l’une de ses propriétés entraînera une erreur. Ce résultat nous permet toujours d'utiliser l'objet en ignorant le type, mais le type de l'objet ne peut pas être implicitement déterminé tout en garantissant la sécurité du type.

Type de contexte (Contexte)

Dans TypeScript, l'inférence de type existe également "sinon" dans certains cas. C'est ce qu'on appelle la « catégorisation contextuelle ». Le classement contextuel se produit lorsque le type d'une expression est implicitement spécifié dans le contexte dans lequel elle apparaît. Par exemple :

window.onmousedown = function(mouseEvent) { 
console.log(mouseEvent.buton); //<- 编译时抛出错误 
}; 

上面的代码将会给出一个类型错误，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可以作为最佳公共类型。

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