ts语法中的一些难记点

叁歲伎倆 2022-09-16 11:28 163阅读 0赞

## 1、接口类型中的任意属性 ##

一旦定义了任意属性，那么确定属性和可选属性的类型都必须是它的子集。实例代码：

interface Person{
        name: string;
        age?:number;   // 报错，应该是string类型
        [propName: string]:string
    }
    
    //正确如下
    interface Person{
        name: string;
        age?:number;
        [propName: string]:any;
    }
    
    //或者如下
    interface Person{
        name: string;
        age?:number;
        [propName: string]:string | number;
    }

## 2、只读属性 ##

初始化的时候，给只读属性赋值，不是在使用的是 赋值

interface Person{
        readonly id:number;
        name: string;
        age?: number;
        [propName: string]: any
    }
    
    let tom: Person = {
        id: 123,
        name: 'tom',
        gender: 'male'
    }

## 3、数组的定义 ##

let instance: number[] = [1,2,3,4,5]
    
    
    //或者如下定义
    
    let instance: Array<number> = [2,3,4,5,6]
    
    // 存放任意类型的数据
    let instance: any[] = [1,'2',3,'4',5]

## 4、函数中的一些难点 ##

let mySum: (x:number,y:number) => number = function(x:number,y:number):number{
        return x+y;
    }

函数重载：允许一个函数接收不同数量或者类型的参数时，做出不同的处理

function reverse(x: number):string;
    
    function reverse(x: string):string;
    
    function reverse(x: number | string):number | string{
        if(typeof x === 'number'){
            return Number(x.toString().split('').reverse().join(''))
        }else if(typeof x === 'string'){
            return x.split('').reverse().join('')
        }
    }

## 5、枚举类型 ##

enum  Days {Sun, Mon, Tue, Wed, Thu, Fri, Sat};
    
    console.log(Days['Sun'] === 0)   //true
    console.log(Days['Nom'] === 1)   //true
    console.log(Days['Tue'] === 2)   //true
    console.log(Days['Fri'] === 5)   //true
    
    console.log(Days[0] === 'Sun')   //true
    console.log(Days[1] === 'Mon')   //true
    console.log(Days[2] === 'Tue')   //true
    console.log(Days[6] === 'Sat')   //true

enum  Days {Sun=7, Mon=1, Tue, Wed, Thu, Fri, Sat};
    
    console.log(Days['Sun'] === 7)   //true
    console.log(Days['Mon'] === 1)   //true
    
    console.log(Days['Tue'] === 2)   //true
    console.log(Days['Wed'] === 3)   //true
    console.log(Days['Thu'] === 4)   //true
    console.log(Days['Fri'] === 5)   //true
    console.log(Days['Sat'] === 6)   //true
    
    // 如果开始定义的时候，只给Sun=7，那么 Mon=9，Tue=10...以此类推

## 6、类 ##

类有3种访问修饰符：public、private、protect，

public   修饰的属性或者方法是公有的，可以在任何地方被访问到，默认所有的属性和方法是public;

private 修饰的属性或者方法是私有的，不能在声明它的类的外部访问，不能在子类中被访问；

protect 修饰的属性或者方法是受保护的，和private类似，区别是它在子类中是可以被访问到的。

class Animal {
        private name;
        public constructor(name){
            this.name = name
        }
    }
    
    let a = new Animal('Jack');
    console.log(a.name);      //报错   name是私有属性，不能在实例中访问
    
    // 需要注意的是，typescript编译之后的代码中，并没有限制 private 属性在外部的可访问性

class Animal {
        private name;
        public constructor(name){
            this.name = name
        }
    }
    
    class Cat extends Animal {
        constructor(name){
            super(name);
            console.log(this.name); //报错
        }
    }
    
    // 下面的定义是可以的
    class Animal {
        protect name;
        public constructor(name){
            this.name = name
        }
    }
    
    class Cat extends Animal {
        constructor(name){
            super(name);
            console.log(this.name); //可以访问
        }
    }

当构造函数被修饰为 private时，不允许被继承和实例化；当构造函数被修饰为 protect时，该类只允许被继承，不允许被实例化

class Animal {
        public name;
        private constructor(name){
            this.name = name;
        }
    }
    
    class Cat extends Animal{
        constructor(name){
            super(name); //报错
        }
    }
    
    let a = new Animal('Jack');  //报错

抽象类， abstract 用于定义抽象类和其中的抽象方法，抽象类不允许被实例化。

abstract class Animal {
        public name;
        public constructor(name){
            this.name = name
        }
        public abstract sayHi();
    }
    
    let a = new Animal('Jack')   //报错

抽象类只能由子类去继承

abstract class Animal {
        public name;
        public constructor(name){
            this.name = name
        }
        public abstract sayHi();
    }
    
    class Cat extends Animal {
        public eat()
    }