Installation de TypeScript
npm install -g typescript
// 查看版本
$ tsc -v
Version 3.2.2
//将.ts文件转为.js
tsc test.ts
使用 node 命令来执行 test.js 文件
node test.js
Mots-clés réservés TypeScript
déclaration break
L'instruction break a les deux utilisations suivantes:
Lorsque l'instruction break apparaît dans une boucle, la boucle se termine immédiatement.
Il peut être utilisé pour terminer un cas dans une instruction switch.
Si vous utilisez des boucles imbriquées (c'est-à-dire qu'une boucle est imbriquée dans une autre boucle), l'instruction break arrêtera l'exécution de la boucle la plus interne, puis commencera à exécuter la ligne de code suivante après le bloc.
break;
Cas
instruction switch ... case
Une instruction switch vous permet de tester lorsqu'une variable est égale à plusieurs valeurs. Chaque valeur est appelée un cas, et la variable testée sera vérifiée pour chaque cas de commutateur.
La syntaxe de l'instruction switch:
switch(expression){
case constant-expression :
statement(s);
break; /* 可选的 */
case constant-expression :
statement(s);
break; /* 可选的 */
/* 您可以有任意数量的 case 语句 */
default : /* 可选的 */
statement(s);
}
L'instruction switch doit suivre les règles suivantes:
L'expression dans l'instruction switch est une expression constante et doit être un type entier ou énuméré.
Il peut y avoir n'importe quel nombre d'instructions case dans un commutateur. Chaque cas est suivi d'une valeur à comparer et d'un signe deux-points.
L'expression constante du cas doit avoir le même type de données que la variable dans le commutateur, et il doit s'agir d'une constante ou d'un littéral.
Lorsque la variable testée est égale à la constante dans le cas, l'instruction qui suit le cas sera exécutée jusqu'à ce que l'instruction break soit rencontrée.
Lorsqu'une instruction break est rencontrée, le commutateur est terminé et le flux de contrôle passe à la ligne suivante après l'instruction switch.
Tous les cas ne doivent pas nécessairement inclure une pause. Si l'instruction case ne contient pas break, le flux de contrôle continuera avec les cas suivants jusqu'à ce qu'une rupture soit rencontrée.
Une instruction switch peut avoir une casse par défaut facultative, qui apparaît à la fin du switch. Le cas par défaut peut être utilisé pour exécuter une tâche lorsque aucun des cas ci-dessus n'est vrai. L'instruction break dans le cas par défaut n'est pas nécessaire.
statique
Les membres de données (attributs et méthodes) utilisés pour définir la classe sont statiques, et les membres statiques peuvent être appelés directement par le nom de la classe.
class StaticMem {
static num:number;
static disp():void {
console.log("num 值为 "+ StaticMem.num)
}
}
StaticMem.num = 12 // 初始化静态变量
StaticMem.disp() // 调用静态方法
opérateur instanceof
L' opérateur instanceof est utilisé pour déterminer si l'objet est du type spécifié et renvoie true s'il l'est, sinon il retourne false.
class Person{
}
var obj = new Person()
var isPerson = obj instanceof Person;
console.log("obj 对象是 Person 类实例化来的吗？ " + isPerson);
Modificateur de contrôle d'accès
Dans TypeScript, vous pouvez utiliser des symboles de contrôle d'accès pour protéger l'accès aux classes, variables, méthodes et constructeurs. TypeScript prend en charge 3 droits d'accès différents.
public (par défaut): Public, accessible de n'importe où.
protected : protected, accessible par lui-même et ses sous-classes et classes parentes.
private: Privé, accessible uniquement par la classe où il est défini.
L'exemple suivant définit deux variables str1 et str2, str1 est public et str2 est privé. Après l'instanciation, vous pouvez accéder à str1. Si vous souhaitez accéder à str2, une erreur de compilation se produit.
class Encapsulate {
str1:string = "hello"
private str2:string = "world"
}
var obj = new Encapsulate()
console.log(obj.str1) // 可访问
console.log(obj.str2) // 编译错误， str2 是私有的
implémente des classes et des interfaces
interface ILoan {
//interface 用來定义接口
interest:number
}
class AgriLoan implements ILoan {
interest:number
rebate:number
constructor(interest:number,rebate:number) {
this.interest = interest
this.rebate = rebate
}
}
var obj = new AgriLoan(10,1)
console.log("利润为 : "+obj.interest+"，抽成为 : "+obj.rebate )
espace de noms
Utilisation de l'espace de noms dans TypeScript espace de noms Pour définir, le format de la syntaxe est le suivant:
namespace SomeNameSpaceName {
export interface ISomeInterfaceName {
}
export class SomeClassName {
}
}
Ce qui précède définit un espace de noms SomeNameSpaceName, si nous devons appeler la classe et l'interface dans SomeNameSpaceName en externe, nous devons ajouter la classe et l'interface exportationMots clés.
Le format de syntaxe pour appeler dans un autre espace de noms est:
SomeNameSpaceName.SomeClassName;
Si un espace de noms se trouve dans un fichier TypeScript distinct, il doit être entre guillemets triples ///, la syntaxe est la suivante:
/// <reference path = "SomeFileName.ts" />
Module TypeScript
Exportation de module à l'aide de mots-clés exportation Mots clés, le format de la syntaxe est le suivant:
// 文件名 : SomeInterface.ts
export interface SomeInterface {
// 代码部分
}
Pour utiliser ce module dans un autre fichier, vous devez utiliser importer Mots clés à importer:
import someInterfaceRef = require("./SomeInterface");
Reportez-vous à https://www.runoob.com/typescript/ts-install.html