Esta pregunta es el análogo directo a la verificación de tipo de clase con TypeScript

Necesito averiguar en tiempo de ejecución si una variable de tipo implementa una interfaz. Aquí está mi código:

interface A{
    member:string;
}

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

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

Si ingresa este código en el campo de juegos mecanografiado, la última línea se marcará como un error, "El nombre A no existe en el ámbito actual". Pero eso no es cierto, el nombre existe en el ámbito actual. Incluso puedo cambiar la declaración de la variable var a:A={member:"foobar"};sin quejas del editor. Después de navegar por la web y encontrar la otra pregunta en SO, cambié la interfaz a una clase pero luego no puedo usar literales de objeto para crear instancias.

Me preguntaba cómo el tipo A podría desaparecer así, pero un vistazo al JavaScript generado explica el problema:

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

No hay representación de A como interfaz, por lo tanto, no es posible realizar verificaciones de tipo de tiempo de ejecución.

Entiendo que javascript como lenguaje dinámico no tiene concepto de interfaces. ¿Hay alguna forma de escribir check para interfaces?

El autocompletado del campo de escritura mecanografiado revela que el mecanografiado incluso ofrece un método implements. Como puedo usar lo ?

Puede lograr lo que desea sin la instanceofpalabra clave, ya que puede escribir protectores de tipo personalizados ahora:

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

Muchos miembros

Si necesita verificar muchos miembros para determinar si un objeto coincide con su tipo, puede agregar un discriminador. El siguiente es el ejemplo más básico, y requiere que maneje sus propios discriminadores ... necesitaría profundizar en los patrones para asegurarse de evitar discriminadores duplicados.

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

En TypeScript 1.6, la protección de tipo definida por el usuario hará el trabajo.

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

Y tal como lo mencionó Joe Yang: desde TypeScript 2.0, incluso puede aprovechar el tipo de unión etiquetado.

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

Y también funciona con switch.

mecanografiado 2.0 introducir unión etiquetada

Características de 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;
    }
}

¿Qué hay de los protectores de tipo definidos por el usuario? 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();
}

Ahora es posible, acabo de lanzar una versión mejorada del TypeScriptcompilador que proporciona capacidades de reflexión completas. Puede crear instancias de clases de sus objetos de metadatos, recuperar metadatos de constructores de clases e inspeccionar interfaces / clases en tiempo de ejecución. Puedes verlo aquí

Ejemplo de uso:

En uno de sus archivos de mecanografía, cree una interfaz y una clase que la implemente de la siguiente manera:

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

class MyClass implements MyInterface {
    counter = 0;

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

ahora imprimamos la lista de interfaces implementadas.

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

compile con reflec-ts y ejecútelo:

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

Ver reflection.d.ts para Interfacedetalles de metatipo.

ACTUALIZACIÓN: puede encontrar un ejemplo de trabajo completo aquí

igual que el anterior donde se usaron guardias definidos por el usuario pero esta vez con un predicado de función de flecha

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

Aquí hay otra opción: el módulo ts-interface-builder proporciona una herramienta de tiempo de construcción que convierte una interfaz TypeScript en un descriptor de tiempo de ejecución, y ts-interface-checker puede verificar si un objeto lo satisface.

Para el ejemplo de OP,

interface A {
  member: string;
}

Primero ejecutaría lo ts-interface-builderque produce un nuevo archivo conciso con un descriptor, digamos foo-ti.ts, que puede usar así:

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" 

Puede crear una función de protección de tipo de una línea:

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

Me gustaría señalar que TypeScript no proporciona un mecanismo directo para probar dinámicamente si un objeto implementa una interfaz particular.

En cambio, el código TypeScript puede usar la técnica de JavaScript para verificar si un conjunto apropiado de miembros está presente en el objeto. Por ejemplo:

var obj : any = new Foo();

if (obj.someInterfaceMethod) {
    ...
}

Tipo Guardias

interface MyInterfaced {
    x: number
}

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

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

Basado en la respuesta de Fenton , aquí está mi implementación de una función para verificar si un dado objecttiene las claves y interfacetiene, total o parcialmente.

Dependiendo de su caso de uso, es posible que también deba verificar los tipos de cada una de las propiedades de la interfaz. El siguiente código no hace eso.

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

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

Debido a que el tipo es desconocido en tiempo de ejecución, escribí el siguiente código para comparar el objeto desconocido, no contra un tipo, sino contra un objeto de tipo conocido:

1. Crear un objeto de muestra del tipo correcto
2. Especifica cuáles de sus elementos son opcionales
3. Haga una comparación profunda de su objeto desconocido con este objeto de muestra

Aquí está el código (interfaz agnóstico) que uso para la comparación 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;
}

A continuación se muestra un ejemplo de cómo lo uso.

En este ejemplo, espero que el JSON contenga una matriz de tuplas, de las cuales el segundo elemento es una instancia de una interfaz llamada User (que tiene dos elementos opcionales).

La verificación de tipos de TypeScript asegurará que mi objeto de muestra sea correcto, luego la función afirmarTypeT verifica que el objeto desconocido (cargado desde JSON) coincida con el objeto de muestra.

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

Podría invocar una verificación como esta en la implementación de una protección de tipo definida por el usuario.

Puede validar un tipo TypeScript en tiempo de ejecución utilizando ts-validate-type , de esta manera (aunque requiere un complemento de Babel):

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