TypeScript学习笔记（二）—— TypeScript基础

一、原始数据类型基本使用

TypeScript中拥有更多的类型，如下表所示：

JavaScript 的类型分为两种：原始数据类型（​​Primitive data types​​）和对象类型（Object types）。

原始数据类型包括：布尔值、数值、字符串、null、undefined 以及 ​​ES6 中的新类型 Symbol​​。

本节主要介绍前五种原始数据类型在 TypeScript 中的应用。

javascript原始类型：布尔值、数值、字符串、null、undefined，为变量指定类型，且变量值需与类型一致

let flag: boolean = false
let num: number = 15
let str: string = 'abc'
var a: null = null
var b: undefined = undefined

// 编译通过

使用构造函数创造的对象不是原始数据类型，事实上 new XXX() 返回的是一个 XXX对象：

let flag:boolean=new Boolean(false)  // Type 'Boolean' is not assignable to type 'boolean'.
let num: number = new Number(15)     // Type 'Number' is not assignable to type 'number'.
let str: string = new String('abc')  // Type 'String' is not assignable to type 'string'.

// 编译通过

但是可以直接调用 XXX 也可以返回一个 xxx 类型：

let flag: boolean = Boolean(false)
  let num : number  = Number(15)
  let str : string  = String('abc')
  // 编译通过

//javascript 中的数据类型分为：原始数据类型 与 对象数据类型
//原始数据类型：number,string,boolean,null,undefined,symbol,bigInt
//对象数据类型：Array,Object,RegExp...
let n:number=1;
let s:string="hello";
let b:boolean=true;
let nu:null=null;
let und:undefined=undefined;
let sy:symbol=Symbol();
let o:Object={};

let num:number;

//num=new Number(100);  //错误，new Number实例化生成的数据类型是Object类型
//new String("");  //Object类型
//new Boolean("true");  //Object类型


let a:number;
a=Number(200);  //直接调用函数Number返回的是number类型的数据

let c:string;
c=String("hi");  //直接调用String函数返回的是string类型的数据

let d:boolean;
d=Boolean(false);  //直接调用Boolean函数返回的是boolean类型的数据

二、原始数据类型

JavaScript 的类型分为两种：原始数据类型（​​Primitive data types​​）和对象类型（Object types）。

原始数据类型包括：布尔值、数值、字符串、​​null​​​、​​undefined​​​ 以及 ES6 中的新类型 ​​Symbol​​​ 和 ES10 中的新类型 ​​BigInt​​。

本节主要介绍前五种原始数据类型在 TypeScript 中的应用。

2.1、布尔值

布尔值是最基础的数据类型，在 TypeScript 中，使用 ​​boolean​​ 定义布尔值类型：

let isDone: boolean = false;

// 编译通过
// 后面约定，未强调编译错误的代码片段，默认为编译通过

注意，使用构造函数 ​​Boolean​​ 创造的对象不是布尔值：

let createdByNewBoolean: boolean = new Boolean(1);

// Type 'Boolean' is not assignable to type 'boolean'.
//   'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.

事实上 ​​new Boolean()​​​ 返回的是一个 ​​Boolean​​ 对象：

let createdByNewBoolean: Boolean = new Boolean(1);

直接调用 ​​Boolean​​​ 也可以返回一个 ​​boolean​​ 类型：

let createdByBoolean: boolean = Boolean(1);

在 TypeScript 中，​​boolean​​​ 是 JavaScript 中的基本类型，而 ​​Boolean​​​ 是 JavaScript 中的构造函数。其他基本类型（除了 ​​null​​​ 和 ​​undefined​​）一样，不再赘述。

let isShow=true;  //推断类型，isShow根据值被编译器推断为boolean类型

//isShow=1;  //错误不能将类型“number”分配给类型“boolean”。ts(2322)

//isShow=new Boolean(true);  //错误，返回的是Object

isShow=Boolean(1);  //正确的，返回的是boolean类型的false

isShow=Boolean(0);   //false

isShow=Boolean(undefined); //false
 
isShow=Boolean(null); //false

isShow=Boolean(""); //false

isShow=Boolean({}); //true

console.log(isShow);

2.2、数值

使用 ​​number​​ 定义数值类型：

let decLiteral: number = 6;
let hexLiteral: number = 0xf00d;
// ES6 中的二进制表示法
let binaryLiteral: number = 0b1010;
// ES6 中的八进制表示法
let octalLiteral: number = 0o744;
let notANumber: number = NaN;
let infinityNumber: number = Infinity;

编译结果：

var decLiteral = 6;
var hexLiteral = 0xf00d;
// ES6 中的二进制表示法
var binaryLiteral = 10;
// ES6 中的八进制表示法
var octalLiteral = 484;
var notANumber = NaN;
var infinityNumber = Infinity;

其中 ​​0b1010​​​ 和 ​​0o744​​​ 是 ​​ES6 中的二进制和八进制表示法​​，它们会被编译为十进制数字。

//数值 number Number

let n1:number=10;  //十进制
let n2:number=0xFFF;  //十六进制
let n3:number=0o176;  //八进制
let n4:number=0b1101; //二进制
let n5:number=15.6;  //小数，浮点数
let n6:number=NaN; //非数字
let n7:number=Infinity; //无限大

//n1=new Number(100);  //错误，返回的Object类型

n1=Number("200");  //正确

console.log(n1);  //200

2.3、字符串

使用 ​​string​​ 定义字符串类型：

let myName: string = 'Tom';
let myAge: number = 25;

// 模板字符串
let sentence: string = `Hello, my name is ${myName}.
I'll be ${myAge + 1}`;

编译结果：

var myName = 'Tom';
var myAge = 25;
// 模板字符串
var sentence = "Hello, my name is " + myName + ".
I'll be " + (myAge + 1) + " years old next month.";

