ts之基本类型，联合类型，函数，类的概念

1.ts中基础类型

数字 字符串 布尔 数组 元组 any never void null undefined 枚举

1.最基础的就是数字 字符串 布尔

number 和 大Number的区别 js特性 装箱的概念 xxx.xxx，string,boolean同理

let num1: number = 1;
let num2: Number = 1; // 用来描述实例的 类也可以当做类型
let num3: number = Number(1)
let num4: Number = new Number(1);

元组 ts中自己实现的 内容固定 类型固定

const tuple: [string, boolean, number] = ['a', true, 1];

枚举类型 ts最终编译成js 是没有类型的， 只是在开发时候使用的

const enum ROLE { // 大写是规范  加上const后 不会生成一个对象（更简洁）
    USER,
    ADMIN = 5,
    MANAGER
}

void表示函数返回值的 也可以描述变量 void的值只能赋予null和undefined

接口中定义类中原型方法的void 表示不关心返回值类型，在实现的时候可以在次确定类型，函数是确定死了

function getVoid(): void { 
    return 
}

2.ts中的联合类型在这里插入代码片

联合类型 如果不进行初始化操作 必须要给类型 否则都是any

let numOrStr: string | number;
numOrStr = 'abc';
numOrStr = 123;

如果类型过于复杂，我希望后续复用 我们可以把类型单独提取出来

type IType = 'a' | 'b' | 'c' | 'd'; // 类型别名
let type: IType = 'b'
let typ2: IType = 'c'

3.ts中的函数

函数 对函数增加类型 对函数的参数进行类型校验 对函数的返回值进行类型检验，也可以对函数本身来校验

函数关键字 写完后会对当前函数自动推断类型

function sum1(x: number, y: string): string { // 函数 括号后面的是返回值类型
    return x + y;
}

1.可以自动根据当前等号右边的内容 推断左边的类型
2.我们可以指定类型 赋予一个可以兼容这个类型的函数
3.函数会自动推倒返回值类型

type IFn = (a: number, b: number) => number
type IFn1 = (a:number,b:number) => number
const sum2:IFn  = (x: number, y: number) => { // 我发现这个函数兼容指定的类型 即可赋值
    return x + y
}
sum2(1, 2);

? 表示参数可以传递或者不传递，但是y的类型 可以是number | undefined

const sum3 = (x: number, y?: number, ...args: number[]): number => {
    return x + (y as number);
}

sum3(123, 1, 2, 3, 4);

4.ts中类的概念

实例属性、方法 new xxx来调用，静态属性、方法 就是通过类.xxx , 原型属性和方法

class Pointer {
     public x:number 
    public y:number  // 声明的变量会被增加到实例上
   // 传入的实例直接就放在实例上，无需再次声明  
  constructor(public x:number,public y:number){ // 在constructor中的操作都是初始化操作
      this.x = x;
       this.y = y;
    }
}
let pointer = new Pointer(100,100)
//实例属性的属性和方法调用
console.log(pointer.y,pointer.x)

属性修饰符

1. public 是属性修饰符 public 表示自己 和 子类 和子类之外都可以访问到
2. protected 只有自己和 自己的后辈能访问
3. private 就是只有自己能访问的属性

我们可以给构造函数添加修饰符 如果被标识成 protected 说明不能被new 了, 如果表示成 private 说明不能继承了，同时也不能被new

readonly 仅读 （const） 如果在初始化完毕后不能在修改了 如果是对象可以更改属性

class Animal {
    public readonly n: number = 1
    //被protected 修饰，不能在被new了，只能被继承
    protected constructor(public name: string, public age: number) {
        console.log(this.name)
    }
    static type = '哺乳动物'; // 静态属性 es7语法
    static get type1(){ // 属性访问器  es6的写法
         return '哺乳动物'
    }
    static getName() {
        return '动物'
    }
    say() {
        console.log('父 ')
    }
}

静态方法可以被继承 ， super 默认在构造函数中和静态方法中都指向自己的父类, 在原型方法中super指向父类的原型

class Cat extends Animal {
    constructor(name: string, age: number, public readonly address: string) {
        super(name, age); // Animal.call(this,name,age)
        console.log(this.name)
    }
    static type = '猫科动物';
    static getName() {
        console.log(super.getName())
        return '猫'
    }
    say() { // 原型方法中的super指向的是父类的原型
        super.say()
    }
    private str: string = '';
    get content() {
        return this.str
    }
    set content(newVal: string) {
        this.str = newVal
    }
}