Qual è il tipo di record in dattiloscritto?

Cosa Record<K, T>significa in dattiloscritto?

Typescript 2.1 ha introdotto il Recordtipo, descrivendolo in un esempio:

// For every properties K of type T, transform it to U
function mapObject<K extends string, T, U>(obj: Record<K, T>, f: (x: T) => U): Record<K, U>

vedi dattiloscritto 2.1

E la tipi avanzati pagina menziona Recordsotto i Tipi mappati voce al fianco Readonly, Partiale Pick, in quello che sembra essere la sua definizione:

type Record<K extends string, T> = {
    [P in K]: T;
}

Di sola lettura, Parziale e Pick sono omomorfi, mentre Record non lo è. Un indizio che Record non è omomorfo è che non richiede un tipo di input per copiare le proprietà da:

type ThreeStringProps = Record<'prop1' | 'prop2' | 'prop3', string>

E questo è tutto. Oltre alle citazioni di cui sopra, non c'è altra menzione Recordsu typescriptlang.org .

Domande

1. Qualcuno può dare una semplice definizione di ciò che Recordè?

2. È Record<K,T>semplicemente un modo di dire "tutte le proprietà su questo oggetto avranno tipo T"? Probabilmente non tutte le proprietà, dal momento che Kha qualche scopo ...

3. Il Kgenerico proibisce chiavi aggiuntive sull'oggetto che non lo sono Ko le consente e indica semplicemente che le loro proprietà non vengono trasformate T?

4. Con l'esempio fornito:

    type ThreeStringProps = Record<'prop1' | 'prop2' | 'prop3', string>

È esattamente lo stesso di questo ?:

    type ThreeStringProps = {prop1: string, prop2: string, prop3: string}

1. Qualcuno può dare una semplice definizione di ciò che Recordè?

A Record<K, T>è un tipo di oggetto le cui chiavi di proprietà sono Ke i cui valori di proprietà sono T. Cioè, keyof Record<K, T>è equivalente a Ked Record<K, T>[K]è (sostanzialmente) equivalente a T.

2. È Record<K,T>semplicemente un modo di dire "tutte le proprietà su questo oggetto avranno tipo T"? Probabilmente non tutti gli oggetti, dal momento che Kha qualche scopo ...

Come notate, Kha uno scopo ... limitare le chiavi di proprietà a valori particolari. Se vuoi accettare tutte le possibili chiavi con valori di stringa, potresti fare qualcosa di simile Record<string, T>, ma il modo idiomatico di farlo è quello di utilizzare una firma indice come { [k: string]: T }.

3. Il Kgenerico proibisce chiavi aggiuntive sull'oggetto che non lo sono Ko le consente e indica semplicemente che le loro proprietà non vengono trasformate T?

Non "proibisce" esattamente le chiavi aggiuntive: dopo tutto, a un valore è generalmente consentito di avere proprietà non esplicitamente menzionate nel suo tipo ... ma non riconoscerebbe l'esistenza di tali proprietà:

declare const x: Record<"a", string>;
x.b; // error, Property 'b' does not exist on type 'Record<"a", string>'

e li tratterebbe come proprietà in eccesso che a volte vengono rifiutate:

declare function acceptR(x: Record<"a", string>): void;
acceptR({a: "hey", b: "you"}); // error, Object literal may only specify known properties

e talvolta accettato:

const y = {a: "hey", b: "you"};
acceptR(y); // okay

4. Con l'esempio fornito:

   type ThreeStringProps = Record<'prop1' | 'prop2' | 'prop3', string>

   È esattamente lo stesso di questo ?:

   type ThreeStringProps = {prop1: string, prop2: string, prop3: string}

Sì!

Spero che aiuti. In bocca al lupo!

Un record consente di creare un nuovo tipo da un'Unione. I valori nell'Unione sono usati come attributi del nuovo tipo.

Ad esempio, supponiamo che io abbia un'Unione come questa:

type CatNames = "miffy" | "boris" | "mordred";

Ora voglio creare un oggetto che contenga informazioni su tutti i gatti, posso creare un nuovo tipo usando i valori nell'Unione CatName come chiavi.

type CatList = Record<CatNames, {age: number}>

Se voglio soddisfare questa CatList, devo creare un oggetto come questo:

const cats:CatList = {
  miffy: { age:99 },
  boris: { age:16 },
  mordred: { age:600 }
}

Ottieni una sicurezza di tipo molto forte:

• Se dimentico un gatto, ricevo un errore.
• Se aggiungo un gatto non consentito, viene visualizzato un errore.
• Se in seguito cambio CatNames, ricevo un errore. Ciò è particolarmente utile perché CatNames è probabilmente importato da un altro file e probabilmente utilizzato in molti luoghi.

Esempio di React nel mondo reale.

L'ho usato di recente per creare un componente Status. Il componente riceve un oggetto di stato e quindi visualizza un'icona. Ho semplificato molto il codice qui a scopo illustrativo

Ho avuto un sindacato come questo:

type Statuses = "failed" | "complete";

L'ho usato per creare un oggetto come questo:

const icons: Record<
  Statuses,
  { iconType: IconTypes; iconColor: IconColors }
> = {
  failed: {
    iconType: "warning",
    iconColor: "red"
  },
  complete: {
    iconType: "check",
    iconColor: "green"
  };

Potrei quindi renderlo destrutturando un elemento dall'oggetto in oggetti di scena, in questo modo:

const Status = ({status}) => <Icon {...icons[status]} />

Se il sindacato Statuses verrà successivamente esteso o modificato, so che il mio componente Status non verrà compilato e verrà visualizzato un errore che posso risolvere immediatamente. Ciò mi consente di aggiungere ulteriori stati di errore all'app.

Si noti che l'app effettiva aveva dozzine di stati di errore a cui era stato fatto riferimento in più punti, quindi questo tipo di sicurezza era estremamente utile.