其中 ​​`​​​ 用来定义 ​​ES6 中的模板字符串​​​，​​${expr}​​ 用来在模板字符串中嵌入表达式。

//字符串 string String

let studentname:string="tom";
let studentage:number=18;

let result=`我叫${studentname},明年${++studentage}岁`;  
//result=100;  //错误，因为模板字符串被推断为string数据类型
console.log(result);  //我叫tom,明年19岁

let a=new String("hello world");  
console.log(typeof a);  //object

//let b:string=new String("hello world"); //不能将类型“String”分配给类型“string”。 object

let c:string=String(true);
console.log(c);  //true

2.4、空值

JavaScript 没有空值（Void）的概念，在 TypeScript 中，可以用 ​​void​​ 表示没有任何返回值的函数：

function alertName(): void {
    alert('My name is Tom');
}

声明一个 ​​void​​​ 类型的变量没有什么用，因为你只能将它赋值为 ​​undefined​​​ 和 ​​null​​（只在 --strictNullChecks 未指定时）：

let unusable: void = undefined;

//void 空值

let a:void=undefined;  //一般不会使用在变量类型的定义中

//a=null;  //默认错误


function f1():void{  //表明函数没有返回值
    //return 100;  //不允许

2.5、Null 和 Undefined

在 TypeScript 中，可以使用 ​​null​​​ 和 ​​undefined​​ 来定义这两个原始数据类型：

let u: undefined = undefined;
let n: null = null;

//null,undefined

let n1:null=null;
//n1=undefined;  //错误

let n2:undefined=undefined;
//n2=null;  //错误

2.6、Infinity无穷大

Infinity(无穷大)在 JS 中是一个特殊的数字，它的特性是：它比任何有限的数字都大，在 Javascript 中，超出 1.797693134862315E+308 的数值即为 Infinity，小于 -1.797693134862316E+308 的数值为无穷小。

1.Infinity(无穷)的定义

无穷可以分为两种，正无穷和负无穷，JS 中对应的表示方式为：+Infinity(或者Infinity) 和 -Infinity。

这意味着Infinity和-Infinity（小于任何有限数的数字）都是number类型的特殊值：

​​typeof​​​ ​​Infinity; ​​​​// => 'number'​​

​​typeof​​​ ​​-Infinity; ​​​​// => 'number'​​

Infinity 是全局对象的属性：

window.Infinity; // => Infinity

另外，Number函数也有两个属性来表示正负无穷大：

Number.POSITIVE_INFINITY; // => Infinity
Number.NEGATIVE_INFINITY; // => -Infinity

2. Infinity 的特性

Infinity比任何有限数都大。

举几个例子 :

Infinity > 100;                     // => true
Infinity > Number.MAX_SAFE_INTEGER; // => true
Infinity > Number.MAX_VALUE;        // => true

​​Number.MAX_SAFE_INTEGER​​​ 常量表示在 JavaScript 中最大的安全整数（maxinum safe integer)（​​2^53 - 1），数值，9007199254740991。​​

Infinity 在加法、乘法和除法等算术运算中用作操作数时会产生有趣的效果：

Infinity + 1;        // => Infinity
Infinity + Infinity; // => Infinity

Infinity * 2;        // => Infinity
Infinity * Infinity; // => Infinity

Infinity / 2;        // => Infinity

一些Infinity 的运算得到有限的数：

10 / Infinity; // => 0

一个有限的数除以0得到 Infinity 结果：

2 / 0; // => Infinity

对无穷数进行概念上不正确的运算会得到NaN。 例如，不能除以无限数，也无法确定无限数是奇数还是偶数：

Infinity / Infinity; // => NaN
Infinity % 2;        // => NaN

2.1 负无穷

负无穷小于任何有限数。

将-Infinity 与一些有限数字进行比较：

-Infinity < 100;                      // => true
-Infinity < -Number.MAX_SAFE_INTEGER; // => true
-Infinity < -Number.MAX_VALUE;        // => true

同时，负无穷小于正无穷：

-Infinity < Infinity; // => true

当使用不同操作符操作数时，也可能会得到负无穷：

Infinity * -1; // => -Infinity
Infinity / -2; // => -Infinity
-2 / 0;        // => -Infinity

3.判断无穷

幸运的是，Infinity等于相同符号的Infinity：

Infinity === Infinity; // => true
-Infinity === -Infinity; // => true

但前面的符号不一样就不相等，就也很好理解：

Infinity === -Infinity; // => false

JSt有一个特殊的函数Number.isFinite(value)，用于检查提供的值是否有限数：

Number.isFinite(Infinity);  // => false
Number.isFinite(-Infinity); // => false
Number.isFinite(999);       // => true

2.7、Number的属性

三、任意值

在typescript中，当我们不确定一个类型是什么类型的，可以选择给其声明为any或者unkown。但实际上，typescript推荐使用unknown，因为unknown是类型安全的。

任意值（Any）用来表示允许赋值为任意类型。

3.1、什么是任意值类型

如果是一个普通类型，在赋值过程中改变类型是不被允许的：

let myFavoriteNumber: string = 'seven';
myFavoriteNumber = 7;

// index.ts(2,1): error TS2322: Type 'number' is not assignable to type 'string'.

但如果是 ​​any​​ 类型，则允许被赋值为任意类型。

let myFavoriteNumber: any = 'seven';
myFavoriteNumber = 7;

3.2、任意值的属性和方法

在任意值上访问任何属性都是允许的：

let anyThing: any = 'hello';
console.log(anyThing.myName);  //undefined

可以认为，声明一个变量为任意值之后，对它的任何操作，返回的内容的类型都是任意值。

3.3、未声明类型的变量

变量如果在声明的时候，未指定其类型，那么它会被识别为任意值类型：

let something;
something = 'seven';
something = 7;

something.setName('Tom');

等价于

let something: any;
something = 'seven';
something = 7;

something.setName('Tom');

3.4、任意值可以赋值给已知类型变量

let a:number;
a=100;

let b:any;
b=200;
b="hello world";

a=b;

console.log(typeof

结果

let a:any;

//可以将任意类型赋值给any类型
a=7;
a="hi";

//任意类型可以接收any类型的值
let b:boolean;
b=true;

b=a;  //注意这里是正确的，b的类型已改变成a的类型string,注意不是any

//b=8;  //错误

console.log(typeof b); //string

//如果在定义变量时没有指定类型，则变量为any类型
let c;  //这里相当于 let c:any
function f1(a,b,c){  //function f1(a: any, b: any, c: any): void

3.5、unknown

let notSure: unknown = 4;
notSure = 'hello';

any是任意类型的父类型，同时也任意类型的子类型
unknown是任意类型的父类型，但仅此而已。

let a:unknown;
let b:number;

a=1;
a="hello world";

b=a;  //错误

示例2

let a:unknown;

//unknown类型可以被赋值为任意类型这点与any类似

a=7;
a=true;
a="hello";

//但是其它类型不能接收unknown的值，不能将unknown赋值给其它类
let b:boolean;
b=true;

b=a;  //错误，如果a是any类型则允许

3.6、nerver

function error(message: string): never {
  throw new Error(message);
}

永远都不会有返回的函数：

1、函数抛出异常

function a () {
    throw TypeError('this is a error')
}

2、永远执行下去的函数

function b() {
    while(true) {
    // todo
    }
}

四、类型推论

如果没有明确的指定类型，那么 TypeScript 会依照类型推论（Type Inference）的规则推断出一个类型。

以下代码虽然没有指定类型，但是会在编译的时候报错：

let myFavoriteNumber = 'seven';
myFavoriteNumber = 7;

// index.ts(2,1): error TS2322: Type 'number' is not assignable to type 'string'.

事实上，它等价于：

let myFavoriteNumber: string = 'seven';
myFavoriteNumber = 7;

// index.ts(2,1): error TS2322: Type 'number' is not assignable to type 'string'.

TypeScript 会在没有明确的指定类型的时候推测出一个类型，这就是类型推论。

如果定义的时候没有赋值，不管之后有没有赋值，都会被推断成 ​​any​​ 类型而完全不被类型检查：

let myFavoriteNumber;
myFavoriteNumber = 'seven';
myFavoriteNumber = 7;

let a=100;  //a被推断为number 等同于let a:number=100;

let b=true; //b被推断为boolean类型

let c;

c="hello";

console.log(typeof c);  //string

function f1(){  //函数的返回值被推断为number,相当于f1():number
    return 1;
}

五、联合类型

联合类型（Union Types）表示取值可以为多种类型中的一种。

5.1、简单的例子

let myFavoriteNumber: string | number;
myFavoriteNumber = 'seven';
myFavoriteNumber = 7;

let myFavoriteNumber: string | number;
myFavoriteNumber = true;

// index.ts(2,1): error TS2322: Type 'boolean' is not assignable to type 'string | number'.
//   Type 'boolean' is not assignable to type 'number'.

联合类型使用 ​​|​​ 分隔每个类型。

这里的 ​​let myFavoriteNumber: string | number​​​ 的含义是，允许 ​​myFavoriteNumber​​​ 的类型是 ​​string​​​ 或者 ​​number​​，但是不能是其他类型。

5.2、访问联合类型的属性或方法

当 TypeScript 不确定一个联合类型的变量到底是哪个类型的时候，我们只能访问此联合类型的所有类型里共有的属性或方法：

function getLength(something: string | number): number {
    return something.length;
}

// index.ts(2,22): error TS2339: Property 'length' does not exist on type 'string | number'.
//   Property 'length' does not exist on type 'number'.

上例中，​​length​​​ 不是 ​​string​​​ 和 ​​number​​ 的共有属性，所以会报错。

访问 ​​string​​​ 和 ​​number​​ 的共有属性是没问题的：

function getString(something: string | number): string {
    return something.toString();
}

联合类型的变量在被赋值的时候，会根据类型推论的规则推断出一个类型：

let myFavoriteNumber: string | number;
myFavoriteNumber = 'seven';
console.log(myFavoriteNumber.length); // 5
myFavoriteNumber = 7;
console.log(myFavoriteNumber.length); // 编译时报错

// index.ts(5,30): error TS2339: Property 'length' does not exist on type 'number'.

上例中，第二行的 ​​myFavoriteNumber​​​ 被推断成了 ​​string​​​，访问它的 ​​length​​ 属性不会报错。

而第四行的 ​​myFavoriteNumber​​​ 被推断成了 ​​number​​​，访问它的 ​​length​​ 属性时就报错了。

let a:string | number | boolean;

a="hello";
a=true;
a=666;

//a={};  //错误，对象类型

console.log(typeof a);  //number

function f1(c:string|number){  //函数的参数可以是联合类型
}

f1(100);
f1("abc");

六、对象的类型——接口

在 TypeScript 中，我们使用接口（Interfaces）来定义对象的类型。

6.1、什么是接口

在面向对象语言中，接口（Interfaces）是一个很重要的概念，它是对行为的抽象，而具体如何行动需要由类（classes）去实现（implement）。

TypeScript 中的接口是一个非常灵活的概念，除了可用于​​对类的一部分行为进行抽象​​以外，也常用于对「对象的形状（Shape）」进行描述。

6.2、简单的例子

interface Person {
    name: string;
    age: number;
}

let tom: Person = {
    name: 'Tom',
    age: 25
};

上面的例子中，我们定义了一个接口 ​​Person​​​，接着定义了一个变量 ​​tom​​​，它的类型是 ​​Person​​​。这样，我们就约束了 ​​tom​​​ 的形状必须和接口 ​​Person​​ 一致。

接口一般首字母大写。​​有的编程语言中会建议接口的名称加上 I​​。

定义的变量比接口少了一些属性是不允许的：

interface Person {
    name: string;
    age: number;
}

let tom: Person = {
    name: 'Tom'
};

// index.ts(6,5): error TS2322: Type '{ name: string; }' is not assignable to type 'Person'.
//   Property 'age' is missing in type '{ name: string; }'.

多一些属性也是不允许的：

interface Person {
    name: string;
    age: number;
}

let tom: Person = {
    name: 'Tom',
    age: 25,
    gender: 'male'
};

// index.ts(9,5): error TS2322: Type '{ name: string; age: number; gender: string; }' is not assignable to type 'Person'.
//   Object literal may only specify known properties, and 'gender' does not exist in type 'Person'.

可见，赋值的时候，变量的形状必须和接口的形状保持一致。

//接口 interface 接口是一种抽象类型 接口中的属性不能有初值，方法不能有方法体
//定义接口人
interface IPerson{
    name:string;
    age:number;
    hello():void;
}

//约束对象
let tom:IPerson={
    name:"汤姆",
    age:18,
    hello(){
        console.log(this.name+","+this.age);
    }
};
tom.hello();

//约束类的属性与行为
class Student implements IPerson{
    name: string;
    age: number;
    sex:string;
    constructor(name:string, age:number,sex:string){  //构造函数
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    hello (): void {
        console.log(this.name+","+this.age+","+this.sex);
    }
}

let jack=new Student("jack",19,"男");
jack.hello();

6.3、可选属性

有时我们希望不要完全匹配一个形状，那么可以用可选属性：

interface Person {
    name: string;
    age?: number;
}

let tom: Person = {
    name: 'Tom'
};

interface Person {
    name: string;
    age?: number;
}

let tom: Person = {
    name: 'Tom',
    age: 25
};

可选属性的含义是该属性可以不存在。

这时仍然不允许添加未定义的属性：

interface Person {
    name: string;
    age?: number;
}

let tom: Person = {
    name: 'Tom',
    age: 25,
    gender: 'male'
};

// examples/playground/index.ts(9,5): error TS2322: Type '{ name: string; age: number; gender: string; }' is not assignable to type 'Person'.
//   Object literal may only specify known properties, and 'gender' does not exist in type 'Person'.

interface IPerson{
    name:string;
    age?:number;  //?号表示该属性是可选的，对象中可以不包含
    hi?():void;  //可选方法
    hello?:(a:number,b:number)=>boolean;  //方法名：（参数）=> 返回值
}

let tom:IPerson={
    name: "Tom"
}

6.4、任意属性

有时候我们希望一个接口允许有任意的属性，可以使用如下方式：

interface Person {
    name: string;
    age?: number;
    [propName: string]: any;
}

let tom: Person = {
    name: 'Tom',
    gender: 'male'
};

使用 ​​[propName: string]​​​ 定义了任意属性取 ​​string​​ 类型的值。

需要注意的是，一旦定义了任意属性，那么确定属性和可选属性的类型都必须是它的类型的子集：

interface Person {
    name: string;
    age?: number;
    [propName: string]: string;
}

let tom: Person = {
    name: 'Tom',
    age: 25,
    gender: 'male'
};

// index.ts(3,5): error TS2411: Property 'age' of type 'number' is not assignable to string index type 'string'.
// index.ts(7,5): error TS2322: Type '{ [x: string]: string | number; name: string; age: number; gender: string; }' is not assignable to type 'Person'.
//   Index signatures are incompatible.
//     Type 'string | number' is not assignable to type 'string'.
//       Type 'number' is not assignable to type 'string'.

interface IPerson{
    id: number;
    name: string;
    age: number;
    [prop:string]:any;  //定义一个名称为string类型的任意属性,prop可以更换成其它名称
}

let tom:IPerson={
    id: 1,
    name: "Tom",
    age: 20,
    a:1,
    b:2
};

上例中，任意属性的值允许是 ​​string​​​，但是可选属性 ​​age​​​ 的值却是 ​​number​​​，​​number​​​ 不是 ​​string​​ 的子属性，所以报错了。

另外，在报错信息中可以看出，此时 ​​{ name: 'Tom', age: 25, gender: 'male' }​​​ 的类型被推断成了 ​​{ [x: string]: string | number; name: string; age: number; gender: string; }​​，这是联合类型和接口的结合。

一个接口中只能定义一个任意属性。如果接口中有多个类型的属性，则可以在任意属性中使用联合类型：

interface Person {
    name: string;
    age?: number;
    [propName: string]: string | number;
}

let tom: Person = {
    name: 'Tom',
    age: 25,
    gender: 'male'
};

6.5、只读属性

有时候我们希望对象中的一些字段只能在创建的时候被赋值，那么可以用 ​​readonly​​ 定义只读属性：

interface Person {
    readonly id: number;
    name: string;
    age?: number;
    [propName: string]: any;
}

let tom: Person = {
    id: 89757,
    name: 'Tom',
    gender: 'male'
};

tom.id = 9527;

// index.ts(14,5): error TS2540: Cannot assign to 'id' because it is a constant or a read-only property.

上例中，使用 ​​readonly​​​ 定义的属性 ​​id​​ 初始化后，又被赋值了，所以报错了。

注意，只读的约束存在于第一次给对象赋值的时候，而不是第一次给只读属性赋值的时候：

interface Person {
    readonly id: number;
    name: string;
    age?: number;
    [propName: string]: any;
}

let tom: Person = {
    name: 'Tom',
    gender: 'male'
};

tom.id = 89757;

// index.ts(8,5): error TS2322: Type '{ name: string; gender: string; }' is not assignable to type 'Person'.
//   Property 'id' is missing in type '{ name: string; gender: string; }'.
// index.ts(13,5): error TS2540: Cannot assign to 'id' because it is a constant or a read-only property.

上例中，报错信息有两处，第一处是在对 ​​tom​​​ 进行赋值的时候，没有给 ​​id​​ 赋值。

第二处是在给 ​​tom.id​​ 赋值的时候，由于它是只读属性，所以报错了。

interface IPerson{
    readonly id?: number;  //id是只读的
    name: string;
}

//只读属性的值只能在对象中初始化一次后就不允许修改
let tom:IPerson={
    id: 1,
    name: "Tom"
};

//tom.id=-100;  //错误，不允许修改

6.6、方法

interface IPerson { 
    firstName:string, 
    lastName:string, 
    sayHi: ()=>string 
} 
 
var customer:IPerson = { 
    firstName:"Tom",
    lastName:"Hanks", 
    sayHi: ():string =>{return "Hi there"} 
}

console.log("Customer 对象 ");
console.log(customer.firstName); 
console.log(customer.lastName); 
console.log(customer.sayHi());

在接口中定义了方法sayHi，要求返回值为String类型。

运行结果：

Customer 对象
Tom
Hanks
Hi there

编译以后的代码：

var customer = {
    firstName: "Tom",
    lastName: "Hanks",
    sayHi: function () { return "Hi there"; }
};
console.log("Customer 对象 ");
console.log(customer.firstName);
console.log(customer.lastName);
console.log(customer.sayHi());

interface ICar{
    name:string;
    readonly run:(speed:number)=>void;  //run方法,(speed:number)约束参数,void是返回值
    stop():string; //方法名stop参数():返回值string
    a:Function;
}

let car:ICar={
    name: "BYD",
    run: function (speed: number): void {
        console.log(`${this.name}以${speed}km/s的速度在运行`);
    },
    stop: function (): string {
       return "车停了";
    },
    a:()=>1
}

car.run(100);

6.7、联合类型和接口

以下实例演示了如何在接口中使用联合类型：

interface RunOptions { 
    program:string; 
    commandline:string[]|string|(()=>string); 
} 
 
// commandline 是字符串
var options:RunOptions = {program:"test1",commandline:"Hello"}; 
console.log(options.commandline)  
 
// commandline 是字符串数组
options = {program:"test1",commandline:["Hello","World"]}; 
console.log(options.commandline[0]); 
console.log(options.commandline[1]);  
 
// commandline 是一个函数表达式
options = {program:"test1",commandline:()=>{return "**Hello World**";}}; 
 
var fn:any = options.commandline; 
console.log(fn());

编译以上代码，得到以下 JavaScript 代码：

// commandline 是字符串
var options = { program: "test1", commandline: "Hello" };
console.log(options.commandline);
// commandline 是字符串数组
options = { program: "test1", commandline: ["Hello", "World"] };
console.log(options.commandline[0]);
console.log(options.commandline[1]);
// commandline 是一个函数表达式
options = { program: "test1", commandline: function () { return "**Hello World**"; } };
var fn = options.commandline;
console.log(fn());

interface IOption{
    command:string[]|string|(()=>string)
    //string[] string类型的数组
    //string 字符
    //(()=>string) 没有参数但返回string类型的函数
}

let o1={
    command:["cd","dir"]
}

let o2={
    command:"cls"
}

let o3={
    command:()=>"exit"
}

let o4={
    command:()=>{return "exit";}
}

let o5={
    command:function(){return "exit";}
}

6.8、接口和数组

接口中我们可以将数组的索引值和元素设置为不同类型，索引值可以是数字或字符串。

设置元素为字符串类型：

示例1：

interface namelist { 
    [index:number]:string 
 } 
  
 // 类型一致，正确
 var list2:namelist = ["Google","Runoob","Taobao"]
 // 错误元素 1 不是 string 类型
 // var list2:namelist = ["Runoob",1,"Taobao"]

示例2：

interface ages { 
    [index:string]:number 
 } 
  
 var agelist:ages; 
  // 类型正确 
 agelist["runoob"] = 15  
  
 // 类型错误，输出  error TS2322: Type '"google"' is not assignable to type 'number'.
 // agelist[2] = "google"

interface INameList{
    [index:number]:string
    //约束的对象只能使用数字索引访问数组，数组中的值只能是string类型
}

let users:INameList=["tom","jack","rose"];
console.log(users[1]);  //jack

interface INameList2{
    [index:string]:number
    //约束的对象只能使用key方法，对象中属性的值只能是number类型
}

let users2:INameList2={
    "tom":202201,
    "jack":202202,
    "rose":202203
}
console.log(users2["jack"]);  //jack

6.9、接口继承

接口继承就是说接口可以通过其他接口来扩展自己。

Typescript 允许接口继承多个接口。

继承使用关键字 extends。

单接口继承语法格式：

Child_interface_nameextends super_interface_name

多接口继承语法格式：

Child_interface_nameextends,,…,super_interfaceN_name
继承的各个接口使用逗号 , 分隔。

单继承实例

interface Person { 
   age:number 
} 
 
interface Musician extends Person { 
   instrument:string 
} 
 
var drummer = <Musician>{}; 
drummer.age = 27 
drummer.instrument = "Drums" 
console.log("年龄:  "+drummer.age)
console.log("喜欢的乐器:  "+drummer.instrument)

输出结果为：

年龄:27喜欢的乐器:Drums

多继承实例

interface IParent1 { 
    v1:number 
} 
 
interface IParent2 { 
    v2:number 
} 
 
interface Child extends IParent1, IParent2 { } 
var Iobj:Child = { v1:12, v2:23} 
console.log("value 1: "+Iobj.v1+" value 2: "+Iobj.v2)

输出结果为：

value 1:122:23

6.10、匿名类型

可以为对象指定一个匿名类型，如下所示：

let obje:{a:string,b:number}={a:"a",b:1};

type Person={  //类型
    name:string,
    age?:number
}

let obj:{name:string,age?:number}={  //匿名类型
    name:"jack"
};

let tom:Person={
    name:"tom",
    age:100
}

七、数组的类型

在 TypeScript 中，数组类型有多种定义方式，比较灵活。

7.1、「类型 + 方括号」表示法

最简单的方法是使用「类型 + 方括号」来表示数组：

let fibonacci: number[] = [1, 1, 2, 3, 5];

数组的项中不允许出现其他的类型：

let fibonacci: number[] = [1, '1', 2, 3, 5];

// Type 'string' is not assignable to type 'number'.

数组的一些方法的参数也会根据数组在定义时约定的类型进行限制：

let fibonacci: number[] = [1, 1, 2, 3, 5];
fibonacci.push('8');

// Argument of type '"8"' is not assignable to parameter of type 'number'.

上例中，​​push​​​ 方法只允许传入 ​​number​​​ 类型的参数，但是却传了一个 ​​"8"​​​ 类型的参数，所以报错了。这里 ​​"8"​​ 是一个字符串字面量类型，会在后续章节中详细介绍。

7.2、数组泛型

我们也可以使用数组泛型（Array Generic） ​​Array<elemType>​​ 来表示数组：

let fibonacci: Array<number> = [1, 1, 2, 3, 5];

7.3、用接口表示数组

接口也可以用来描述数组：

interface NumberArray {
    [index: number]: number;
}
let fibonacci: NumberArray = [1, 1, 2, 3, 5];

​​NumberArray​​ 表示：只要索引的类型是数字时，那么值的类型必须是数字。

虽然接口也可以用来描述数组，但是我们一般不会这么做，因为这种方式比前两种方式复杂多了。

不过有一种情况例外，那就是它常用来表示类数组。

7.4、类数组

类数组（Array-like Object）不是数组类型，比如 ​​arguments​​：

function sum() {
    let args: number[] = arguments;
}

// Type 'IArguments' is missing the following properties from type 'number[]': pop, push, concat, join, and 24 more.

上例中，​​arguments​​ 实际上是一个类数组，不能用普通的数组的方式来描述，而应该用接口：

function sum() {
    let args: {
        [index: number]: number;
        length: number;
        callee: Function;
    } = arguments;
}

在这个例子中，我们除了约束当索引的类型是数字时，值的类型必须是数字之外，也约束了它还有 ​​length​​​ 和 ​​callee​​ 两个属性。

事实上常用的类数组都有自己的接口定义，如 ​​IArguments​​​, ​​NodeList​​​, ​​HTMLCollection​​ 等：

function sum() {
    let args: IArguments = arguments;
}

其中 ​​IArguments​​ 是 TypeScript 中定义好了的类型，它实际上就是：

interface IArguments {
    [index: number]: any;
    length: number;
    callee: Function;
}

7.5、any 在数组中的应用

一个比较常见的做法是，用 ​​any​​ 表示数组中允许出现任意类型：

let list: any[] = ['xcatliu', 25, { website: 'http://abc.com' }];

八、函数的类型

8.1、函数声明

在 JavaScript 中，有两种常见的定义函数的方式——函数声明（Function Declaration）和函数表达式（Function Expression）：

// 函数声明（Function Declaration）
function sum(x, y) {
    return x + y;
}

// 函数表达式（Function Expression）
let mySum = function (x, y) {
    return x + y;
};

一个函数有输入和输出，要在 TypeScript 中对其进行约束，需要把输入和输出都考虑到，其中函数声明的类型定义较简单：

function sum(x: number, y: number): number {
    return x + y;
}

注意，输入多余的（或者少于要求的）参数，是不被允许的：

function sum(x: number, y: number): number {
    return x + y;
}
sum(1, 2, 3);

// index.ts(4,1): error TS2346: Supplied parameters do not match any signature of call target.

function sum(x: number, y: number): number {
    return x + y;
}
sum(1);

// index.ts(4,1): error TS2346: Supplied parameters do not match any signature of call target.

8.2、函数表达式

如果要我们现在写一个对函数表达式（Function Expression）的定义，可能会写成这样：

let mySum = function (x: number, y: number): number {
    return x + y;
};

这是可以通过编译的，不过事实上，上面的代码只对等号右侧的匿名函数进行了类型定义，而等号左边的 ​​mySum​​​，是通过赋值操作进行类型推论而推断出来的。如果需要我们手动给 ​​mySum​​ 添加类型，则应该是这样：

let mySum: (x: number, y: number) => number = function (x: number, y: number): number {
    return x + y;
};

注意不要混淆了 TypeScript 中的 ​​=>​​​ 和 ES6 中的 ​​=>​​。

在 TypeScript 的类型定义中，​​=>​​ 用来表示函数的定义，左边是输入类型，需要用括号括起来，右边是输出类型。

在 ES6 中，​​=>​​​ 叫做箭头函数，应用十分广泛，可以参考 ​​ES6 中的箭头函数​​。

mySum: (x: number, y: number) => number 是对函数的参数与返回值的约束

function (x: number, y: number): number是对函数约束的实现

8.3、用接口定义函数的形状

我们也可以使用接口的方式来定义一个函数需要符合的形状：

interface SearchFunc {
    (source: string, subString: string): boolean;
}

let mySearch: SearchFunc;
mySearch = function(source: string, subString: string) {
    return source.search(subString) !== -1;
}

采用函数表达式|接口定义函数的方式时，对等号左侧进行类型限制，可以保证以后对函数名赋值时保证参数个数、参数类型、返回值类型不变。

8.4、可选参数

前面提到，输入多余的（或者少于要求的）参数，是不允许的。那么如何定义可选的参数呢？

与接口中的可选属性类似，我们用 ​​?​​ 表示可选的参数：

function buildName(firstName: string, lastName?: string) {
    if (lastName) {
        return firstName + ' ' + lastName;
    } else {
        return firstName;
    }
}
let tomcat = buildName('Tom', 'Cat');
let tom = buildName('Tom');

需要注意的是，可选参数必须接在必需参数后面。换句话说，可选参数后面不允许再出现必需参数了：

function buildName(firstName?: string, lastName: string) {
    if (firstName) {
        return firstName + ' ' + lastName;
    } else {
        return lastName;
    }
}
let tomcat = buildName('Tom', 'Cat');
let tom = buildName(undefined, 'Tom');

// index.ts(1,40): error TS1016: A required parameter cannot follow an optional parameter.

8.5、参数默认值

在 ES6 中，我们允许给函数的参数添加默认值，TypeScript 会将添加了默认值的参数识别为可选参数：

function buildName(firstName: string, lastName: string = 'Cat') {
    return firstName + ' ' + lastName;
}
let tomcat = buildName('Tom', 'Cat');
let tom = buildName('Tom');

此时就不受「可选参数必须接在必需参数后面」的限制了：

function buildName(firstName: string = 'Tom', lastName: string) {
    return firstName + ' ' + lastName;
}
let tomcat = buildName('Tom', 'Cat');
let cat = buildName(undefined, 'Cat');

关于默认参数，可以参考 ​​ES6 中函数参数的默认值​​。

8.6、剩余参数

ES6 中，可以使用 ​​...rest​​ 的方式获取函数中的剩余参数（rest 参数）：

function push(array, ...items) {
    items.forEach(function(item) {
        array.push(item);
    });
}

let a: any[] = [];
push(a, 1, 2, 3);

事实上，​​items​​ 是一个数组。所以我们可以用数组的类型来定义它：

function push(array: any[], ...items: any[]) {
    items.forEach(function(item) {
        array.push(item);
    });
}

let a = [];
push(a, 1, 2, 3);

注意，rest 参数只能是最后一个参数，关于 rest 参数，可以参考 ​​ES6 中的 rest 参数​​。

8.7、重载

重载允许一个函数接受不同数量或类型的参数时，作出不同的处理。

比如，我们需要实现一个函数 ​​reverse​​​，输入数字 ​​123​​​ 的时候，输出反转的数字 ​​321​​​，输入字符串 ​​'hello'​​​ 的时候，输出反转的字符串 ​​'olleh'​​。

利用联合类型，我们可以这么实现：

function reverse(x: number | string): number | string | void {
    if (typeof x === 'number') {
        return Number(x.toString().split('').reverse().join(''));
    } else if (typeof x === 'string') {
        return x.split('').reverse().join('');
    }
}

然而这样有一个缺点，就是不能够精确的表达，输入为数字的时候，输出也应该为数字，输入为字符串的时候，输出也应该为字符串。

这时，我们可以使用重载定义多个 ​​reverse​​ 的函数类型：

function reverse(x: number): number;
function reverse(x: string): string;
function reverse(x: number | string): number | string | void {
    if (typeof x === 'number') {
        return Number(x.toString().split('').reverse().join(''));
    } else if (typeof x === 'string') {
        return x.split('').reverse().join('');
    }
}

上例中，我们重复定义了多次函数 ​​reverse​​，前几次都是函数定义，最后一次是函数实现。在编辑器的代码提示中，可以正确的看到前两个提示。

注意，TypeScript 会优先从最前面的函数定义开始匹配，所以多个函数定义如果有包含关系，需要优先把精确的定义写在前面。

 九、类型断言

类型断言（Type Assertion）可以用来手动指定一个值的类型。

9.1、语法

值 as 类型

或

<类型>值

在 tsx 语法（React 的 jsx 语法的 ts 版）中必须使用前者，即 ​​值 as 类型​​。

形如 ​​<Foo>​​​ 的语法在 tsx 中表示的是一个 ​​ReactNode​​，在 ts 中除了表示类型断言之外，也可能是表示一个泛型。

故建议大家在使用类型断言时，统一使用 ​​值 as 类型​​ 这样的语法，本书中也会贯彻这一思想。

9.2、类型断言的用途

类型断言的常见用途有以下几种：

9.2.1、将一个联合类型断言为其中一个类型

之前提到过，当 TypeScript 不确定一个联合类型的变量到底是哪个类型的时候，我们只能访问此联合类型的所有类型中共有的属性或方法：

interface Cat {
    name: string;
    run(): void;
}
interface Fish {
    name: string;
    swim(): void;
}

function getName(animal: Cat | Fish) {
    return animal.name;
}

而有时候，我们确实需要在还不确定类型的时候就访问其中一个类型特有的属性或方法，比如：

interface Cat {
    name: string;
    run(): void;
}
interface Fish {
    name: string;
    swim(): void;
}

function isFish(animal: Cat | Fish) {
    if (typeof animal.swim === 'function') {
        return true;
    }
    return false;
}

// index.ts:11:23 - error TS2339: Property 'swim' does not exist on type 'Cat | Fish'.
//   Property 'swim' does not exist on type 'Cat'.

上面的例子中，获取 ​​animal.swim​​ 的时候会报错。

此时可以使用类型断言，将 ​​animal​​​ 断言成 ​​Fish​​：

interface Cat {
    name: string;
    run(): void;
}
interface Fish {
    name: string;
    swim(): void;
}

function isFish(animal: Cat | Fish) {
    if (typeof (animal as Fish).swim === 'function') {
        return true;
    }
    return false;
}

这样就可以解决访问 ​​animal.swim​​ 时报错的问题了。

需要注意的是，类型断言只能够「欺骗」TypeScript 编译器，无法避免运行时的错误，反而滥用类型断言可能会导致运行时错误：

interface Cat {
    name: string;
    run(): void;
}
interface Fish {
    name: string;
    swim(): void;
}

function swim(animal: Cat | Fish) {
    (animal as Fish).swim();
}

const tom: Cat = {
    name: 'Tom',
    run() { console.log('run') }
};
swim(tom);
// Uncaught TypeError: animal.swim is not a function`

