Более строгое утверждение типа в Typescript

Я не понимаю, зачем вам нужна функция cast в любом из этих примеров. Я думаю, вы можете слишком много думать об этом.

Давайте начнем здесь, что прекрасно и так.

doSomething({a: 2, b: 1, c: 10} as Example)

Ключевое слово as по-прежнему обычно безопасно для типов. Это позволяет вам привести значение к супертипу. В этом случае { a: number, b: number } является супертипом { a: number, b: number, c: number }.

Например:

const value = { a: 1, b: 2, c: 2 }
const exampleValue: { a: number, b: number } = value // works!

И в вашем первом примере, если вы пропустите обязательное свойство, у вас будет ошибка типа:

doSomething({b: 1, c: 10} as Example)
// Property 'a' is missing in type '{ b: number; c: number; }'
// but required in type 'Example'.(2352)

Так почему же это дает ошибку?

cast<Example>({a: 1, b: 2, c: 3}) // error

Потому что, когда вы создаете значение и присваиваете его супертипу, вы ссылаетесь только на это значение, относящееся к этому супертипу. Это означает, что любые другие свойства, которые могут существовать, будут недоступны. Example не имеет свойства c. Итак, typescript предполагает, что это ошибка, и это правильно.

Но в реальном коде, если вы передадите объект с a, b и c функции, которая ожидает только a и b, то ничего плохого не произойдет. Вы удовлетворили ограничения, так что проблем нет.

В этом фрагменте:

doSomething(cast<Example>({a: 2, b: 1, c: 10})) // yay, error

Актерский состав бессмысленный. Если doSomething заботится о типе, который он получает, он должен объявить это в своих аргументах. А если все равно, то и приведение не нужно вообще.

const x: Example = {a: 2, b: 1, c: 10}
doSomething(x)

Это в основном то же самое, что и as Example сверху.

declare function doSomething(arg: Example): any

Это правильно, и именно то, что вы должны делать. Если функция принимает определенный тип, позвольте ей применять его самостоятельно. Вам не нужно ничего разыгрывать, если вы назначаете его any, так как это приведение все равно будет потеряно.

const example = (i: number, j: number, k: number) =>
  cast<Example>({a: 1, b: 2, c: 3})

Если вы хотите, чтобы функция возвращала тип, вы обычно просто аннотируете возвращаемый тип. Следующее работает нормально:

const example(i: number, j: number, k: number): Example =>
  ({ a: i, b: j, c: k }) // error, as expected

Чтобы правильно установить тип, не приводя к функции идентификации, мне нужно было бы написать:

const example: (i: number, j: number, k: number) => Example = (i, j, k) => ({a: 1, b: 2, c: 3})

Неверно, см. предыдущий пример. Одна функция, тип применяется, как и ожидалось.

Наконец:

function example (i: number, j: number, k: number): Example {
    return {a: 1, b: 2, c: 3} // error as expected.
}

Если вам нужна функция, которая создает и возвращает Example, это идеально. Он должным образом предупреждает вас о том, что у вас есть свойство, которое никогда не может быть использовано, и четко документирует возвращаемое значение.

TLDR:

Ни один из ваших фрагментов кода не должен требовать функции cast<T>(). Я думаю, что вам лучше всего устранить все вхождения any, а затем просто позволить Typescript применять типы. Вот для чего он нужен. Компилятор довольно хорош и обычно не нуждается в такой помощи.

Фильтрация

Фильтрация действительно странный случай во всем этом. Проблема связана с тем, что тип filter() возвращает точно такой же тип массива, с которого он начинался, независимо от того, что вы фильтруете. Обычное решение состоит в том, чтобы сделать функцию обратного вызова фильтра типом предикатная функция

Тогда вы можете сделать что-то вроде:

interface Example {
    a: number
    b: number
}

declare function doSomethingWithArray(arg: Example[]): void

doSomethingWithArray([
    {a: 1, b: 2},
    false,
    {a: 1, b: 2, c: 3} // no error because of perfectly safe casting to supertype
].filter((x): x is Example => typeof x !== 'boolean'))

See playground