Interface in TS

Interface

Interface understanding

An interface is the state of an object （ attribute ） And behavior （ Method ） An abstract description of ; It's a norm , constraint , Ability

  interface Iperson {
    readonly name: string; // name Is a read-only property 
    age: number;
    sex?: string; // sex It's an optional property 
  }

  const introduce = function (person: Iperson) {
    if (person.age < 18) {
      person.age = 20;
    }
    person.sex = "male";
    return person;
  };

  console.log(introduce({ name: " Zhang San ", age: 16 }));

Variables cannot be modified and used const , Attribute cannot be modified and used readonly

Interfaces can inherit from other interfaces

interface IStr{
str:string
}
interface INum{
num:number
}
interface Icom extends IStr,INum{}

application

Constraints on normal objects

interface IPerson{
name:string;
age:number
gender:string
}

const person:IPerson={name:"luca",age:20,gender:"male"}

Use interfaces to represent function types

To represent function types using interfaces , We need to define a call signature for the interface ; It's like a function definition that specifies the types of parameters and return values . Each parameter in the parameter list needs a name and type

Define an interface , Specify the parameter type and return value type of the function

  interface IFun {
    (str1: string, str2: string): boolean;
  }

  const isExist: IFun = function (str1: string, str2: string) {
    return str1.includes(str2);
  };

  isExist(" I will kill you ", " volume ");

Class implementation interface （ Use interface constraint classes ）

Class can implement an interface , You can also implement multiple interfaces （ A class is constrained by multiple interfaces ）, The content in the interface needs to be really implemented （ Functions in the class need

It should be realized 、 There are content ）

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

  //  Define a class , Use IFly Interface to constrain this class 
  class Person implements IFly {
    fly() {
      console.log("i belive i can fly");  //  Implementation of interface content 
    }
  }

  const person = new Person();
  person.fly();

  interface IBelieve {
    believe();
  }

  interface several extends IFly, IBelieve {}
  //   class Person2 implements IFly, IBelieve {
  class Person2 implements several {
    believe() {
      console.log("i believe what i believe");
    }
    fly() {
      console.log("i can fly");
    }
  }

  const person2 = new Person2();
  person2.fly();
  person2.believe();