В компиляторе TypeScript это пока невозможно, хотя в конечном итоге это возможно.

Эта проблема в проекте TypeScript, по-видимому, является основной, отслеживающей этот запрос функции; с ним связаны многие другие подобные проблемы.

Как всегда можно выполнять эти проверки во время выполнения. Это можно сделать вручную с помощью стандартных проверок/утверждений. Мне лично нравится использовать JSONSchema для нетривиальных случаев "все, кроме объектов в форме X " или пакета io-ts, для создания этих типов валидаторов времени исполнения. В TypeScript вы также имеете доступ к функциям защиты типа, которые могут использоваться для выполнения этих проверок.

EDIT это возможно в ограниченном, не очень полезном виде. Используя модификацию типа Omit из этой статьи, можно проверить тип проверки, чтобы отклонить некоторые, но не все, нарушающие типы.

Например, предположим, что вам нужен тип для "любого object, который не имеет свойств c или d ". Таким образом, вы можете выразить такой тип:

type Diff<T extends string, U extends string> = ({[P in T]: P } & {[P in U]: never } & { [x: string]: never })[T];  
type Omit<T, K extends keyof T> = Pick<T, Diff<keyof T, K>>;
type AnyTypeWithoutCorD<T> = Omit<T, keyof T & ( "c" | "d" )>

Используя этот тип, директива typechecker отвергает следующее:

type MyType = { a: number, b: number, c: number };

// Accepts a generic argument and a parameter; ensures the
// parameter can be constrained into the AnyTypeWithoutCorD type.
function funcGeneric<T>(arg: AnyTypeWithoutCorD<T>) {}

// Accepts a parameter of a known type MyType, constrained 
// into the AnyTypeWithoutCorD type.
function func(arg: AnyTypeWithoutCorD<MyType>) {}

let foo: AnyTypeWithoutCorD<MyType> = { a: 1, b: 1, c: 2 } // Error: type not assignable
func({ a: 1, b: 1, c: 2 }) // Error: type not assignable
funcGeneric<MyType>({ a: 1, b: 1, c: 2 }) // Error: type not assignable

Ограничения:

• Все ключи в типе ввода (MyType в примере) должны быть явно перечислены. Не допускается подписывание свойств индекса; те вызывают проверки типов принимать Omit объекты независимо от их полей. Например, если вы добавили [x: string]: any в спецификацию MyType в приведенном выше примере, typechecker с радостью принимает все аргументы (& { [x: string]: any } эквивалентно и ведет себя одинаково), Если вы выполняете Omit -type проверку на вещах, чьи входные типов не контролировать, это означает, что проверка не будет иметь место, если любые типы входов имеют подпись индекса собственности.
• Это работает только в том случае, если вы поставляете новое значение конструктору типа Omit или выполняете что-то эквивалентно "раннее" при проверке типа. Поставка данных из предыдущего назначения или с помощью утверждения типа не выполняет проверку на Omit как ожидалось.
• Если вы поставляете необработанные данные в общую функцию или тип, который использует общий параметр для параметризации типа Omit, и вы не указываете явно общее при вызове функции, это будет неверно выведено, и в результате Omit проверку не произойдет так как ваш тип не пройдет.

Например, ни одна из ниже не работает (все они принимаются с помощью проверки типа):

let bar: MyType = { a: 1, b: 1, c: 2 }
func(bar)
func({ a: 1, b: 1, c: 2 } as MyType)
funcGeneric(bar)
funcGeneric({ a: 1, b: 1, c: 2 })
let ok: AnyTypeWithoutCorD<object> = { a: 1, b: 1, c: 2 }
let ok: AnyTypeWithoutCorD<{ c: number }> = { a: 1, b: 1, c: 2 }
let ok: AnyTypeWithoutCorD<MyType> = { a: 1, b: 1, c: 2 } as MyType
let ok: AnyTypeWithoutCorD<MyType> = bar as MyType

Это мои первые попытки достичь/продемонстрировать это, поэтому люди, более осведомленные о TypeScript и построении настраиваемого типа, могут меня поправить. Возьмите его с солью.

Выводы:

Решение Omit не стоит.

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

Это связано с тем, что он иногда корректно проверяет ваши типы, что создает ложное чувство безопасности и трудно отлаживающее, казалось бы, непоследовательное поведение.

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

В машинописном тексте: можно ли проверить, не является ли тип ожидаемого типа НЕ какой-то?

Я подозреваю, что вы ищете типы времени выполнения. У TypeScript нет способа сделать это, поскольку в JavaScript не существует стандартизованного способа сделать это.

Если вы просто ищете простые защитные устройства, они работают нормально, например

function foo(bar: string | number){
    if (typeof bar !== 'string') {
        // TypeScript knows its a number!
        return bar.toPrecision(3);
    }
}

Больше

Тип охранников: https://basarat.gitbooks.io/typescript/content/docs/types/typeGuard.html