Typescript interface

TypeScript One of the core principles of the is to check the type of the value .
Use interfaces to define the types of objects , Interfaces are descriptions of object properties and methods
Interface ： It's a type of 、 A specification 、 An ability 、 A constraint

Optional attribute

• Attributes in a definable interface do not have to be , grammar attribute ?

interface IPerson {
    
        firstName: string
        lastName?: string // Non mandatory attributes 
} 

Read-only property

• The attributes in the interface can be defined as read-only , Non modifiable , grammar readonly attribute

interface IPerson {
    
		readonly id: number // Read-only property 
        firstName: string
        lastName: string
} 

Function type

• Function type ： Define an interface , Type as function
• Use an interface to represent the type of a function , You need to define a call signature for the interface
• Call signature ： It is like a function definition with only parameter list and return value type . Each parameter in the parameter list needs a name and type

        // Define an interface , Type used as a function 
        interface ISearchFunc {
    
            // Define a call signature 
            (source: string, subStr: string): boolean
        }
    
        // Define a function , The type is the above interface 
        const searchString: ISearchFunc = function (source: string, subStr: string): boolean{
    
            return source.search(subStr) > -1
        }
    
        // Call function 
        console.log(searchString(' Kite in the sky ', ' wind ')); //true

Class types

• Class types ： The class type is implemented through the interface , Used to explicitly force a class to conform to a contract

    // Define an interface 
    interface IFly {
    
        fly() // This method has no implementation 
    }

    // Define a class , Its type is the interface defined above 
    class Person implements IFly {
    
        // Implement the methods in the interface 
        fly() {
    
            console.log(' Flying ');
            
        }
    }

    // Instantiate objects 
    const person = new Person
    person.fly()

The relationship between classes and interfaces is not called inheritance , It's called realizing

• A class can implement multiple interfaces

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

Class can implement an interface , Multiple interfaces can be implemented , Pay attention to the real implementation of the interface contents

• An interface can inherit multiple interfaces

    interface IAll extends IFly, ISwim {
    }
    // Define a class , Directly implement the inherited interface 
    class Person3 implements IAll {
    
        fly() {
    
            console.log(' fly 3');
            
        }
        swim() {
    
            console.log(' swimming 3');
            
        }
    }
    const person3 = new Person3
    person3.fly()
    person3.swim()

summary ： Interfaces and interfaces are called inheritance （ Use extends keyword ）, Between classes and interfaces is called implementation （ Use implements keyword ）