Saltar al contenido

Anulación del tipo de propiedad de la interfaz definido en el archivo Typescript d.ts

Siéntete libre de divulgar nuestra web y códigos en tus redes, necesitamos tu ayuda para hacer crecer nuestra comunidad.

Solución:

Uso un método que primero filtra los campos y luego los combina.

referencia Excluir propiedad del tipo

interface A 
    x: string


export type B = Omit &  x: number ;

para interfaz:

interface A 
    x: string


interface B extends Omit 
  x: number

type ModifiedType = Modify

interface ModifiedInterface extends Modify 

Inspirado en ZSkycat extends Omit solución, se me ocurrió esto:

type Modify = Omit & R;

// before [email protected]
type Modify = Pick> & R

Ejemplo:

interface OriginalInterface 
  a: string;
  b: boolean;
  c: number;


type ModifiedType  = Modify

// ModifiedType =  a: number; b: number; c: number; 

Yendo paso a paso:

type R0 = Omit        //  c: number; 
type R1 = R0 & a: number, b: number          //  a: number; b: number; c: number; 

type T0 = Exclude<'a' | 'b' | 'c' , 'a' | 'b'> // 'c'
type T1 = Pick               //  c: number; 
type T2 = T1 & a: number, b: number          //  a: number; b: number; c: number; 

Tipos de utilidades de TypeScript

No puede cambiar el tipo de una propiedad existente.

Puedes agregar una propiedad:

interface A 
    newProperty: any;

Pero cambiando un tipo de uno existente:

interface A 
    property: any;

Resultados en un error:

Las declaraciones de variables subsiguientes deben tener el mismo tipo. La variable 'propiedad' debe ser del tipo 'número', pero aquí tiene el tipo 'cualquiera'

Por supuesto, puede tener su propia interfaz que amplíe una existente. En ese caso, puede anular un tipo solo por un tipo compatible, por ejemplo:

interface A  number;


interface B extends A 
    x: number;


Por cierto, probablemente deberías evitar usar Object como un tipo, en su lugar use el tipo any.

En los documentos para el any escriba dice:

Any type es una forma poderosa de trabajar con JavaScript existente, lo que le permite habilitar y deshabilitar gradualmente la verificación de tipos durante la compilación. Es de esperar que Object desempeñe un papel similar, como lo hace en otros idiomas. Pero las variables de tipo Objeto solo le permiten asignarles cualquier valor; no puede llamar a métodos arbitrarios, incluso a los que realmente existen.:

let notSure: any = 4;
notSure.ifItExists(); // okay, ifItExists might exist at runtime
notSure.toFixed(); // okay, toFixed exists (but the compiler doesn't check)

let prettySure: Object = 4;
prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'.

Ten en cuenta mostrar esta sección si si solucionó tu problema.

¡Haz clic para puntuar esta entrada!
(Votos: 0 Promedio: 0)



Utiliza Nuestro Buscador

Deja una respuesta

Tu dirección de correo electrónico no será publicada.