TypeScript入门笔记

ts语言编译后是js文件，完全兼容js代码

如果以符合js但是不符合ts的语法编写，是可以通过编译和运行的。 

定义变量类型

 基本数据类型定义

let num: number;//定义number类型变量
let name: string;//定义string类型变量
let isShow = true;//声明时赋值为boolean就是boolean类型

//两种定义数组的方式
let ArrayNum: number[];
let ArrayString: Array<string>;

//元组，固定长度
let yuanZu: [string, number];

//枚举
enum Gender { Male = 0, Female = 1 };
let gen: number = Gender.Male;

 固定变量值（final）

let finalNum: 100;
let finalNums: 100 | 200 | 300;//固定值只能为这三个

 类型别名

//类型别名
type myNum = 1 | 2 | 3;
let age: myNum;//let age: 1 | 2 | 3;

任意类型 （跟js一样，不做类型判断，可以赋值给任意变量）

let anyNum: any;
let anyNum2;// 隐式any

未知类型（不能赋值给别人，安全的any） 

let unkownNum: unknown;

 类型断言，强转类型 as,<>

let unkownNum: unknown;
unkownNum as string;
unkownNum = "str"
let isUnkown = <boolean>unkownNum;

函数定义

冒号后面加类型就定义了参数和函数的返回值类型

function sum(a: number, b: number): number{
	return a + b;
}

 void

function fun1() {
}
function fun2():void {
}

定义函数

fun3包含两个number类型参数，返回类型boolean

let fun3: (word1: number, word2: number) => boolean;

 

对象定义

{属性名：属性值}

let person: { name: string, age?: number }//?表示可选参数
person = { name: "Z" };

let comments: { name: string, [words: string]: any }//表示任意数量任意类型属性
comments = { name: "Y", word1: "1", word2: true }

 类

定义类和属性

class Person{
	//定义实例属性（只有new对象之后才有
	name: string = "Z";
	//定义类属性（静态属性，可以直接获取
	static age: number = 20;
	Walk() {
	}
	static Run() {
	}
}
//new类
let person = new Person();
//获取实例属性
person.name;
//获取静态属性
Person.age;

 静态属性和方法（可以直接调用）

    //定义类属性（静态属性，可以直接获取
	static age: number = 20;
	static Walk() {
	}

实例属性和方法（需要new对象后才能调用）

    //定义实例属性（只有new对象之后才有
	name: string = "Z";
	Walk() {
	}

调用静态

//获取静态属性
Person.age;
Person.Walk();

调用实例方法和参数

//new类
let person = new Person();
//获取实例属性
person.name;
person.Walk();

构造函数（无需定义属性时就赋值）

在new对象时对对象属性赋值，this指的是创建出来（new）的这个对象本身

new对象就是调用对象的constructor方法

class Person {
	name: string;
	age: number;
	constructor(name: string, age: number) {
		this.name = name;
		this.age = age;
	}
}
//new类
let person = new Person("Z", 19);

super

调用父类的构造函数，添加新参数

//子类中
constructor(name: string, age: number, addr: string){
    //调用父类的构造函数先，父类里面只有2个
    super(name, age);
    this.addr = addr;
}

调用父类方法

super.fun1();

抽象类（不能创建为对象，只能继承）

abstract class Person{
}

抽象方法（没有方法体，子类必须重写该方法，只能在抽象类中定义）

abstract Walk(): void;

ts也有继承和get()set()方法（与java相同）

class Person extends People{
}

class people{
	private name: string;
	constructor(name: string) {
		this.name = name;
	}
	get Name() {
		return this.name;
	}
	set Name(value: string) {
		this.name = value;
	}
}

泛型

可变参数类型等

//T表示任意类型，调用时什么类型就是什么，可以有多个<T,K>
function fun5<T>(value: T): T{//参数和返回值类型都是T相同的
	return value;
}
//这样就设置T为number类型
fun5(5);
//指定泛型类型string
fun5<string>("5");

可以规定泛型的范围

//设置泛型T继承Inter接口
function fun5<T extends Inter>(value: T): void{
}