学习TypeScript8（接口 和别名）

接口

使用interface来定义一种约束，让数据的结构满足约束的格式。

//这样写会报错的，因为person定义了a,b但是对象里面缺少b属性
//使用接口约束的时候不能多一个属性也不能少一个属性
//必须与接口保持一致
interface Person{
	b:string,
	a:string
}
const person:Person={
	a:'213'
}

可选属性使用？操作符

interface Person{
	b?:string,
	a:string
}
const person:Person={
	a:'213'
}

只读属性 readonly

readonly只读属性是不允许被赋值的只能读取

interface Person{
	b?:string,
	a:string，
	readonly c:sting
}
const person:Person={
	a:'213'
}
person.c=123  //这样写会报错，c是只读的不允许重新赋值

TypeScript具有ReadonlyArray类型，它与Array相似，只是把所有可变方法去掉了，因此可以确保数组创建后再也不能修改

let a:number[]=[1,2,3,4];
let ro:ReadonlyArray<number>=a
ro[0] = 12; // error!
ro.push(5); // error!
ro.length = 100; // error!
a = ro; // error!    可以用类型断言重写：a=ro as number[]

readonly vs const

最简单判断该用readonly还是const的方法是看要把它作为变量还是作为一个属性。作为变量使用的话用const，作为属性则似乎用readonly

额外的属性检查（任意属性[propName:string]）

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

interface SquareConfig {
    color?: string;
    width?: number;
}
function createSquare(config: SquareConfig): { color: string; area: number } {
    // ...
}
let mySquare = createSquare({ colour: "red", width: 100 }); //报错
如果一个对象字面量存在任何“目标类型”不包含的属性时，会报错

最简单的方法是使用类型断言

let mySquare = createSquare({ colour: "red", width: 100 }) as SquareConfig

最佳方式是能够添加一个字符串索引签名

interface SquareConfig {
    color?: string;
    width?: number;
    [propName:string]:any //可以有任意数量的属性
}

函数类型

为了使用接口表示函数类型，我们需要给接口定义一个调用签名。它就像是一个只有参数列表和返回值类型的函数定义。参数列表里的每个参数都需要名字和类型。

对于函数类型的类型检查来说，函数的参数名不需要与接口定义的名称相匹配。

interface SearchFunc{
	(source:string,subString:string):boolean;  //函数签名
	cb:()=>void  //属性成员，其类型为一个不接受参数并没有返回值的函数，一个属性，函数类型
	cd():void    //方法成员，其类型为一个不接受参数并没有返回值的函数，一个方法，拥有名为cd方法
}
let mySearch:SearchFunc;
mySearch=function(src:string,sub:string):boolean{
	let result=src.search(sub)
	return result>-1
}

可索引的类型

可索引类型具有一个 索引签名，它描述了对象索引的类型，还有相应的索引返回值类型。

interface StringArray{
	[index:number]:string
}
let myArray:StringArray;
myArray = ["bob","Fred"]
let myStr:string=myArray[0]

TypeScript支持两种索引签名：字符串和数字。可以同时使用两种类型的索引，但是数字索引的返回值必须是字符串索引返回值的子类型。这是因为当使用number来索引时，javascript会将它转换成string然后再去索引对象

字符串索引签名能够很好的描述dictionary模式，并且他们也会确保所有属性与其返回值类型相匹配。

interface NumberDictionary{
	[index:string]:number;
	length:number;//可以，length是number类型
	name:string //错误，‘name’的类型与索引类型返回值的类型不匹配
}

可以将索引签名设置为只读，这样就防止了给索引赋值

interface ReadonluStringArray{
	readonly [index:number]:string
}
let myArray: ReadonlyStringArray = ["Alice", "Bob"];
myArray[2] = "Mallory"; // error!

你不能设置myArray[2]，因为索引签名是只读的。

继承接口

接口可以相互继承。能够从一个接口里复制成员到另一个接口里，可以更灵活地将接口分割到可重用的模块里

interface Shape{
	color:string
}
interface Square extends Shape{
	sideLength:number
}
let square=<Square>{};  //<Square>{} 这个空对象字面量断言为 Square 类型
square.color='blue'
square.sideLength=10;

一个接口可以继承多个接口，创建出多个接口的合成接口

interface Shape{
	color:string
}
interface PenStroke{
	penwidth:number
}
interface Square extends Shape,PenStroke{
	sideLength:number
}
let square = <Square>{};
square.color = "blue";
square.sideLength = 10;
square.penWidth = 5.0;

混合类型

interface Counter{
	(start:number):string;  //函数签名
	 a:number;        //数字类型
	 reset():void    //方法
}
function getCounter():Counter{
	let counter=<Counter>function(start:number){};
	counter.a=123;
	counter.reset = function () { };
	return counter;
}
let c = getCounter();
c(10);
c.reset();
c.a = 5.0;

别名

type s=string
type s=string | number
type s=(name:string)=>void
type s={name:string}
type s=number[]

与接口区别

interface继承可以使用extends，type不可以使用extends，type只能使用交叉类型

interface没有办法写联合类型，而type可以使用联合类型

interface遇见重名的可以合并，type不会

1）interface A extend B{

}
interface B{}
 type s= A & B
 2) teype s=number[] |string
 interface A extend B{
	name:string|number  //interface里面属性可以使用联合类型，外面不可以
}
3）
interface A{
	name:string|number
}
interface A{
	age：number
}

type高阶用法

//extends 包含的意思
//左边的值  会作为右边类型的子类型 1会最为number子类型
//1.any unknow 顶级类型
//2.Object
//3.Number、String、Boolean
//4.number、string、boolean
//5.1、’test‘、true
//6.never

type num =1 extends number ? 1:0    //1
type num =1 extends any ? 1:0    //1
type num =1 extends unknow ? 1:0    //1
type num =1 extends Object ? 1:0    //1
type num =1 extends Number ? 1:0    //1
type num =1 extends never ? 1:0    //0