Quel est le type d'enregistrement dans le tapuscrit?

Que Record<K, T>signifie dans Typescript?

Typescript 2.1 a introduit le Recordtype, en le décrivant dans un exemple:

// 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>

voir Typescript 2.1

Et les types avancés la page mentionne Recordsous les types cartographiées rubrique à côté Readonly, Partialet Pick, dans ce qui semble être sa définition:

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

Readonly, Partial et Pick sont homomorphes alors que Record ne l'est pas. Un indice que Record n'est pas homomorphe est qu'il ne prend pas de type d'entrée pour copier les propriétés:

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

Et c'est tout. Outre les citations ci-dessus, il n'y a aucune autre mention de Recordsur typescriptlang.org .

Des questions

1. Quelqu'un peut-il donner une définition simple de ce que Recordc'est?

2. Est-ce Record<K,T>simplement une façon de dire "toutes les propriétés de cet objet auront un type T"? Probablement pas toutes les propriétés, car elles Kont un but ...

3. Le Kgénérique interdit-il les clés supplémentaires sur l'objet qui ne le sont pas K, ou les autorise-t-il et indique-t-il simplement que leurs propriétés ne sont pas transformées en T?

4. Avec l'exemple donné:

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

Est-ce exactement la même chose?:

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

1. Quelqu'un peut-il donner une définition simple de ce que Recordc'est?

A Record<K, T>est un type d'objet dont les clés de propriété sont Ket dont les valeurs de propriété sont T. Autrement dit, keyof Record<K, T>équivaut à Ket Record<K, T>[K]équivaut (fondamentalement) à T.

2. Est-ce Record<K,T>simplement une façon de dire "toutes les propriétés de cet objet auront un type T"? Probablement pas tous les objets, car ils Kont un but ...

Comme vous le notez, Ka un but ... de limiter les clés de propriété à des valeurs particulières. Si vous voulez accepter toutes les clés à valeur de chaîne possibles, vous pouvez faire quelque chose comme Record<string, T>, mais la manière idiomatique de le faire est d'utiliser une signature d'index comme { [k: string]: T }.

3. Le Kgénérique interdit-il les clés supplémentaires sur l'objet qui ne le sont pas K, ou les autorise-t-il et indique-t-il simplement que leurs propriétés ne sont pas transformées en T?

Cela n'interdit pas exactement les clés supplémentaires: après tout, une valeur est généralement autorisée à avoir des propriétés non explicitement mentionnées dans son type ... mais elle ne reconnaîtrait pas que de telles propriétés existent:

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

et il les traiterait comme des propriétés excédentaires qui sont parfois rejetées:

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

et parfois accepté:

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

4. Avec l'exemple donné:

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

   Est-ce exactement la même chose?:

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

Oui!

J'espère que cela pourra aider. Bonne chance!

Un enregistrement vous permet de créer un nouveau type à partir d'une union. Les valeurs de l'Union sont utilisées comme attributs du nouveau type.

Par exemple, disons que j'ai un syndicat comme celui-ci:

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

Maintenant, je veux créer un objet qui contient des informations sur tous les chats, je peux créer un nouveau type en utilisant les valeurs de CatName Union comme clés.

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

Si je veux satisfaire cette CatList, je dois créer un objet comme celui-ci:

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

Vous obtenez une sécurité de type très forte:

• Si j'oublie un chat, j'obtiens une erreur.
• Si j'ajoute un chat qui n'est pas autorisé, j'obtiens une erreur.
• Si je change plus tard CatNames, j'obtiens une erreur. Ceci est particulièrement utile car CatNames est probablement importé d'un autre fichier, et probablement utilisé dans de nombreux endroits.

Exemple de React dans le monde réel.

Je l'ai utilisé récemment pour créer un composant Status. Le composant recevrait un accessoire d'état, puis rendrait une icône. J'ai beaucoup simplifié le code ici à des fins d'illustration

J'avais un syndicat comme celui-ci:

type Statuses = "failed" | "complete";

J'ai utilisé ceci pour créer un objet comme celui-ci:

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

Je pourrais ensuite rendre en déstructurant un élément de l'objet en accessoires, comme ceci:

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

Si l'union Statuses est ultérieurement étendue ou modifiée, je sais que mon composant Status échouera à se compiler et j'obtiendrai une erreur que je peux corriger immédiatement. Cela me permet d'ajouter des états d'erreur supplémentaires à l'application.

Notez que l'application réelle contenait des dizaines d'états d'erreur référencés à plusieurs endroits, ce type de sécurité était donc extrêmement utile.