Tipi di destrutturazione degli oggetti

122

Questo

const { foo: IFoo[] } = bar;

e questo

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

causerà ragionevolmente un errore.

E questo

const { foo: TFoo } = bar;

destrutturerà solo la TFooproprietà.

Come possono essere specificati i tipi per le proprietà degli oggetti destrutturati?

typescript destructuring

— Fiaschetta Estus
fonte

Bella domanda, ma non sarà comunque in grado di inferire il tipo dalla definizione di bar?

2

Questo è coperto abbastanza bene qui .

Il commento @ user663031 deve essere rimosso in quanto fuorviante.

— Sasuke Uchiha,

@SasukeUchiha L'articolo non è disponibile, ma la maggior parte degli articoli può essere cercata su Google in base al titolo dell'articolo. È stato spostato su mariusschulz.com/blog/… . Fa davvero luce.

— Estus Flask

Questo è utile. Grazie.

— Sasuke Uchiha

189

Risulta che è possibile specificare il tipo dopo :per l'intero pattern destrutturante:

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

Che in realtà non è migliore del semplice vecchio

const foo: IFoo[] = bar.foo;

— artem
fonte

2

Ma {foo}non è un valore. È quello che di solito viene chiamato "modello di assegnazione decostruttiva". Quello che vedete qui è in realtà una speciale funzione TypeScript che consente di associare tipi di modelli a tali modelli.

In effetti, è più simile a un caso speciale, soprattutto rispetto al let x, y, z: stringquale apparentemente specifica zsolo il tipo . Ho aggiornato la risposta.

— artem

55

Sono chiaramente un po 'in ritardo alla festa, ma:

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

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

I tipi di proprietà namee agedevono essere correttamente dedotti a stringe numberrispettivamente.

— Stephen Paul
fonte

9

È un raro caso in cui desideri utilizzare un'interfaccia per ogni distruzione.

— RA.

2

Un seguito alla mia stessa domanda.

Non è necessario specificare i tipi per le proprietà degli oggetti perché vengono dedotti da oggetti destrutturati.

Considerando che è barstato digitato correttamente, il footipo verrà dedotto:

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

Anche se barnon è stato digitato correttamente ( anyo unknown), il suo tipo può essere affermato:

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

— Fiaschetta Estus
fonte