Esta questão é o analogon direto da verificação de tipo de classe com o TypeScript

Preciso descobrir em tempo de execução se uma variável do tipo any implementa uma interface. Aqui está o meu código:

interface A{
    member:string;
}

var a:any={member:"foobar"};

if(a instanceof A) alert(a.member);

Se você digitar esse código no parque de texto datilografado, a última linha será marcada como um erro "O nome A não existe no escopo atual". Mas isso não é verdade, o nome existe no escopo atual. Posso até alterar a declaração da variável para var a:A={member:"foobar"};sem queixas do editor. Depois de navegar na web e encontrar a outra pergunta no SO, mudei a interface para uma classe, mas não consigo usar literais de objeto para criar instâncias.

Gostaria de saber como o tipo A poderia desaparecer assim, mas uma olhada no javascript gerado explica o problema:

var a = {
    member: "foobar"
};
if(a instanceof A) {
    alert(a.member);
}

Não há representação de A como uma interface, portanto, nenhuma verificação de tipo de tempo de execução é possível.

Eu entendo que o javascript como uma linguagem dinâmica não tem conceito de interfaces. Existe alguma maneira de digitar check para interfaces?

O preenchimento automático do playground de texto datilografado revela que o texto datilografado ainda oferece um método implements. Como posso usá-lo?

Você pode conseguir o que deseja sem a instanceofpalavra - chave, já que pode escrever protetores de tipo personalizados agora:

interface A{
    member:string;
}

function instanceOfA(object: any): object is A {
    return 'member' in object;
}

var a:any={member:"foobar"};

if (instanceOfA(a)) {
    alert(a.member);
}

Muitos membros

Se você precisar verificar vários membros para determinar se um objeto corresponde ao seu tipo, adicione um discriminador. O exemplo abaixo é o mais básico e exige que você gerencie seus próprios discriminadores ... você precisará se aprofundar nos padrões para garantir que você evite duplicados discriminadores.

interface A{
    discriminator: 'I-AM-A';
    member:string;
}

function instanceOfA(object: any): object is A {
    return object.discriminator === 'I-AM-A';
}

var a:any = {discriminator: 'I-AM-A', member:"foobar"};

if (instanceOfA(a)) {
    alert(a.member);
}

No TypeScript 1.6, a proteção de tipo definida pelo usuário fará o trabalho.

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;
}

E, como Joe Yang mencionou: desde o TypeScript 2.0, você pode tirar vantagem do tipo de união com tags.

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;
}

E isso também funciona switch.

typescript 2.0 introduzir união marcada

Recursos do Typecript 2.0

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;
    }
}

E quanto às proteções de tipo definidas pelo usuário? 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();
}

Agora é possível, acabei de lançar uma versão aprimorada do TypeScriptcompilador que fornece recursos completos de reflexão. Você pode instanciar classes de seus objetos de metadados, recuperar metadados de construtores de classe e inspecionar interface / classes em tempo de execução. Você pode conferir aqui

Exemplo de uso:

Em um dos seus arquivos datilografados, crie uma interface e uma classe que a implemente da seguinte maneira:

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

class MyClass implements MyInterface {
    counter = 0;

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

agora vamos imprimir algumas da lista de interfaces implementadas.

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

compile com o reflec-ts e inicie-o:

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

Veja reflection.d.ts para Interfacedetalhes do tipo meta.

UPDATE: Você pode encontrar um exemplo de trabalho completo aqui

igual ao descrito acima, onde os protetores definidos pelo usuário foram usados, mas desta vez com um predicado de função de seta

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);

Aqui está outra opção: o módulo ts-interface-builder fornece uma ferramenta em tempo de construção que converte uma interface TypeScript em um descritor de tempo de execução, e o ts-interface-checker pode verificar se um objeto a satisfaz.

Para o exemplo do OP,

interface A {
  member: string;
}

Você executaria primeiro o ts-interface-builderque produziria um novo arquivo conciso com um descritor, por exemplo foo-ti.ts, que você possa usar assim:

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" 

Você pode criar uma função de proteção de tipo de uma linha:

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

Gostaria de salientar que o TypeScript não fornece um mecanismo direto para testar dinamicamente se um objeto implementa uma interface específica.

Em vez disso, o código TypeScript pode usar a técnica JavaScript para verificar se um conjunto apropriado de membros está presente no objeto. Por exemplo:

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;
}

Com base na resposta de Fenton , aqui está minha implementação de uma função para verificar se um dado objecttem as chaves e um interfacetotal ou parcialmente.

Dependendo do seu caso de uso, também pode ser necessário verificar os tipos de cada uma das propriedades da interface. O código abaixo não faz isso.

function implementsTKeys<T>(obj: any, keys: (keyof T)[]): obj is T {
    if (!obj || !Array.isArray(keys)) {
        return false;
    }

    const implementKeys = keys.reduce((impl, key) => impl && key in obj, true);

    return implementKeys;
}

