TypeScript接口

TypeScript的核心原则之一是对值所具有的类型进行检查。
使用接口定义对象的类型，接口是对象属性和方法的描述
接口：是一种类型、一种规范、一个能力、一种约束

可选属性

• 可定义接口里的属性不一定必须，语法属性?

interface IPerson {
    
        firstName: string
        lastName?: string //非必须属性
} 

只读属性

• 可定义接口里的属性为只读，不可更改，语法readonly 属性

interface IPerson {
    
		readonly id: number //只读属性
        firstName: string
        lastName: string
} 

函数类型

• 函数类型：定义一个接口，作为函数的类型
• 使用接口表示函数的类型，需要给接口定义一个调用签名
• 调用签名：像是一个只有参数列表和返回值类型的函数定义。参数列表中的每个参数都需要名字和类型

        //定义一个接口，用来作为函数的类型
        interface ISearchFunc {
    
            //定义一个调用签名
            (source: string, subStr: string): boolean
        }
    
        //定义一个函数，类型为上面的接口
        const searchString: ISearchFunc = function (source: string, subStr: string): boolean{
    
            return source.search(subStr) > -1
        }
    
        //调用函数
        console.log(searchString('天上的风筝', '风')); //true

类类型

• 类类型：通过接口实现了类的类型，用来明确的强制一个类去符合某种契约

    //定义一个接口
    interface IFly {
    
        fly() //该方法没有任何的实现
    }

    //定义一个类，其类型为上面定义的那个接口
    class Person implements IFly {
    
        //实现接口中的方法
        fly() {
    
            console.log('飞飞飞');
            
        }
    }

    //实例化对象
    const person = new Person
    person.fly()

类和接口的关系不叫继承，叫实现

• 一个类可以实现多个接口

    interface ISwim {
    
        swim()
    }
    class Person2 implements IFly,ISwim {
    
        fly() {
    
            console.log('飞2');
            
        }
        swim() {
    
            console.log('游泳2');
            
        }
    }
    const person2 = new Person2
    person2.fly()
    person2.swim()

类可以实现一个接口，可以实现多个接口，注意接口的内容都要真正的实现

• 一个接口可以继承多个接口

    interface IAll extends IFly, ISwim {
    }
    //定义一个类，直接实现继承后的接口
    class Person3 implements IAll {
    
        fly() {
    
            console.log('飞3');
            
        }
        swim() {
    
            console.log('游泳3');
            
        }
    }
    const person3 = new Person3
    person3.fly()
    person3.swim()

总结：接口和接口之间叫继承（使用extends关键字），类和接口之间叫实现（使用implements关键字）