dattiloscritto: ‘lascia risultato: {[key: t [K]: t} = {};’ non funziona, come posso digitare il mio oggetto in base ai generici?

voglio digitare una semplice funzione chiamata keyBy.

ciò che questa funzione fa è di convertire un array of objects in object basato su ‘stringa chiave’ fornita:

const arr = [{ name: 'Jason', age: 18 }, { name: 'Amy', age: 25 }];

console.log(keyBy(arr, 'name'));

// => { 'Jason': { name: 'Jason', age: 18 }, 'Amy': { name: 'Amy', age: 25 } }

ora, ecco una semplice implementazione corretta javascript senza dattiloscritto.

function keyBy(arr, key) {
  let result = {};

  arr.forEach(obj => {
    result[obj[key]] = obj;
  });

  return result;
}

in questo momento, di seguito è riportata la mia versione dattiloscritta di keyBy (non compilare):

function keyBy<T, K extends keyof T>(arr: T[], key: K): { [key: T[K]]: T } { // typescript yells: An index signature parameter type must be 'string' or 'number'. let result: { [key: T[K]]: T } = {}; arr.forEach(item => { result[item[key]] = item; }); return result; }

ecco lo screenshot del mio VSCode:

enter image description here

come posso digitare correttamente questa funzione keyBy?

EN From: Typescript: `let result: { [key: T[K]]: T } = {};` is not working, how can I type my object based on generics?

More similar articles:

6 Comments

  1. per utilizzare le proprietà chiave con nome, è necessario in anziché ::

    { [key in K]: T }

    è inoltre necessario utilizzare K, che è un tipo di unione stringa di nomi di proprietà, non T[K], che è il valore della proprietà.

    1. grazie, Voglio fare un’altra domanda, quindi K è 'name' | 'age' tipo di unione stringa in questo momento, che cosa sarà [key in K] diventare?

  2. il valore di name: 'Jason' non esiste nel sistema di tipo, quindi non c’è modo di fare che fortemente digitato.

  3. nel pensare si può fare anche in qualche altro modo:

    export type Omit<A extends object, K extends keyof A> = Pick<A, Exclude<keyof A, K>>
    
    type KeyOf<T extends Array<any>> = { [K: string]: Omit<T[number], 'name'> };
    
    type Result = KeyOf<[{ name: 'a', attr: 42 }, { name: 'b', attr: 42}, {name: 'c', attr: 42}]>

    omit util restituirà l’interfaccia senza un tasto, in questo caso ‘name’.

    T[number] quando T estende Array restituirà X

    e K essere sempre una stringa perché se oggetto ordinario.

    parco giochi area giochi

Leave a Reply

Your email address will not be published. Required fields are marked *