TypeScript的接口

骑猪看日落 2022-09-01 09:12 255阅读 0赞

TypeScript 的核心原则之一是对值所具有的结构进行类型检查。我们使用接口（Interfaces）来定义对象的类型。`接口是对象的状态(属性)和行为(方法)的抽象(描述)`

在 TypeScript 中，我们使用接口（Interfaces）来定义对象的类型  
接口: 是对象的状态(属性)和行为(方法)的抽象(描述)  
接口类型的对象  
    多了或者少了属性是不允许的  
    可选属性: ?  
    只读属性: readonly

(() => {
        interface IPerson {
            // readonly 设置，此属性为只读属性
            readonly id: number
            name: string
            age: number
            // ? 代表这个属性可有可无
            sex?: string
        }
        // 定义一个对象，该对象的类型是我定义的接口IPerson
        const person: IPerson = {
            id: 1,
            name: 'tom',
            age: 20,
            // sex: '男'
        }
        person.sex = '女';
        // person.id = 111;   // id在只读的状态下，这个状态是不能修改的
    })()

## 函数类型 ##

接口能够描述 JavaScript 中对象拥有的各种各样的外形。 除了描述带有属性的普通对象外，接口也可以描述函数类型。

为了使用接口表示函数类型，我们需要给接口定义一个调用签名。它就像是一个只有参数列表和返回值类型的函数定义。参数列表里的每个参数都需要名字和类型。

(() => {
        // 函数类型
    
        // 定义一个函数，用来作为某个函数的类型使用
        interface ISearchFunc {
            (source: string, subString: string): boolean
        }
        // 定义一个函数，该类型是上面定义的接口
        const searchString: ISearchFunc = function (source: string, subString: string): boolean {
            // 在source字符串中查找subString字符串
            return source.search(subString) > -1
        }
    
        // 调用函数
        console.log(searchString('113345511', '11'))
    })()

### 类类型 ###

// 类 类型：类的类型可以通过接口来实现
    (() => {
        // 定义一个接口
        interface IFly {
            // 该方法没有任何的实现（方法中什么都没有）
            fly(): any
        }
        // 定义一个类 这个类的类型就是上面定义的接口(实际上也可以理解为，IFly接口约束了当前的这个Person类)
        class Person implements IFly {
            // 实现接口中的方法
            fly() {
                console.log('111')
            }
        }
        const person = new Person();
        person.fly()
    
        // 定义一个接口
        interface ISwim {
            swim(): any
        }
        // 定义一个类，这个类的类型就是IFly和ISwin(当前这个类可以实现多个接口，一个类同同时可以被多个接口进行约束)
        class Person2 implements IFly, ISwim {
            fly() {
                console.log('fly');
    
            }
            swim() {
                console.log('swim');
            }
        }
        const person2 = new Person2();
        person2.fly()
        person2.swim()
    
        // 总结：类可以通过接口的方式来定义当前类的类型
        // 类可以实现一个接口，类也可以实现多个接口，要注意，接口中的内容都要真正实现
    
        // 定义额一个接口，可以继承其他的多个接口
        interface IMyFlyAndSwim extends IFly, ISwim { }
        // 定义一个类直接实现IMyFlyAndSwim这个接口
        class Person3 implements IMyFlyAndSwim {
            fly() {
                console.log('fly3');
            }
            swim() {
                console.log('swim');
            }
        }
        const person3 = new Person3()
        person3.fly()
        person3.swim()
    
        // 总结：接口和接口之间叫继承（使用的是extends关键字），类和接口之间叫实现（使用的是implements）
    })()

这个就是接口内的涉及方法。