W TypeScript 1.6, user-defined type guard wykona zadanie.

interface Foo {
    fooProperty: string;
}

interface Bar {
    barProperty: string;
}

function isFoo(object: any): object is Foo {
    return 'fooProperty' in object;
}

let object: Foo | Bar;

if (isFoo(object)) {
    // `object` has type `Foo`.
    object.fooProperty;
} else {
    // `object` has type `Bar`.
    object.barProperty;
}

I tak jak wspomniał Joe Yang: od TypeScript 2.0, możesz nawet skorzystać z tagged Union type.

interface Foo {
    type: 'foo';
    fooProperty: string;
}

interface Bar {
    type: 'bar';
    barProperty: number;
}

let object: Foo | Bar;

// You will see errors if `strictNullChecks` is enabled.
if (object.type === 'foo') {
    // object has type `Foo`.
    object.fooProperty;
} else {
    // object has type `Bar`.
    object.barProperty;
}

I działa również z switch.

Typescript 2.0 wprowadzenie tagged union

Typescript 2.0 features

interface Square {
    kind: "square";
    size: number;
}

interface Rectangle {
    kind: "rectangle";
    width: number;
    height: number;
}

interface Circle {
    kind: "circle";
    radius: number;
}

type Shape = Square | Rectangle | Circle;

function area(s: Shape) {
    // In the following switch statement, the type of s is narrowed in each case clause
    // according to the value of the discriminant property, thus allowing the other properties
    // of that variant to be accessed without a type assertion.
    switch (s.kind) {
        case "square": return s.size * s.size;
        case "rectangle": return s.width * s.height;
        case "circle": return Math.PI * s.radius * s.radius;
    }
}

A może Strażnicy zdefiniowani przez użytkownika? https://www.typescriptlang.org/docs/handbook/advanced-types.html

interface Bird {
    fly();
    layEggs();
}

interface Fish {
    swim();
    layEggs();
}

function isFish(pet: Fish | Bird): pet is Fish { //magic happens here
    return (<Fish>pet).swim !== undefined;
}

// Both calls to 'swim' and 'fly' are now okay.

if (isFish(pet)) {
    pet.swim();
}
else {
    pet.fly();
}

Teraz jest to możliwe, właśnie wydałem ulepszoną wersję kompilatora TypeScript, który zapewnia pełne możliwości odbicia. Można tworzyć instancje klas z ich obiektów metadanych, pobierać metadane z konstruktorów klas i sprawdzać interfejs / klasy w czasie wykonywania. Możesz to sprawdzić tutaj

Przykład użycia:

W jednym z plików maszynopisu Utwórz interfejs i klasę, które implementują go w następujący sposób:

interface MyInterface {
    doSomething(what: string): number;
}

class MyClass implements MyInterface {
    counter = 0;

    doSomething(what: string): number {
        console.log('Doing ' + what);
        return this.counter++;
    }
}

Teraz wydrukujmy listę zaimplementowane interfejsy.

for (let classInterface of MyClass.getClass().implements) {
    console.log('Implemented interface: ' + classInterface.name)
}

Skompiluj z reflec-ts i uruchom go:

$ node main.js
Implemented interface: MyInterface
Member name: counter - member kind: number
Member name: doSomething - member kind: function

Zobacz odbicie.d. ts dla Interface meta-type details.

aktualizacja: Pełny przykład pracy znajdziesz tutaj

Chciałbym zauważyć, że TypeScript nie zapewnia bezpośredniego mechanizmu dynamicznego testowania, czy obiekt implementuje konkretny interfejs.

Zamiast tego, Kod maszynopisu może używać techniki JavaScript sprawdzania, czy odpowiedni zestaw elementów jest obecny na obiekcie. Na przykład:

var obj : any = new Foo();

if (obj.someInterfaceMethod) {
    ...
}

TypeGuards

interface MyInterfaced {
    x: number
}

function isMyInterfaced(arg: any): arg is MyInterfaced {
    return arg.x !== undefined;
}

if (isMyInterfaced(obj)) {
    (obj as MyInterfaced ).x;
}

Oto inna opcja: moduł ts-interface-builder zapewnia narzędzie czasu kompilacji, które konwertuje interfejs TypeScript do deskryptora uruchomieniowego, a ts-interface-checker może sprawdzić, czy obiekt go spełnia.

Dla przykładu OP,

interface A {
  member: string;
}

Najpierw uruchamiasz ts-interface-builder, który tworzy nowy zwięzły Plik z deskryptorem, powiedzmy, foo-ti.ts, którego możesz użyć w następujący sposób:

import fooDesc from './foo-ti.ts';
import {createCheckers} from "ts-interface-checker";
const {A} = createCheckers(fooDesc);

A.check({member: "hello"});           // OK
A.check({member: 17});                // Fails with ".member is not a string" 

Można utworzyć jednoliniową funkcję typu strażnika:

function isA(value: any): value is A { return A.test(value); }

To samo, co powyżej, gdzie zastosowano strażników zdefiniowanych przez użytkownika , ale tym razem z predykatem funkcji strzałki

interface A {
  member:string;
}

const check = (p: any): p is A => p.hasOwnProperty('member');

var foo: any = { member: "foobar" };
if (check(foo))
    alert(foo.member);