2
votes

Supprimer une clé dynamique d'un objet TypeScript

Dans TypeScript, il est assez simple de cloner un objet:

const a = {... b}

ou cloner et mettre à jour

const a = {... b, c: 'd'}

Par exemple, j'ai ce code:

const a = {
    'something': 1,
    'e': 2,
};
const c = 'something';
delete a[c];

javascript typescript ecmascript-6 ecmascript-5 ecma

2 commentaires

Je pense que vous cherchez const {[c]: _, ... withootC} = a;

ah, génial. Pourriez-vous ajouter une réponse et expliquer comment cela fonctionne, c'est ce que j'ai recherché

3 Réponses :

-1
votes

Bien sûr! Vous pouvez le faire en utilisant Omit type:

type Omit<T, K> = Pick<T, Exclude<keyof T, K>>

type DeleteBar = Omit<{bar: 123, baz: 123}, 'bar'> // {baz: 123}

P.S. J'ai réalisé que vous aviez peut-être posé des questions sur les valeurs, pas sur les types. Vous auriez probablement dû poser des questions sur javascript, pas sur dactylographié.

1 commentaires

cela ne fonctionne pas vraiment, pourriez-vous s'il vous plaît me faire savoir comment cela fonctionne dans ce cas: const a = {'something': 1, 'e': 2,}; const c = 'quelque chose'; supprimer un [c];

2
votes

Plutôt que de supprimer la propriété de a , utilisez une affectation déstructurée pour créer un nouvel objet sans cette propriété:

const exclude = <T>(map: { [k: string]: T }, omitted: string[]): { [k: string]: T } =>
  return Object.getOwnPropertyNames(a)
    .filter(k => omitted.indexOf(k) >= 0)
    .reduce((a, k) => (a[k] = map[k], a), {})
};
var b = exclude(a, ["c"]);

Après ce b code > contiendra tous les membres de a sauf c.

Étant donné que a est un type, disons, {c: string, d: string} les types de c et b seront déduits comme étant string et {d: string} respectivement. Bien sûr, si vous devez écrire explicitement ces annotations de type, utilisez un type Omit comme @Nurbol Alpybayev a> suggère est généralement beaucoup mieux que d'avoir à épeler les types sous forme longue.

Vous pouvez renommer c pour éviter les conflits avec un autre nom en utilisant cette syntaxe: p >

const {c: someOtherName, ...b} = a;

La méthode ci-dessus fonctionnera si vous connaissez le nom de la propriété au moment de la compilation. Si ce n'est pas le cas dans votre scénario, alors le compilateur TypeScript ne peut pas vraiment vous aider car il ne pourra pas déterminer le type de résultat de l'opération.

Vous seriez mieux loti taper a comme {[k: string]: number} , auquel cas supprimer un [c] serait bien, ou vous pourriez utiliser quelque chose comme ce qui suit:

const {c, ...b} = a;

5 commentaires

Vraiment proche, mais dans mon cas, c'est un peu plus compliqué. Par exemple: const a = {'quelque chose': 1, 'e': 2,}; const c = 'quelque chose'; const {'quelque chose': indéfini, ... b} = a; fonctionne, mais const a = {'quelque chose': 1, 'e': 2,}; const c = 'quelque chose'; const {c: undefined, ... b} = a; ne le fait pas

donc le point ici est c n'est pas une chaîne 'c' . C'est une variable const c = 'quelque chose' . J'espère que cette fois c'est assez clair

@NguyenPhongThien Je ne sais toujours pas si je comprends le problème. Si la propriété que vous souhaitez supprimer est connue au moment de la compilation, ma méthode fonctionnera. Si le nom de la propriété n'est pas connu au moment de la compilation, le type de résultat de l'expression ne peut pas être déterminé (sauf pour les types mappés comme {[k: string]: number} ).

non, ce n'est pas du tout un problème. Je trouve une meilleure façon de cloner un objet et d'en supprimer une clé, au lieu de const a = {... b}; supprimer un [c]; et un peu plus tard b = {... a} . Parce que je ne veux pas muter l'objet d'origine pendant un certain temps. Mais si ce n'est pas possible, ce ne sera toujours pas un gros problème

@NguyenPhongThien J'ai ajouté une solution de plus qui est plus idiomatique que const a = {... b}; supprimer un [c]; .

7
votes

Vous recherchez une combinaison de noms de propriétés calculés et de déstructuration. Plus d'informations ici

const a = {
    'something': 1,
    'e': 2,
};

const c = 'something';

const { [c]: _, ...withoutC } = a;

Ici, nous mettons la valeur de la propriété quelque chose (prise de la variable c ) dans la variable _ et toutes les autres les accessoires vont à la variable withoutC . Le fait que c défini comme const permet à dactylographié de déduire correctement le type de withoutC .

0 commentaires