TS学习总结

1：数据类型

布尔类型 boolean
数字类型 number
字符串类型 string
数组类型 array
元组类型 tuple
枚举类型 enum
任意类型 any
null 和 undefined
void类型
never类型

数组的三种写法：

可以定义好数组每一项的类型，比如number第一张写法，而不确定的时候可以定义为any类型，

// 数组的三种写法：

const arr1:number[] = [1,2,3]
console.log("arr1===",arr1)

const arr2:Array<number> = [1,2,3]
console.log("arr2===",arr2)

const arr3:any[] = [1,'2',true]
console.log("arr3===",arr3)

元组类型：属于数组的一种，而元组类型就相当于数字的每一项以及长度都是固定的

// 元组类型：属于数组的一种
const arr4:[string,number] = ['1',2]
console.log("arr4===",arr4)

** 枚举：**enum类型是对JavaScript标准数据类型的一个补充。 像C#等其它语言一样，使用枚举类型可以为一组数值赋予友好的名字。大概意思就是事先考虑到每一变量可能取的值，尽量用表达的含义清楚简单的的单词来表示每一个值，而这种方法叫枚举方法，用这种方法定义的类型就叫枚举类型。

// 枚举
// enum 枚举名称 {
//   标识符[=整型常数],
//   标识符[=整型常数],
//   ...
//   标识符[=整型常数],
// }

enum Hjp {
  age = 1,
  height = 2,
}
let p: Hjp = Hjp.age;
console.log(p);

任意类型 他可以解决很多场景，比如我们处理一个元素节点,使用object就会提示错误

never类型
never类型表示的是那些永不存在的值的类型。 例如， never类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型； 变量也可能是 never类型，当它们被永不为真的类型保护所约束时。

never类型是任何类型的子类型，也可以赋值给任何类型；然而，没有类型是never的子类型或可以赋值给never类型（除了never本身之外）。 即使 any也不可以赋值给never。

类

// ES5的类
function Es5Class {
  this.name = 'hejinpeng';
  this.age = '24';
}
const H = new Es5Class();
console.log(p.name)

// ES5构造函数 和 原型链 里面增加方法
function Es5Class {
  this.name = 'hejinpeng';
  this.age = '24';
  this.work = function(){
    console.log(this.name);
  }
}
Es5Class.prototype.sex = 'man'
Es5Class.prototype.run = function(){
  console.log(this.name + "会跑");
}
const test = new Es5Class();
test.work()
// 原型链上面的方法可以被实例共享，但是构造函数的不会；

// ES5增加静态方法
function Es6Class{
  this.name = 'hjp';
  this.age = 24;
  this.work = function(){
    console.log(this.name);
  }
}
Es6Class.getInfo = function(){
  console.log('我是getInfo');
};
// 使用静态方法
Es6Class.getInfo()

TS里面定义类

// TS里面定义类

class TsClsss{
  name:string;
  constructor(name:string){
    this.name = name;
  }
  work():void{
    console.log(this.name);
  }
}
//使用new构造了TsClsss这个类的一个实例，他会调用TsClsss里面定义的构造函数，
// 创建一个TsClsss类型的对象t，并且执行构造函数初始化t
const t = new TsClsss("鹏鹏子");
t.work();

继承
在TypeScript里，我们可以使用常用的面向对象模式。 基于类的程序设计中一种最基本的模式是允许使用继承来扩展现有的类。

// ts继承
class Animal {
    name:string;
    constructor(name:string){ 
       this.name = name;
    }
    run():void{
      console.log(this.name);
    }
}

class Dog extends Animal {
  constructor(name:string){ 
    // 构造函数和super都要有；super 相当于 调用父类的构造函数
      super(name); 
   }
}
const test3 = new Dog('zhansan');
test3.run();

类从基类中继承了属性和方法。 这里， Dog是一个 派生类，它派生自 Animal 基类，通过 extends关键字。 派生类通常被称作 子类，基类通常被称作 超类。因为 Dog继承了 Animal的功能，因此我们可以创建一个 Dog的实例，它能够run()。
派生类包含了一个构造函数，它 必须调用 super()，它会执行基类的构造函数。 而且，在构造函数里访问 this的属性之前，我们 一定要调用 super()。 这个是TypeScript强制执行的一条重要规则。

TS的 静态属性 和 静态方法

// TS的 静态属性 和 静态方法
class Person{
  public name:string;
  constructor(name:string){
    this.name = name
  }
  run(){ //  实例方法
    console.log(this.name+'can run');
  }
  worl(){//  实例方法
    console.log(this.name +"can work")
  }
  static eat(){//  静态方法
    console.log(this.name + "can eat");
  }
}
const test4 = new Person("鹏鹏子");
test4.run();   //  使用实例方法
Person.eat();  //  使用静态方法