Exemplo de uso:

interface A {
    propOfA: string;
    methodOfA: Function;
}

let objectA: any = { propOfA: '' };

// Check if objectA partially implements A
let implementsA = implementsTKeys<A>(objectA, ['propOfA']);

console.log(implementsA); // true

objectA.methodOfA = () => true;

// Check if objectA fully implements A
implementsA = implementsTKeys<A>(objectA, ['propOfA', 'methodOfA']);

console.log(implementsA); // true

objectA = {};

// Check again if objectA fully implements A
implementsA = implementsTKeys<A>(objectA, ['propOfA', 'methodOfA']);

console.log(implementsA); // false, as objectA now is an empty object

export interface ConfSteps {
    group: string;
    key: string;
    steps: string[];
}

private verify(): void {
    const obj = `{
      "group": "group",
      "key": "key",
      "steps": [],
      "stepsPlus": []
    } `;
    if (this.implementsObject<ConfSteps>(obj, ['group', 'key', 'steps'])) {
      console.log(`Implements ConfSteps: ${obj}`);
    }
  }

private objProperties: Array<string> = [];

private implementsObject<T>(obj: any, keys: (keyof T)[]): boolean {
    JSON.parse(JSON.stringify(obj), (key, value) => {
      this.objProperties.push(key);
    });
    for (const key of keys) {
      if (!this.objProperties.includes(key.toString())) {
        return false;
      }
    }
    this.objProperties = null;
    return true;
  }

Como o tipo é desconhecido no tempo de execução, escrevi o código da seguinte maneira para comparar o objeto desconhecido, não contra um tipo, mas contra um objeto do tipo conhecido:

1. Crie um objeto de amostra do tipo certo
2. Especifique quais de seus elementos são opcionais
3. Faça uma comparação profunda do seu objeto desconhecido com esse objeto de amostra

Aqui está o código (independente de interface) que eu uso para uma comparação profunda:

function assertTypeT<T>(loaded: any, wanted: T, optional?: Set<string>): T {
  // this is called recursively to compare each element
  function assertType(found: any, wanted: any, keyNames?: string): void {
    if (typeof wanted !== typeof found) {
      throw new Error(`assertType expected ${typeof wanted} but found ${typeof found}`);
    }
    switch (typeof wanted) {
      case "boolean":
      case "number":
      case "string":
        return; // primitive value type -- done checking
      case "object":
        break; // more to check
      case "undefined":
      case "symbol":
      case "function":
      default:
        throw new Error(`assertType does not support ${typeof wanted}`);
    }
    if (Array.isArray(wanted)) {
      if (!Array.isArray(found)) {
        throw new Error(`assertType expected an array but found ${found}`);
      }
      if (wanted.length === 1) {
        // assume we want a homogenous array with all elements the same type
        for (const element of found) {
          assertType(element, wanted[0]);
        }
      } else {
        // assume we want a tuple
        if (found.length !== wanted.length) {
          throw new Error(
            `assertType expected tuple length ${wanted.length} found ${found.length}`);
        }
        for (let i = 0; i < wanted.length; ++i) {
          assertType(found[i], wanted[i]);
        }
      }
      return;
    }
    for (const key in wanted) {
      const expectedKey = keyNames ? keyNames + "." + key : key;
      if (typeof found[key] === 'undefined') {
        if (!optional || !optional.has(expectedKey)) {
          throw new Error(`assertType expected key ${expectedKey}`);
        }
      } else {
        assertType(found[key], wanted[key], expectedKey);
      }
    }
  }

  assertType(loaded, wanted);
  return loaded as T;
}

Abaixo está um exemplo de como eu o uso.

Neste exemplo, espero que o JSON contenha uma matriz de tuplas, da qual o segundo elemento é uma instância de uma interface chamada User(que possui dois elementos opcionais).

A verificação de tipo do TypeScript garantirá que meu objeto de amostra esteja correto, e a função assertTypeT verifica se o objeto desconhecido (carregado de JSON) corresponde ao objeto de amostra.

export function loadUsers(): Map<number, User> {
  const found = require("./users.json");
  const sample: [number, User] = [
    49942,
    {
      "name": "ChrisW",
      "email": "example@example.com",
      "gravatarHash": "75bfdecf63c3495489123fe9c0b833e1",
      "profile": {
        "location": "Normandy",
        "aboutMe": "I wrote this!\n\nFurther details are to be supplied ..."
      },
      "favourites": []
    }
  ];
  const optional: Set<string> = new Set<string>(["profile.aboutMe", "profile.location"]);
  const loaded: [number, User][] = assertTypeT(found, [sample], optional);
  return new Map<number, User>(loaded);
}

Você pode chamar uma verificação como esta na implementação de uma proteção de tipo definida pelo usuário.

Você pode validar um tipo TypeScript em tempo de execução usando ts-validate-type , assim: (embora exija um plug-in Babel):

const user = validateType<{ name: string }>(data);