Início / coding / Perguntas / 76924030
Accepted
Lumin
Asked: 2023-08-18 01:55:45 +0800 CST

Como você discrimina uniões marcadas ao restringir tipos usando uma proteção de tipo?

  • 772

Considere uma função auxiliar

const isKeyOf = <K extends PropertyKey, O extends object>(key: K, object: O): key is K & keyof O => key in object

Aqui, isKeyOflimita o tipo de chave ao verificar se existe uma chave em um objeto

const obj = {
    a: 1,
    b: 2,
    c: 3
}

const key: string = "a" // type of key is string

if (isKeyOf(key, obj)) {
    // type of key is "a" | "b" | "c"
}

Isso funciona bem, desde que obj não seja uma união de tipos, no entanto:

const holder: Record<number, { a: number } | { b: number }> = {
    1: { a: 1 },
    2: { b: 2 }
}

// type of obj is { a: number } | { b: number }
const obj = holder[1 as number]
const key: string = "a" // type of key is string
 
if (isKeyOf(key, obj)) {
     // type of key is never!
     // However, this branch does execute, and
     console.log(typeof key) // prints string
     console.log(obj) // prints { a: 1 }
}

Depois de alguma investigação, descobri que isso ocorre porque o keyofoperador lista apenas as chaves que são comuns a todos os tipos em uma união

type objType = { a: number } | { b: number }
type key = keyof objType // = never

ainda assim, neste caso, verifiquei se keyrealmente está in objTypeno tipo de guarda. Como faço para escrever um tipo de proteção que verifique isso corretamente e atribua o tipo correto à chave?

typescript

1 respostas

  1. Best Answer

    Como você mencionou, o keyofoperador retornará apenas as chaves comuns, portanto, o seguinte tipo resultará em never:

    // never
type Result = keyof ({ a: string } | { b: string });

    Para corrigi-lo, precisamos verificar keyofcada membro do sindicato separadamente. Portanto, nosso resultado final deve ficar assim:

    // "a" | "b"
type Result = keyof { a: string } | keyof { b: string };

    Podemos conseguir isso usando tipos condicionais distributivos . Os tipos de união são distribuídos sempre que são verificados em relação a alguma condição usando extends. Exemplo:

    type Test<T> = T extends number ? T : never;

// 1
type Result = Test<'a' | false | [] | 1>

    Para garantir que não perderemos nenhum membro como no exemplo anterior, precisamos ter uma condição que seja sempre verdadeira. As condições possíveis são verificar contra anyou o Tpróprio, desde que T extends Tseja sempre verdadeiro:

    type Test<T> = T extends T ?  keyof T : never;

// "a" | "b"
type Result = Test<{ a: string } | { b: string }>

    Parece bom! Vamos adaptá-lo ao seu tipo de guarda :

    const isKeyOf = <K extends PropertyKey, O extends object>(
  key: K,
  object: O,
): key is K & (O extends O ? keyof O : never) => key in object;

    Teste:

    const obj = holder[1 as number];
const key: string = 'a'; // type of key is string

if (isKeyOf(key, obj)) {
  key; // "a" | "b"
}

    Parque infantil

    • 1

relate perguntas