título de primer nivel
1. Introducción a la interfaz
¿Qué es la interfaz?
Una interfaz es una abstracción del estado y comportamiento de un objeto . Es un tipo, es una especificación, es una capacidad, también es una restricción.
Para los estudiantes que no saben mucho sobre tyoescript, si quieren entender la interfaz por primera vez, es posible que no puedan entender su significado, no importa. Descubramos lentamente el misterio de la interfaz a través de un requisito
/*
需求:
创建人的对象, 需要对人的属性进行一定的约束
id是number类型, 必须有, 只读的
name是string类型, 必须有
age是number类型, 必须有
sex是string类型, 可以没有
*/
//2、定义一个接口，该接口作为person对象的类型使用，此时可以限定或者约束该对象中的属性数据
interface IPerson{
//此时代表id是只读的，是number类型的，readonly修饰符只能写在属性之前
readonly id: number
name: string
age: number
//此时代表sex是可选属性：可以写也可以不写
？ sex: string
}
//1、定义一个对象，该对象的类型就是定义的接口IPerson
const person1: IPerson = {
//此时IPerson 会报错：“找不到名称：IPerson ”
id: 1,
name: 'tom',
age: 20,
？ sex: '男'
}
Lo anterior es el caso más básico sobre la interfaz. Ahora es posible que aún tenga algunas dudas. Está bien. Miremos hacia abajo lentamente y ordenemos algunos conocimientos sobre la interfaz lentamente.
Conceptos básicos y definiciones de interfaces
Uno de los principios básicos de TypeScript es la verificación de tipo de la estructura que tiene un valor. Usamos interfaces (Interfaces) para definir el tipo de objeto, lo que puede facilitar la descripción de propiedades y métodos.
Interfaz: es un tipo, es una especificación, es una capacidad, también es una restricción, que se utiliza para la abstracción (descripción) del estado (atributo) y el comportamiento (método) del objeto . En el caso anterior, usamos la interfaz IPerson para imponer algunas restricciones a los atributos de person1, que es la interfaz
propiedades en la interfaz
- a. Atributo obligatorio: una vez agregado a la interfaz, significa un atributo requerido
//示例：
name: string
age: number
- b. Atributos opcionales: no se requieren todos los atributos de la interfaz. Algunos solo están presentes bajo ciertas condiciones, o no están presentes en absoluto. ¿usar? modificador
//使用语法：
？ sex: '男'
- c. Atributos de solo lectura: algunos atributos de objetos solo se pueden modificar cuando el objeto se acaba de crear. con modificador de solo lectura
//使用语法：
readonly id: number
//补充内容：
/*
const VS readonly
做为变量使用的话用 const，若做为属性则使用 readonly
*/
Características de la interfaz
- 1. No está permitido escribir más o menos atributos: el verificador de tipos verificará si los atributos dentro del objeto son consistentes con la descripción de la interfaz IPerson, y si son inconsistentes, generará un error de tipo
- 2. Atributos de solo lectura: (Algunos atributos de objetos solo pueden modificar sus valores cuando el objeto se acaba de crear) El modificador de solo lectura debe agregarse antes del atributo
- 3. Atributos opcionales: (No todos los atributos en la interfaz son obligatorios. Algunos solo existen bajo ciertas condiciones, o no existen en absoluto)? Modificador, que debe agregarse antes del atributo
- 4. Atributo obligatorio: una vez agregado a la interfaz, significa un atributo requerido
2. Tipo de función de descripción de interfaz
Además de describir objetos ordinarios con propiedades, las interfaces también pueden describir tipos de funciones.
Las interfaces pueden describir los tipos de parámetros de función y los tipos de retorno
También lo implementamos con un estuche.
Para usar una interfaz para representar un tipo de función, necesitamos definir una firma de llamada para la interfaz. Es como una definición de función con solo una lista de parámetros y un tipo de retorno. Cada parámetro de la lista de parámetros requiere un nombre y un tipo.
/*
需求：定义一个函数mySearch，用以查找第一个参数中是否存在第二个参数，返回结果为一个布尔值。参数为字符串，返回结果为布尔值
*/
//1、定义一个接口，用来作为某个函数的类型使用
interface SearchFunc {
//定义一个调用签名
(source:string,substring:string):boolean//它就像是一个只有参数列表和返回值类型的函数定义。参数列表里的每个参数都需要名字和类型。
}
//2、定义一个函数，需要满足定义的接口
const mySearch: SearchFunc = function (source: string, sub: string): boolean {
return source.search(sub) > -1//从source这个字符串中查找sub字符串
}
console.log(mySearch('abcd', 'bc'))
¿Encontró que la función de descripción de la interfaz es muy simple de implementar, es tan simple y alcanzable?
3. El tipo de clase de descripción de interfaz
TypeScript también puede usar interfaces para hacer cumplir explícitamente una clase para cumplir con un contrato determinado
clase implementa una interfaz
- gramática:
用interface定义接口，用implements描述类的类型
- Caso de implementación:
//1、定义一个接口
interface IFly{
//该方法没有任何的实现
fly()
}
//2、定义一个类，这时这个类的类型就是上面的接口定义的(也可以理解为IFly接口约束了当前的Person类)
class Person implements IFly{
//实现接口中的方法
fly(){
console.log("我相信我可以")
}
}
//实现类：实例化对象
const person = new Person()
person.fly()
Una clase implementa múltiples interfaces.
- Descripción gramatical:
用interface定义接口，implements描述类的类型，多个接口用“，”隔开
- Implementación del caso:
//1、定义多个个接口
interface IFly{
//该方法没有任何的实现
fly()
}；
interface ISwim{
//该方法没有任何的实现
swim()
}
//2、定义一个类：这个类的类型就是IFly和ISwim（一个类同时被多个接口约束）
class Person implements IFly,ISwim{
//实现接口中的方法，必须要真正实现才会不报错
fly(){
console.log("我相信我可以")
}
swim()(){
console.log(“我是真的可以”)
}
}
//3、实例化对象
const person = new Person()
person.fly()
person.swim()
interfaz hereda interfaz
- Descripción gramatical:
使用extends关键字实现继承
作用：优化一个类描述多个接口一直使用“，”的缺陷
- Implementación del caso:
/*
需求：
在上述函数的基础上：由一个新接口来实现已经存在的IFly和ISwim接口，再由Person来实现对新接口的描述。
作用：优化一个类描述多个接口一直使用“，”的缺陷
*/
//接口可以继承其他的多个接口
//1、定义了一个ALL接口，继承了其他的接口
interface ALL extends IFly，ISwim{
}
//2、定义一个类，直接实现ALL接口
class Person implements ALL{
//实现接口中的方法，必须要真正实现才会不报错
fly(){
console.log("我相信我可以")
}
swim()(){
console.log(“我是真的可以”)
}
}
//3、实例化对象
const person = new Person()
person.fly()
person.swim()
Lo anterior es todo el contenido del tipo de clase de descripción de interfaz.
4. Resumen
接口是对象的状态(属性)和行为(方法)的抽象(描述), es un tipo, una especificación, una capacidad y una restricción- La interfaz tiene atributos como atributos obligatorios, atributos de solo lectura (readonly) y atributos opcionales (?), etc.
- Además de describir objetos ordinarios con propiedades, las interfaces también pueden describir tipos de funciones y tipos de clases.
- Al describir el tipo de una clase, una clase puede implementar una interfaz o múltiples interfaces. Cabe señalar que el contenido de la interfaz debe implementarse verdaderamente.
- Al describir el tipo de una clase, la relación entre la interfaz y la interfaz se llama herencia (usando la palabra clave extends), y la relación entre la clase y la interfaz se llama implementación (usando la palabra clave implements)