摘要：基础静态类型非常简单，只要在声明变量的后边加一个:号，然后加上对应的类型。例如：const count : number=88;const myName：string='蜡笔小新'类似这样常用的基础类型还有，null,undefind,symbol,boole

基础静态类型和对象类型

基础静态类型 非常简单，只要在声明变量的后边加一个:号，然后加上对应的类型。例如：
const count : number=88;
const myName：string='蜡笔小新'
类似这样常用的基础类型还有，null,undefind,symbol,boolean,void
对象类型
①经典对象类型，如下：
const lbxx: {
name: string
age: number
} = {
name: "蜡笔小新",
age: 18,
};
②对象类型也可以是数组，如下：
const users: String = ["蜡笔小新", "犬夜叉", "樱桃小丸子"];
③对象类型也可以是类，如下：
class Person { }
// lbxx 必须是一个 Person 实例化的对象
const lbxx: Person=new Person;
④对象类型可以是函数类型，并确定返回值，如下：
const getName: => string = => {
return "蜡笔小新";
};
总结：对象类型形式：对象类型，数组类型，类类型，函数类型

函数参数和返回类型注解

函数无返回值时定义方法
没有返回值的函数，我们就可以给他一个类型注解void，代表没有任何返回值
function sayHello: void {
console.log("hello world");
}
never 返回值类型
如果一个函数是永远也执行不完的，就可以定义返回值为never，比如执行的时候，抛出了异常，这时候就无法执行完了，如下：
function errorFuntion: never {
throw new Error;
console.log("Hello World");
}
还有一种就是死循环，如下：
function forNever: never {
while (true) {}
console.log("Hello JSPang");
}
函数参数为对象（解构）时使用类型注解
function add({ one, two }: { one: number, two: number }): number {
return one+two;
}
const three=add({ one: 1, two: 2 });

数组类型的定义

单一数据类型数组的定义
const numberArr: number = [1, 2, 3];
const stringArr: string = ["a", "b", "c"];
const undefinedArr: undefined = [undefined, undefined];
多种数据类型数组类型注解
const arr: (number|string) = [1, "string", 2];
数组中对象类型的定义
const users: { name: string, age: number } = [
{ name: "蜡笔小新", age: 18 },
{ name: "犬夜叉", age: 28 },
];
这种形式阅读麻烦，并且不便于复用，所有 TypeScript 为我们准备了一个概念，叫做类型别名「type alias」
type User= { name: string, age: Number };
const users: User = [

];
当然我们也可以使用类来作为类型注解约束
class User {
name: string;
age: number;
}

];

interface 接口的使用

我们可以把这重复使用的类型注解，定义成统一的接口，比如：
interface User {
name: string;
age: number;
}
接口和类型别名的区别
类型别名 type 可以直接给类型，也可以给对象类型，如下：
type User=string;
const lbxx: User='蜡笔小新';
接口 interface 必须代表对象，如下：
interface User {
name: string;
age: number;
}
const users: User={ name: "蜡笔小新", age: 18 }
接口非必选值得定义
:号前加一个? 代表当前接口属性是非必选项
interface User {
name: string;
age: number;
like?: string;
}
允许加入任意值
interface User {
name: string;
age: number;
like?: string;
[propname: string]: any;
}
这个的意思是，属性的名字是字符串类型，属性的值可以是任何类型
接口里的方法
接口里不仅可以存属性，还可以存方法，比如：
interface User {
name: string;
age: number;
like?: string;

// 需要注意的是：加了方法后作为类型注解使用时对象必须要有该方法
say: string;
}
接口和类的约束
类可以和接口很好的结合，比如：
class Teacher implements User {
name="蜡笔小新";
age=18;
say {
return"你好，我是蜡笔小新！";
}
}
接口间的继承
接口也可以用于继承的，比如你新写一个Admin接口，继承于User接口。
interface Admin extends User {
admin: string;
}
// 用接口直接约束对象
const qyx: Admin= {
name: "黑猫警长",
age: 18,
say {
return"你好，我是黑猫警长！";
},
admin {
return"我是一个管理员";
},
}

联合类型和类型保护

联合类型
所谓联合类型，可以认为一个变量可能有两种或两种以上的类型，关键符号是|竖线
class MathTeacher {
public compute: void {
console.log('数学老师会计算')
}
}
class EnglishTeacher {
public say: void {
console.log('英语老师说 Hello！')
}
}
function teacherTeach(teacher: MathTeacher|EnglishTeacher): void {}
const lucy=new MathTeacher('Lucy', '乡村小学')
// 这个时候，teacherTeach 这个方法是如何判定 lucy 对象是数学老师还是 英语老师呢？
teacherTeach(lucy)
类型保护 - 类型断言
直接调用联合类型的方法提示异常，因为 teacherTeach 方法不能准确的判断联合类型的具体实例是什么。这时候就需要再引出一个概念叫做类型保护，类型断言就是通过断言的方式确定传递过来的准确值
类型保护 - in /instanceof 语法
class MathTeacher {

}
}

