Início / coding / Perguntas / 76924339
Accepted
Lumin
Asked: 2023-08-18 02:49:41 +0800 CST

Como acesso com segurança um objeto que possui um tipo de união com uma chave não literal?

  • 772

Dado um objeto:

const obj = { a: 1 } as { a: number } | { b: number }
const key = "a" as string

if (key in obj) {
  console.log(obj[key])
  // string cannot be used to index { a: number } | { b: number }
}

Como faço para acessar com segurança obj(sem declaração de tipo)?

Não consigo usar verificações literais

if ("a" in obj) {
   // obj.a is number
}

uma vez que o valor de keynão é pré-determinado.

Link do Playground

typescript

2 respostas

  1. Best Answer

    Infelizmente, o tipo de restrição que você está tentando fazer if (key in obj)é difícil de acertar. Consulte microsoft/TypeScript#34867 para uma discussão oficial sobre isso.

    Atualmente, o TypeScript não pode restringir keyquando você verifica key in obj; isso é solicitado em microsoft/TypeScript#43284 , mas isso interagiria mal com algumas das inrestrições de operador existentes que atuam no tipo de obj.

    Mesmo se o estreitamento de chave fosse implementado, não funcionaria muito bem quando objfosse do tipo union . Em certo sentido, você está tentando restringir ambos keye objao mesmo tempo, de alguma forma correlacionada, de modo que isso key in objimplique que o par [key, obj]é de um tipo como ["a", {a: number}] | ["b", {b: number}].

    Mas não há facilidade no TypeScript para lidar com essas coisas; consulte microsoft/TypeScript#30581 para obter o problema geral com uniões correlacionadas; muitas vezes, eles podem ser refatorados para usar genéricos, conforme descrito em microsoft/TypeScript#47109 , mas, neste caso, não valeria nem remotamente o esforço.

    Provavelmente, minha recomendação aqui é que você deve ampliar o tipo de objpara algo mais passível de indexação com uma chave desconhecida. Talvez com uma assinatura de índice como

    const _obj: { [k: string]: number | undefined } = obj;

    Isso representa a ideia de que qualquer propriedade será numberou ausente/ undefined, e você pode apenas indexar diretamente (sem inverificar) e comparar com undefined:

    const val = _obj[key];
if (typeof val !== "undefined") {
    console.log(val)
}

    Link do Playground para o código

    • 1

  2. Uma maneira divertida de fazer isso é

    function isKeyOf<ObjT extends (Record<string,any>)>(k: string | number | symbol, obj: ObjT): k is keyof ObjT {
    return k in obj;
}

declare const obj: { a?: number, b?: number };
declare const key: string;


if (isKeyOf(key,obj)) {
  console.log(obj[key])
}

    mas se você estiver com pressa também pode fazer

    declare const obj: { a?: number , b?: number };
declare const key: string;

if (key in obj) {
  console.log(obj[key as keyof typeof obj])
}

    Nota1: Tomei a liberdade de mudar {a:number}|{b:number}para {a?:number,b?:number}porque a maneira como o TypeScript avalia {a:number}|{b:number}um nevertipo, que provavelmente não é o que você pretendia.

    Observação2: também usei declare constformulários, em vez de valores constantes explícitos, para que fique claro que a chave precisa ser verificada antes de ser usada para acessar o objeto. (Caso contrário, a questão é trivial).

    Atualizar

    function isKeyOf<ObjT extends (Record<string,any>)>(k: string | number | symbol, obj: ObjT): k is keyof ObjT {
    return k in obj;
}
const obj = (Math.random()<0.5) ? { a: 1 } : { b: 2 }; 
declare const key: string;
if (isKeyOf(key,obj)) {
  console.log(obj[key])
}

    Nesta versão o TypeScript infere o tipo de objto be {a: number;b?: undefined;}|{b: number;a?: undefined;}, que é reduzido a {a?: number;b?: undefined;}. É somente nesta forma condicional especial de uma linha que o TypeScript irá gerar uma união de tipos sem chaves comuns. Geralmente, se você deseja uma "união" conceitual de tipos com chaves diferentes, pode fazer algo como

    type AB = Partial<{a:number} & {b: number}>
//{
//    a?: number | undefined;
//    b?: number | undefined;
//}

    Mas as chaves são todas opcionais - isso é uma limitação.

    • 0

relate perguntas