Це питання є прямим аналогом перевірки типу класу за допомогою TypeScript

Мені потрібно з’ясувати під час виконання, чи змінна типу будь-який реалізує інтерфейс. Ось мій код:

interface A{
    member:string;
}

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

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

Якщо ви введете цей код на майданчик машинопису, останній рядок буде позначений як помилка: "Ім'я A не існує в поточному діапазоні". Але це неправда, назва існує в нинішній області. Я навіть можу змінити декларацію змінної на var a:A={member:"foobar"};без скарг редактора. Після перегляду Інтернету та пошуку іншого питання на SO я змінив інтерфейс на клас, але потім я не можу використовувати об’єктні літерали для створення екземплярів.

Мені було цікаво, як тип A може зникнути таким чином, але погляд на створений JavaScript пояснює проблему:

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

Немає представлення A як інтерфейсу, тому перевірки типу виконання не можливі.

Я розумію, що javascript як динамічна мова не має поняття інтерфейсів. Чи є спосіб перевірити інтерфейси?

Автозавершення ігрового майданчика машинопису виявляє, що машинопис навіть пропонує метод implements. Як я можу ним користуватися?

Ви можете домогтися того, що ви хочете, без instanceofключового слова, оскільки ви можете зараз написати власні охоронці типу:

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

Багато членів

Якщо вам потрібно перевірити чимало членів, щоб визначити, чи відповідає об'єкт вашому типу, замість цього ви можете додати дискримінатора. Нижче наведено найосновніший приклад, і вимагає, щоб ви керували власними дискримінаторами ... вам потрібно буде поглибитись у закономірності, щоб уникнути дублювання дискримінаторів.

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

У TypeScript 1.6 виконує завдання захищений тип, визначений користувачем .

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

І так, як згадував Джо Ян: починаючи з TypeScript 2.0, ви навіть можете скористатися перевагою тегового типу об'єднання.

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

І це switchтеж працює .

typecript 2.0 ввести теговий союз

Особливості Typescript 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;
    }
}

Як щодо захищених типів охоронців? 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();
}

Зараз це можливо, я щойно випустив розширену версію TypeScriptкомпілятора, яка забезпечує повні можливості відображення. Ви можете створювати екземпляри класів з їх метаданих, отримувати метадані у конструкторів класів та перевіряти інтерфейс / класи під час виконання. Ви можете перевірити це тут

Приклад використання:

В одному зі своїх файлів машинопису створіть інтерфейс та клас, який реалізує його, як описано нижче:

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

class MyClass implements MyInterface {
    counter = 0;

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

Тепер давайте надрукуємо деякий список реалізованих інтерфейсів.

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

компілювати з reflec-t і запустити його:

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

Докладні відомості про Interfaceмета-тип див. У розділі refle.d.ts.

ОНОВЛЕННЯ: Повний робочий приклад ви можете знайти тут

те саме, що вище, де використовувались визначені користувачем захисні пристрої , але цього разу з предикатом функції стрілки

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

Ось ще один варіант: модуль ts-interface-builder забезпечує інструмент вбудованого часу, який перетворює інтерфейс TypeScript в дескриптор виконання та ts-interface-checker може перевірити, чи задовольняє його об'єкт.

На прикладі ОП:

interface A {
  member: string;
}

Ви спершу запустите, ts-interface-builderякий створює новий стислий файл з дескриптором, скажімо,, foo-ti.tsякий ви можете використовувати так:

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" 

Ви можете створити функцію захисту одного вкладиша:

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

Я хотів би зазначити, що TypeScript не забезпечує прямий механізм динамічного тестування, чи реалізує об'єкт певний інтерфейс.

Натомість код TypeScript може використовувати техніку JavaScript для перевірки наявності відповідного набору членів на об’єкті. Наприклад:

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

На підставі Фентона відповіді , ось моя реалізація функції для перевірки , є чи даний objectє ключі interfaceмає, як повністю або частково.

Залежно від випадку використання, вам може знадобитися також перевірити типи властивостей кожного з інтерфейсів. Нижче наведений код не робить цього.

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

Приклад використання:

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

Оскільки тип невідомий під час виконання, я написав код наступним чином, щоб порівняти невідомий об'єкт не проти типу, а проти об'єкта відомого типу:

1. Створіть зразок об’єкта правильного типу
2. Вкажіть, які з його елементів необов’язкові
3. Зробіть глибоке порівняння вашого невідомого об’єкта з цим об’єктом зразка

Ось (інтерфейсно-агностичний) код, який я використовую для глибокого порівняння:

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

Нижче наведено приклад того, як я ним користуюся.

У цьому прикладі я очікую, що JSON містить масив кортежів, з яких другий елемент - це примірник інтерфейсу, який називається User(який має два необов'язкові елементи).

Перевірка типу TypeScript забезпечить правильність мого вибіркового об'єкта, тоді функція assertTypeT перевіряє, чи невідомий (завантажений з JSON) об'єкт відповідає об'єкту вибірки.

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

Ви можете викликати такий чек у реалізації захищеного типу захисту.

Ви можете перевірити тип TypeScript під час виконання за допомогою ts-validate-типу , як-от так (для цього потрібен плагін Babel):

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