typescripts学习

可选与默认参数

1. function buildName(firstName: string, lastName?: string) { //lastName为可选参数
2. if (lastName)
3. return firstName + " " + lastName;
4. else
5. return firstName;
6. }
7. var result1 = buildName("Bob"); //正确调用 Bob
8. var result2 = buildName("Bob", "Adams"); //正确调用 Bob Adams

默认参数：在参数名后直接给定一个值，如果这个值没有被传入，那么将会被赋值为默认值。如下代码：

1. function buildName(firstName: string, lastName = "Smith") {
2. return firstName + " " + lastName;
3. }
4. var result1 = buildName("Bob"); //没有传入第二个参数，则被赋值为默认的smith,结果为:Bob Smith
5. var result2 = buildName("Bob", "Adams"); //结果为:Bob Adams

注：可选参数和默认参数必须在参数列表的最后。

继承

1. class B extends A {
2. // 类B中的成员
3. }

　　如果我们要在子类中调用基类中的属性与方法就要使用super关键字。如下代码：

1. class Animal { //定义基类
2. name:string;
3. constructor(theName: string) { this.name = theName; }
4. move(meters: number) {
5. document.write(this.name + " moved " + meters + "m.");
6. }
7. }
8. class Snake extends Animal { //继承基类
9. constructor(name: string) {
10. super(name); //调用基本类的构造函数
11. }
12. move() { //重写了基类的方法
13. document.write("Slithering...<br>");
14. super.move(5); //调用基类的方法
15. }
16. }
17. var sam = new Snake("Python"); //声明Snake类
18. sam.move();

接口声明

1. interface LabelledValue { //定义接口
2. label: string; //定义属性
3. }

1. interface LabelledValue { //定义接口
2. label: string;
3. }
4. function printLabel(labelledObj: LabelledValue) { //定义函数printLabel,其参数类型为接口类型
5. document.write(labelledObj.label);
6. }
7. var myObj = {size: 10, label: "Size 10 Object"}; //定义含有接口中属性的对象
8. printLabel(myObj); //调用函数

可选属性

1. interface SquareConfig { //定义了两个可选属性
2. color?: string;
3. width?: number;
4. }
5. function createSquare(config: SquareConfig): {color: string; area: number} {//定义函数
6. var newSquare = {color: "white", area: 100};
7. if (config.color) {
8. newSquare.color = config.color;
9. }
10. if (config.width) {
11. newSquare.area = config.width * config.width;
12. }
13. return newSquare;
14. }
15. var mySquare = createSquare({color: "black"}); //调用函数，
16. document.write(mySquare.color); //结果为： black

　　大家可能会问既然是可选属性，可有可无的，那么为什么还要定义呢?对比起完全不定义，定义可选属性主要是：如果存在属性，能约束类型，而这也是十分关键的。

方法类型

1. interface SearchFunc {
2. (source: string, subString: string): boolean; //定义一个匿名方法
3. }
4. var mySearch: SearchFunc;
5. mySearch = function(source: string, subString: string) { //实现接口
6. var result = source.search(subString); //调用系统方法search查找字符串的位置
7. if (result == -1) {
8. return false;
9. }
10. else {
11. return true;
12. }
13. }

　　上面代码中，我们定义了一个接口，接口内约束了一个方法的签名，这个方法有两个字符串参数，返回布尔值。在第二段代码中我们声明了这个接口的实现。编译器仅仅检查类型是否正确(参数类型、返回值类型)，因此参数的名字我们可以换成别的。

数组类型

1. interface StringArray { //定义数组接口
2. [index: number]: string; //每个数组元素的类型
3. }
4. var myArray: StringArray;
5. myArray = ["Bob", "Fred"];

　　在接口的定义里面，索引器的名字一般为 index(当然也可以改成别的，但一般情况下都是保持名字为 index)。索引器的类型只能为 number 或者 string。

1. interface Array{
2. [myindex: number]: number;
3. }
4. interface Dictionary{
5. [index: string]: any;
6. }

Class类型

1. interface IPrint{
2. print();
3. }
4. class A implements IPrint { //实现接口
5. print(){ //实现接口中的方法
6. document.write("实现接口");
7. }
8. }
9. var B=new A();
10. B.print();

接口继承

1. interface Shape { //定义接口Shape
2. color: string;
3. }
4. interface Square extends Shape { //继承接口Shape
5. sideLength: number;
6. }

一个interface可以同时继承多个interface，实现多个接口成员的合并。用逗号隔开要继承的接口。

1. interface Shape {
2. color: string;
3. }
4. interface PenStroke {
5. penWidth: number;
6. }
7. interface Square extends Shape, PenStroke {
8. sideLength: number;
9. }

模块的声明

1. interface StringValidator { //定义验证接口
2. isAcceptable(s: string): boolean;
3. }
4. var lettersRegexp = /^[A-Za-z]+$/;
5. var numberRegexp = /^[0-9]+$/;
6. class LettersOnlyValidator implements StringValidator {　//实现接口
7. isAcceptable(s: string) {
8. return lettersRegexp.test(s);
9. }
10. }
11. class ZipCodeValidator implements StringValidator { //实现接口
12. isAcceptable(s: string) {
13. return s.length === 5 && numberRegexp.test(s);
14. }
15. }
16. var strings = [‘Hello‘, ‘98052‘, ‘101‘];
17. var validators: { [s: string]: StringValidator; } = {};
18. validators[‘ZIP code‘] = new ZipCodeValidator(); //实例化类
19. validators[‘Letters only‘] = new LettersOnlyValidator(); //实例化类
20. for(var i=0;i<strings.length;i++){
21. for (var name in validators) {
22. document.write(‘"‘ + strings[i] + ‘" ‘ + (validators[name].isAcceptable(strings[i]) ? ‘ matches ‘ : ‘ does not match ‘) + name+"<br>"); //调用类的方法
23. }
24. }

