Tipos de desestructuración de objetos

122

Esta

const { foo: IFoo[] } = bar;

y esto

const { foo: Array<IFoo> } = bar;

causará razonablemente un error.

Y esto

const { foo: TFoo } = bar;

simplemente desestructurará la TFoopropiedad.

¿Cómo se pueden especificar tipos para propiedades de objetos desestructurados?

typescript destructuring

— Matraz Estus
fuente

Buena pregunta, pero ¿no va a poder inferir el tipo de la definición de bartodos modos?

2

Esto se cubre bastante bien aquí .

El comentario @ user663031 debe eliminarse ya que es engañoso.

— Sasuke Uchiha

@SasukeUchiha El artículo no está disponible, pero la mayoría de los artículos se pueden buscar en Google por título. Se movió a mariusschulz.com/blog/… . De hecho, arroja algo de luz.

— Estus Flask

Eso es útil. Gracias.

— Sasuke Uchiha

189

Resulta que es posible especificar el tipo después :de todo el patrón de desestructuración:

const {foo}: {foo: IFoo[]} = bar;

Que en realidad no es mejor que el viejo

const foo: IFoo[] = bar.foo;

— artem
fuente

2

Pero {foo}no es un valor. Es lo que generalmente se llama un "patrón de asignación de deconstrucción". Lo que está viendo aquí es en realidad una función especial de TypeScript que permite asociar tipos de patrones con dichos patrones.

De hecho, es más como un caso especial, especialmente en comparación con el let x, y, z: stringque aparentemente especifica el tipo zsolo para . Actualicé la respuesta.

— Artem

55

Claramente llego un poco tarde a la fiesta, pero:

interface User {
  name: string;
  age: number;
}

const obj: any = { name: 'Johnny', age: 25 };
const { name, age }: User = obj;

Los tipos de propiedades namey agedeben inferirse correctamente stringy numberrespectivamente.

— Stephen Paul
fuente

9

Es un caso raro en el que le gustaría usar una interfaz para cada destrucción.

— RA.

2

Un seguimiento de mi propia pregunta.

No es necesario especificar tipos para las propiedades del objeto porque se infieren a partir de un objeto desestructurado.

Teniendo en cuenta que barse escribió correctamente, foose deducirá el tipo:

const bar = { foo: [fooValue], ... }; // bar type is { foo: IFoo[], ... }
...
const { foo } = bar; // foo type is IFoo[]

Incluso si barno se escribió correctamente ( anyo unknown), su tipo se puede afirmar:

const { foo } = bar as { foo: IFoo[] }; // foo type is IFoo[]

— Matraz Estus
fuente