Início / coding / Perguntas / 77828900
Accepted
Alex Wayne
Asked: 2024-01-17 05:54:41 +0800 CST

Retornar `nunca` para função que sempre lança apenas estreitamentos quando não é uma propriedade do objeto

  • 772

Digamos que você tenha uma função que gera um erro configurado especificamente:

function throwMyError(): never {
    throw new Error("My Custom error")
}

E você tem um valor anulável:

declare const str: string | null

Você poderia restringir esse valor a algo não anulável como este:

if(!str) throwMyError()
str.toLocaleLowerCase() // fine

Agora coloque essa chamada de função em um objeto literal e ela não poderá mais fazer o mesmo estreitamento:

const foo = { throwMyError }
if (!str) foo.throwMyError()
str.toLocaleLowerCase() // 'obj' is possibly 'null'.(18047)

Ou:

const bar = {
    throwMyError: (): never => {
        throw new Error()
    }
}
if (!str) bar.throwMyError()
str.toLocaleLowerCase() // 'obj' is possibly 'null'.(18047)

Por que o estreitamento não funciona quando a função de lançamento é chamada a partir de um tipo de objeto?

Isso pode ser resolvido sem criar uma função de predicado de tipo?

Consulte Playground datilografado

Pergunta relacionada: Estreitamento de tipo e nunca funciona

Mas isso não parece resolver esta questão porque em todos os casos o tipo de função é explicitamente anotado para retornarnever

typescript

1 respostas

  1. Best Answer

    As condições nas quais uma neverfunção de retorno é tratada como uma afirmação que afeta a análise do fluxo de controle são descritas no PR de implementação, microsoft/TypeScript#32695 . Se parece com isso:

    Uma chamada de função é analisada como uma chamada de asserção ou chamada sem retorno quando

    • a chamada ocorre como uma instrução de expressão de nível superior e

    • a chamada especifica um único identificador ou uma sequência pontilhada de identificadores para o nome da função, e

    • cada identificador no nome da função faz referência a uma entidade com um tipo explícito e

    • o nome da função é resolvido para um tipo de função com um assertstipo de retorno ou uma neveranotação de tipo de retorno explícita.

    Uma entidade é considerada de tipo explícito quando é declarada como uma função, método, classe ou namespace, ou como uma variável, parâmetro ou propriedade com uma anotação de tipo explícita. (Essa regra específica existe para que a análise do fluxo de controle de possíveis chamadas de asserção não acione circularmente análises adicionais.)

    O problema que você está tendo com ambos fooé barque são variáveis ​​sem uma anotação de tipo explícita . Você permitiu que o compilador inferisse seus tipos, o que em quase todas as outras situações é algo perfeitamente aceitável e razoável de se fazer. Mas aparentemente é muito difícil apoiar isso para funções de asserção e neverfunções de retorno; diz-se que causa lentidão no verificador de tipo e avisos de circularidade.

    Se você quiser fooe bartrabalhar, precisará anotá-los explicitamente, assim:

    declare const str: string | null;
const foo: { throwMyError(): never } = { throwMyError };
if (!str) foo.throwMyError();
str.toLocaleLowerCase(); // okay

    ou

    declare const str: string | null; 
const bar: { throwMyError(): never } = {
    throwMyError: (): never => { throw new Error() }
};
if (!str) bar.throwMyError();
str.toLocaleLowerCase(); // okay

    Esse é o comportamento que você queria e, para o código de exemplo aqui, não há muito trabalho extra. Mas, na prática, essa restrição nas anotações de tipo faz com que o uso de métodos neverde retorno e asserção seja um fardo significativo, pois você precisa criar nomes explícitos para tipos que, de outra forma, seriam convenientemente anônimos e inferidos para você. Dependendo do caso de uso, isso pode variar de um pequeno aborrecimento ( const foo: Foo = ⋯) a um completo problema ( const baz: Baz<Map<string, boolean>, "qux", [number, "hello"], Baz<Map<string, Date>, "quux", [boolean, "goodbye"], ⋯>> = ⋯). Portanto, proceda com cautela.

    Link do Playground para o código

    • 1

relate perguntas