　　那么这段代码最大的问题是什么呢？一个是没法复用，验证的封装和验证过程在同一个文件，验证的封装已经是可以复用的。另一个是接口和两个实现的类都直接挂接在全局变量上，假如数量一多的话，将会影响整个全局变量。

　　而TypeScritp中模块的出现给我们解决了这一问题。使用 module 关键字来定义模块，并在末尾加花括号即可用； 用export 关键字使接口、类等成员对模块外可见。

1. module Validation { //定义模块
2. export interface StringValidator { //声明接口对外部可以使用
3. isAcceptable(s: string): boolean;
4. }
5. var lettersRegexp = /^[A-Za-z]+$/;
6. var numberRegexp = /^[0-9]+$/;
7. export class LettersOnlyValidator implements StringValidator { //声明类对外部可用
8. isAcceptable(s: string) {
9. return lettersRegexp.test(s);
10. }
11. }
12. export class ZipCodeValidator implements StringValidator {
13. isAcceptable(s: string) {
14. return s.length === 5 && numberRegexp.test(s);
15. }
16. }
17. }

模块内容的调用

1. module Validation { //定义模块
2. export interface StringValidator { //声明接口对外部可以使用
3. isAcceptable(s: string): boolean;
4. }
5. var lettersRegexp = /^[A-Za-z]+$/;
6. var numberRegexp = /^[0-9]+$/;
7. export class LettersOnlyValidator implements StringValidator { //声明类对外部可用
8. isAcceptable(s: string) {
9. return lettersRegexp.test(s);
10. }
11. }
12. export class ZipCodeValidator implements StringValidator {
13. isAcceptable(s: string) {
14. return s.length === 5 && numberRegexp.test(s);
15. }
16. }
17. }
18. var strings = [‘Hello‘, ‘98052‘, ‘101‘];
19. var validators: { [s: string]: Validation.StringValidator; } = {};
20. validators[‘ZIP code‘] = new Validation.ZipCodeValidator(); //使用模块中的类
21. validators[‘Letters only‘] = new Validation.LettersOnlyValidator();
22. // 显示匹配结果
23. for(var i=0;i<strings.length;i++){
24. for (var name in validators) {
25. document.write(‘"‘ + strings[i] + ‘" ‘ + (validators[name].isAcceptable(strings[i]) ? ‘ matches ‘ : ‘ does not match ‘) + name+"<br>"); // 使用方法
26. }
27. }

分隔模块到多个文件

Validation.ts

1. module Validation {
2. export interface StringValidator {
3. isAcceptable(s: string): boolean;
4. }
5. }

LettersOnlyValidator.ts

1. /// <reference path="Validation.ts" />
2. module Validation {
3. var lettersRegexp = /^[A-Za-z]+$/;
4. export class LettersOnlyValidator implements StringValidator {
5. isAcceptable(s: string) {
6. return lettersRegexp.test(s);
7. }
8. }
9. }

ZipCodeValidator.ts

1. /// <reference path="Validation.ts" />
2. module Validation {
3. var numberRegexp = /^[0-9]+$/;
4. export class ZipCodeValidator implements StringValidator {
5. isAcceptable(s: string) {
6. return s.length === 5 && numberRegexp.test(s);
7. }
8. }
9. }

Test.ts

1. /// <reference path="Validation.ts" />
2. /// <reference path="LettersOnlyValidator.ts" />
3. /// <reference path="ZipCodeValidator.ts" />
4. var strings = [‘Hello‘, ‘98052‘, ‘101‘];
5. var validators: { [s: string]: Validation.StringValidator; } = {};
6. validators[‘ZIP code‘] = new Validation.ZipCodeValidator();
7. validators[‘Letters only‘] = new Validation.LettersOnlyValidator();
8. for(var i=0;i<strings.length;i++){
9. for (var name in validators) {
10. document.write(‘"‘ + strings[i] + ‘" ‘ + (validators[name].isAcceptable(strings[i]) ? ‘ matches ‘ : ‘ does not match ‘) + name+"<br>"); //调用类的方法
11. }
12. }

　　在项目中新建好以上四个文件，然后我们编译项目，如果我们代码编写没错的话，是能够编译通过的。另外，我们可以见到后面三个文件开头有类似于 C# 的文档注释，这是告诉 TypeScript 编译器该文件依赖于哪些文件，假如依赖的文件不存在的话，编译就会不通过。当然我们不写也是可以的，只不过编译器在编译时不会帮我们检查，一般来说，还是建议写上。 另外，在引用编译生成的 JavaScript 文件时，我们需要注意好顺序。以上面的代码为例，我们在 Html 代码中已经这么引用。

1. <script src="Validation.js" type="text/javascript"/>
2. <script src="LettersOnlyValidator.js" type="text/javascript"/>
3. <script src="ZipCodeValidator.js" type="text/javascript"/>
4. <script src="Test.js" type="text/javascript"/>

原文地址：https://www.cnblogs.com/mttcug/p/8120259.html