public say: void {

}
}
function teacherTeach(teacher: MathTeacher|EnglishTeacher): void {
if ("compute" in/instanceof teacher) {
teacher.compute
} else {
teacher.say
}
}

teacherTeach(lucy)

enum 枚举类型

使用枚举我们可以定义一些带名字的常量，使用枚举可以清晰地表达意图或创建一组有区别的用例， TypeScript支持数字的和基于字符串的枚举。
// 数字枚举
enum Direction {
Up=1, // 设置初始增长的值 后面递增 +1
Down,
Left,
Right
}
// 字符串枚举
enum Direction {
Up="UP",
Down="DOWN",
Left="LEFT",
Right="RIGHT",
}

泛型的基础使用

泛型在类中的使用

class SelectTeacher {
constructor(privateteachers: T) {}
getOneTeacher(index: number): T {
return this.teachers[index];
}
}
const teachers=new SelectTeacher(["蜡笔小新", "樱桃小丸子", "犬夜叉"]);
console.log(teachers.getOneTeacher(1))
const teachers = new SelectTeacher(["蜡笔小新", "樱桃小丸子", "犬夜叉"])
泛型中的继承
使用extends关键字实现泛型继承
interface Teacher {
name: string;
age: number;
}
class SelectTeacher {
constructor(privateteachers: T) {}

}
}
const teachers=new SelectTeacher([{
name: "蜡笔小新",
age: 18
},{
name: "樱桃小丸子",
age: 28
}])
console.log(teachers.getOneTeacher(0))
泛型约束
泛型可以是任意类型，可以是对象、字符串、布尔、数字都是可以的，如果我们约束泛型为指定的类型，这就叫做泛型约束
interface Teacher {
name: string;
age: number;
}
class SelectTeacher {
constructor(private teachers: T) {}

return this.teachers[index]
}
}

TypeScript 中类的概念和使用

类的基本使用

class Person {
content:"Hi，老铁";
teach {
return"我是一个正常人，想成为一个老师！";
}
}
class Teacher extends Person {
teach {
return super.content+super.teach +"我成为了一个老师，当然可以教点啥了！";
}
}
const lbxx=new Teacher;
console.log(lbxx.teach);

类的访问类型

public 访问属性
在程序里的意思就是允许在类的内部和外部被调用，public 也是类中默认的访问属性
class Person {
public name:string;
}
private 访问属性
private 访问属性的意思是，只允许该类的内部被调用，外部不允许调用
class Person {
private name:string;
public sayHello{
console.log(this.name+'say Hello') //此处不报错
}
}
//-------以下属于类的外部--------
const person=new Person
person.name='蜡笔小新' //此处报错
person.sayHello
console.log(person.name) //此处报错
protected 访问属性
protected 允许在类内及继承的子类中使用
readonly 只读属性
static 静态属性
static声明的属性和方法，不需要进行声明对象，就可以直接使用
class Girl {
static sayLove {
return "I Love you";
}
}
console.log(Girl.sayLove);

构造函数

构造函数的关键字是constructor
在子类中使用构造函数需要用super调用父类的构造函数，子类继承父类并有构造函数的原则，就是在子类里写构造函数时，必须用super调用父类的构造函数，如果需要传值，也必须进行传值操作
class Person{
constructor(public name:string){}
}
class Teacher extends Person{
constructor(name:string, public age:number){
super(name)
}
}
const teacher=new Teacher('樱桃小丸子',18)
console.log(teacher.age)
console.log(teacher.name)

类的 Getter 和 Setter

对私有属性 private 的外部访问，需要使用 Getter
class User {
constructor(private_age:number){}
getage{
return '年龄保密'
}
}
const lbxx=new User(21)
console.log(lbxx.age)
对私有属性 private 的外部加工，需要使用 Setter
class User {
constructor(private_age: number) { }
// 外部访问会主动调用
getage{
return this._age+18
}
// 内部访问会主动调用
setage( age:number ){
this._age = age + 18
}
}
const lbxx=new User(28)

// 在外部设置 年龄 ，将调整逻辑写在外面
lbxx.age=88

abstract 抽象类使用

抽象类的关键词是abstract，里边的抽象方法也是abstract开头的，抽象方法需要在被继承的类中被覆盖重写，并且必须包含这个抽象方法，代表的是一种约束
abstract class Teacher {
constructor(publicname:string, publicschool:string) {}
public abstract skill:void
}
class MathTeacher extends Teacher {
skill {
console.log('数学老师教数学！')
}
public compute: void {
console.log('数学老师会计算')
}
}
class EnglishTeacher extends Teacher {
skill {
console.log('English Teacher taech English ! ')
}
public say: void {
console.log('英语老师说 Hello！')
}
}
const lucy=new MathTeacher('Lucy', '乡村小学')
lucy.skill

来源：敏儿畅谈