Pourquoi ne puis-je pas assigner un U à un Partial<T> lorsque T étend U ?

Question

Par exemple :

interface U {
  u: boolean;
}

const f = <T extends U>() => {
  const t: Partial<T> = {u: true};
};

J'obtiens l'erreur suivante :

Type '{ u: true; }' is not assignable to type 'Partial<T>'.ts(2322)

Lien vers l'aire de jeux

Existe-t-il un moyen de résoudre ce problème sans faire de casting ?

Answer 1

Le problème dont se plaint TypeScript est le suivant :

Type '{ u: true; }' is not assignable to type 'Partial<T>'.ts(2322)

votre fonction f pourrait être appelé avec :

f<{ u: boolean, v: boolean }>(); // ok since U is "implemented" but not "v"

Cela ouvre la possibilité que votre générique et votre implémentation concrète d'un objet à l'intérieur de la fonction { u: true } pourraient différer.

Le compilateur TypeScript ne vous oblige pas à définir le même type que celui qu'il étend, vous êtes toujours en mesure de spécifier une implémentation plus spécifique de U tant que U est entièrement fourni (dans ce cas, le drapeau booléen u ).

Voici quelques solutions possibles :

Utiliser le Type-Cast (comme précédemment) :

interface U {
  u: boolean;
}

const f = <T extends U>() => {
  const t: Partial<T> = {u: true} as Partial<T>;
};

f<U>();

Les inconvénients : { u: true } pourrait très bien être remplacée par : { v: true } ce qui peut entraîner des problèmes de non-définition plus tard dans votre code.

Essayez de reformuler votre fonction

Pour indiquer au compilateur d'utiliser exactement le type U vous pouvez, si possible, essayer de reformuler la fonction et de déplacer la constante t comme paramètre de la fonction.

interface U {
  u: boolean;
}

const f = <T>(u: T) => {
  const t: Partial<T> = u;
};

f<{ u: boolean }>({ u: true });

Déterminer si les génériques sont pertinents

Votre fonction requiert un type générique, mais le corps de la fonction assigne un type concret, ce qui cause le problème ici. Vous pourriez vous demander si les types génériques sont pertinents dans ce cas. Une alternative sans générique serait :

interface U {
  u: boolean;
}

const f = () => {
  const t: Partial<U> = {u: true};
};

f();