上面的例子编译时不会报错，但在运行时会报错：

Uncaught TypeError: animal.swim is not a function`

原因是 ​​(animal as Fish).swim()​​​ 这段代码隐藏了 ​​animal​​​ 可能为 ​​Cat​​​ 的情况，将 ​​animal​​​ 直接断言为 ​​Fish​​​ 了，而 TypeScript 编译器信任了我们的断言，故在调用 ​​swim()​​ 时没有编译错误。

可是 ​​swim​​​ 函数接受的参数是 ​​Cat | Fish​​​，一旦传入的参数是 ​​Cat​​​ 类型的变量，由于 ​​Cat​​​ 上没有 ​​swim​​ 方法，就会导致运行时错误了。

总之，使用类型断言时一定要格外小心，尽量避免断言后调用方法或引用深层属性，以减少不必要的运行时错误。

9.2.2、将一个父类断言为更加具体的子类

当类之间有继承关系时，类型断言也是很常见的：

class ApiError extends Error {
    code: number = 0;
}
class HttpError extends Error {
    statusCode: number = 200;
}

function isApiError(error: Error) {
    if (typeof (error as ApiError).code === 'number') {
        return true;
    }
    return false;
}

上面的例子中，我们声明了函数 ​​isApiError​​​，它用来判断传入的参数是不是 ​​ApiError​​​ 类型，为了实现这样一个函数，它的参数的类型肯定得是比较抽象的父类 ​​Error​​​，这样的话这个函数就能接受 ​​Error​​ 或它的子类作为参数了。

但是由于父类 ​​Error​​​ 中没有 ​​code​​​ 属性，故直接获取 ​​error.code​​​ 会报错，需要使用类型断言获取 ​​(error as ApiError).code​​。

大家可能会注意到，在这个例子中有一个更合适的方式来判断是不是 ​​ApiError​​​，那就是使用 ​​instanceof​​：

class ApiError extends Error {
    code: number = 0;
}
class HttpError extends Error {
    statusCode: number = 200;
}

function isApiError(error: Error) {
    if (error instanceof ApiError) {
        return true;
    }
    return false;
}

上面的例子中，确实使用 ​​instanceof​​​ 更加合适，因为 ​​ApiError​​​ 是一个 JavaScript 的类，能够通过 ​​instanceof​​​ 来判断 ​​error​​ 是否是它的实例。

但是有的情况下 ​​ApiError​​​ 和 ​​HttpError​​​ 不是一个真正的类，而只是一个 TypeScript 的接口（​​interface​​​），接口是一个类型，不是一个真正的值，它在编译结果中会被删除，当然就无法使用 ​​instanceof​​ 来做运行时判断了：

interface ApiError extends Error {
    code: number;
}
interface HttpError extends Error {
    statusCode: number;
}

function isApiError(error: Error) {
    if (error instanceof ApiError) {
        return true;
    }
    return false;
}

// index.ts:9:26 - error TS2693: 'ApiError' only refers to a type, but is being used as a value here.

此时就只能用类型断言，通过判断是否存在 ​​code​​​ 属性，来判断传入的参数是不是 ​​ApiError​​ 了：

interface ApiError extends Error {
    code: number;
}
interface HttpError extends Error {
    statusCode: number;
}

function isApiError(error: Error) {
    if (typeof (error as ApiError).code === 'number') {
        return true;
    }
    return false;
}

9.2.3、将任何一个类型断言为 any

理想情况下，TypeScript 的类型系统运转良好，每个值的类型都具体而精确。

当我们引用一个在此类型上不存在的属性或方法时，就会报错：

const foo: number = 1;
foo.length = 1;

// index.ts:2:5 - error TS2339: Property 'length' does not exist on type 'number'.

上面的例子中，数字类型的变量 ​​foo​​​ 上是没有 ​​length​​ 属性的，故 TypeScript 给出了相应的错误提示。

这种错误提示显然是非常有用的。

但有的时候，我们非常确定这段代码不会出错，比如下面这个例子：

window.foo = 1;

// index.ts:1:8 - error TS2339: Property 'foo' does not exist on type 'Window & typeof globalThis'.

上面的例子中，我们需要将 ​​window​​​ 上添加一个属性 ​​foo​​​，但 TypeScript 编译时会报错，提示我们 ​​window​​​ 上不存在 ​​foo​​ 属性。

此时我们可以使用 ​​as any​​​ 临时将 ​​window​​​ 断言为 ​​any​​ 类型：

(window as any).foo = 1;

在 ​​any​​ 类型的变量上，访问任何属性都是允许的。

需要注意的是，将一个变量断言为 ​​any​​ 可以说是解决 TypeScript 中类型问题的最后一个手段。

它极有可能掩盖了真正的类型错误，所以如果不是非常确定，就不要使用 ​​as any​​。

上面的例子中，我们也可以通过[扩展 window 的类型（TODO）][]解决这个错误，不过如果只是临时的增加 ​​foo​​​ 属性，​​as any​​ 会更加方便。

总之，一方面不能滥用 ​​as any​​​，另一方面也不要完全否定它的作用，我们需要在类型的严格性和开发的便利性之间掌握平衡（这也是 ​​TypeScript 的设计理念​​之一），才能发挥出 TypeScript 最大的价值。

9.2.4、将 any 断言为一个具体的类型

在日常的开发中，我们不可避免的需要处理 ​​any​​ 类型的变量，它们可能是由于第三方库未能定义好自己的类型，也有可能是历史遗留的或其他人编写的烂代码，还可能是受到 TypeScript 类型系统的限制而无法精确定义类型的场景。

遇到 ​​any​​​ 类型的变量时，我们可以选择无视它，任由它滋生更多的 ​​any​​。

我们也可以选择改进它，通过类型断言及时的把 ​​any​​ 断言为精确的类型，亡羊补牢，使我们的代码向着高可维护性的目标发展。

举例来说，历史遗留的代码中有个 ​​getCacheData​​​，它的返回值是 ​​any​​：

function getCacheData(key: string): any {
    return (window as any).cache[key];
}

那么我们在使用它时，最好能够将调用了它之后的返回值断言成一个精确的类型，这样就方便了后续的操作：

function getCacheData(key: string): any {
    return (window as any).cache[key];
}

interface Cat {
    name: string;
    run(): void;
}

const tom = getCacheData('tom') as Cat;
tom.run();

上面的例子中，我们调用完 ​​getCacheData​​​ 之后，立即将它断言为 ​​Cat​​​ 类型。这样的话明确了 ​​tom​​​ 的类型，后续对 ​​tom​​ 的访问时就有了代码补全，提高了代码的可维护性。

9.3、类型断言的限制

本小节的前置知识点：[结构类型系统（TODO）][]、[类型兼容性（TODO）][]

从上面的例子中，我们可以总结出：

• 联合类型可以被断言为其中一个类型
• 父类可以被断言为子类
• 任何类型都可以被断言为 any
• any 可以被断言为任何类型

那么类型断言有没有什么限制呢？是不是任何一个类型都可以被断言为任何另一个类型呢？

答案是否定的——并不是任何一个类型都可以被断言为任何另一个类型。

具体来说，若 ​​A​​​ 兼容 ​​B​​​，那么 ​​A​​​ 能够被断言为 ​​B​​​，​​B​​​ 也能被断言为 ​​A​​。

下面我们通过一个简化的例子，来理解类型断言的限制：

interface Animal {
    name: string;
}
interface Cat {
    name: string;
    run(): void;
}

let tom: Cat = {
    name: 'Tom',
    run: () => { console.log('run') }
};
let animal: Animal = tom;

我们知道，TypeScript 是结构类型系统，类型之间的对比只会比较它们最终的结构，而会忽略它们定义时的关系。

在上面的例子中，​​Cat​​​ 包含了 ​​Animal​​​ 中的所有属性，除此之外，它还有一个额外的方法 ​​run​​​。TypeScript 并不关心 ​​Cat​​​ 和 ​​Animal​​​ 之间定义时是什么关系，而只会看它们最终的结构有什么关系——所以它与 ​​Cat extends Animal​​ 是等价的：

interface Animal {
    name: string;
}
interface Cat extends Animal {
    run(): void;
}

那么也不难理解为什么 ​​Cat​​​ 类型的 ​​tom​​​ 可以赋值给 ​​Animal​​​ 类型的 ​​animal​​ 了——就像面向对象编程中我们可以将子类的实例赋值给类型为父类的变量。

我们把它换成 TypeScript 中更专业的说法，即：​​Animal​​​ 兼容 ​​Cat​​。

当 ​​Animal​​​ 兼容 ​​Cat​​ 时，它们就可以互相进行类型断言了：

interface Animal {
    name: string;
}
interface Cat {
    name: string;
    run(): void;
}

function testAnimal(animal: Animal) {
    return (animal as Cat);
}
function testCat(cat: Cat) {
    return (cat as Animal);
}

这样的设计其实也很容易就能理解：

• 允许​​animal as Cat​​ 是因为「父类可以被断言为子类」，这个前面已经学习过了
• 允许​​cat as Animal​​ 是因为既然子类拥有父类的属性和方法，那么被断言为父类，获取父类的属性、调用父类的方法，就不会有任何问题，故「子类可以被断言为父类」

需要注意的是，这里我们使用了简化的父类子类的关系来表达类型的兼容性，而实际上 TypeScript 在判断类型的兼容性时，比这种情况复杂很多，详细请参考[类型的兼容性（TODO)][]章节。

总之，若 ​​A​​​ 兼容 ​​B​​​，那么 ​​A​​​ 能够被断言为 ​​B​​​，​​B​​​ 也能被断言为 ​​A​​。

同理，若 ​​B​​​ 兼容 ​​A​​​，那么 ​​A​​​ 能够被断言为 ​​B​​​，​​B​​​ 也能被断言为 ​​A​​。

所以这也可以换一种说法：

要使得 ​​A​​​ 能够被断言为 ​​B​​​，只需要 ​​A​​​ 兼容 ​​B​​​ 或 ​​B​​​ 兼容 ​​A​​ 即可，这也是为了在类型断言时的安全考虑，毕竟毫无根据的断言是非常危险的。

综上所述：

• 联合类型可以被断言为其中一个类型
• 父类可以被断言为子类
• 任何类型都可以被断言为 any
• any 可以被断言为任何类型
• 要使得​​A​​​ 能够被断言为​​B​​​，只需要​​A​​​ 兼容​​B​​​ 或​​B​​​ 兼容​​A​​ 即可

其实前四种情况都是最后一个的特例。

9.4、双重断言

既然：

• 任何类型都可以被断言为 any
• any 可以被断言为任何类型

那么我们是不是可以使用双重断言 ​​as any as Foo​​ 来将任何一个类型断言为任何另一个类型呢？

interface Cat {
    run(): void;
}
interface Fish {
    swim(): void;
}

function testCat(cat: Cat) {
    return (cat as any as Fish);
}

在上面的例子中，若直接使用 ​​cat as Fish​​​ 肯定会报错，因为 ​​Cat​​​ 和 ​​Fish​​ 互相都不兼容。

但是若使用双重断言，则可以打破「要使得 ​​A​​​ 能够被断言为 ​​B​​​，只需要 ​​A​​​ 兼容 ​​B​​​ 或 ​​B​​​ 兼容 ​​A​​ 即可」的限制，将任何一个类型断言为任何另一个类型。

若你使用了这种双重断言，那么十有八九是非常错误的，它很可能会导致运行时错误。

除非迫不得已，千万别用双重断言。

9.5、类型断言 vs 类型转换

类型断言只会影响 TypeScript 编译时的类型，类型断言语句在编译结果中会被删除：

function toBoolean(something: any): boolean {
    return something as boolean;
}

toBoolean(1);
// 返回值为 1

在上面的例子中，将 ​​something​​​ 断言为 ​​boolean​​ 虽然可以通过编译，但是并没有什么用，代码在编译后会变成：

function toBoolean(something) {
    return something;
}

toBoolean(1);
// 返回值为 1

所以类型断言不是类型转换，它不会真的影响到变量的类型。

若要进行类型转换，需要直接调用类型转换的方法：

function toBoolean(something: any): boolean {
    return Boolean(something);
}

toBoolean(1);
// 返回值为 true

9.6、类型断言 vs 类型声明

在这个例子中：

function getCacheData(key: string): any {
    return (window as any).cache[key];
}

interface Cat {
    name: string;
    run(): void;
}

const tom = getCacheData('tom') as Cat;
tom.run();

我们使用 ​​as Cat​​​ 将 ​​any​​​ 类型断言为了 ​​Cat​​ 类型。

但实际上还有其他方式可以解决这个问题：

function getCacheData(key: string): any {
    return (window as any).cache[key];
}

interface Cat {
    name: string;
    run(): void;
}

const tom: Cat = getCacheData('tom');
tom.run();

上面的例子中，我们通过类型声明的方式，将 ​​tom​​​ 声明为 ​​Cat​​​，然后再将 ​​any​​​ 类型的 ​​getCacheData('tom')​​​ 赋值给 ​​Cat​​​ 类型的 ​​tom​​。

这和类型断言是非常相似的，而且产生的结果也几乎是一样的——​​tom​​​ 在接下来的代码中都变成了 ​​Cat​​ 类型。

它们的区别，可以通过这个例子来理解：

interface Animal {
    name: string;
}
interface Cat {
    name: string;
    run(): void;
}

const animal: Animal = {
    name: 'tom'
};
let tom = animal as Cat;

在上面的例子中，由于 ​​Animal​​​ 兼容 ​​Cat​​​，故可以将 ​​animal​​​ 断言为 ​​Cat​​​ 赋值给 ​​tom​​。

但是若直接声明 ​​tom​​​ 为 ​​Cat​​ 类型：

interface Animal {
    name: string;
}
interface Cat {
    name: string;
    run(): void;
}

const animal: Animal = {
    name: 'tom'
};
let tom: Cat = animal;

// index.ts:12:5 - error TS2741: Property 'run' is missing in type 'Animal' but required in type 'Cat'.

则会报错，不允许将 ​​animal​​​ 赋值为 ​​Cat​​​ 类型的 ​​tom​​。

这很容易理解，​​Animal​​​ 可以看作是 ​​Cat​​ 的父类，当然不能将父类的实例赋值给类型为子类的变量。

深入的讲，它们的核心区别就在于：

• ​​animal​​​ 断言为​​Cat​​​，只需要满足​​Animal​​​ 兼容​​Cat​​​ 或​​Cat​​​ 兼容​​Animal​​ 即可
• ​​animal​​​ 赋值给​​tom​​​，需要满足​​Cat​​​ 兼容​​Animal​​ 才行

但是 ​​Cat​​​ 并不兼容 ​​Animal​​。

而在前一个例子中，由于 ​​getCacheData('tom')​​​ 是 ​​any​​​ 类型，​​any​​​ 兼容 ​​Cat​​​，​​Cat​​​ 也兼容 ​​any​​，故

const tom = getCacheData('tom') as Cat;

等价于

const tom: Cat = getCacheData('tom');

知道了它们的核心区别，就知道了类型声明是比类型断言更加严格的。

所以为了增加代码的质量，我们最好优先使用类型声明，这也比类型断言的 ​​as​​ 语法更加优雅。

9.7、类型断言 vs 泛型

本小节的前置知识点：​​泛型​​

还是这个例子：

function getCacheData(key: string): any {
    return (window as any).cache[key];
}

interface Cat {
    name: string;
    run(): void;
}

const tom = getCacheData('tom') as Cat;
tom.run();

我们还有第三种方式可以解决这个问题，那就是泛型：

function getCacheData<T>(key: string): T {
    return (window as any).cache[key];
}

interface Cat {
    name: string;
    run(): void;
}

const tom = getCacheData<Cat>('tom');
tom.run();

通过给 ​​getCacheData​​​ 函数添加了一个泛型 ​​<T>​​​，我们可以更加规范的实现对 ​​getCacheData​​​ 返回值的约束，这也同时去除掉了代码中的 ​​any​​，是最优的一个解决方案。

十、问号与叹号

 十一、常量类型

在定义变量时可以指定变量的类型为某1个或多个常量，变量的值只能取常量值，如：

//常量 类型

let age:88;  //约束age的值只能是88

age=88;
//age=87.9;  //错误

let sex:"男"|"女";  //sex只允许是男或女
sex="男";
sex="女";

let obj:{name:"tom"}={
    name:"tom"
};