To pytanie jest bezpośrednim sprawdzeniem analogonu do klasy za pomocą TypeScript

Muszę dowiedzieć się w czasie wykonywania, czy zmienna typu any implementuje interfejs. Oto mój kod:

interface A{
    member:string;
}

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

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

Jeśli wpiszesz ten kod na placu zabaw maszynopisu, ostatni wiersz zostanie oznaczony jako błąd: „Nazwa A nie istnieje w bieżącym zakresie”. Ale to nieprawda, nazwa istnieje w obecnym zakresie. Mogę nawet zmienić deklarację zmiennej na var a:A={member:"foobar"};bez reklamacji redaktora. Po przejrzeniu sieci i znalezieniu drugiego pytania na SO zmieniłem interfejs na klasę, ale potem nie mogę używać literałów obiektowych do tworzenia instancji.

Zastanawiałem się, jak typ A może tak zniknąć, ale spojrzenie na wygenerowany skrypt javascript wyjaśnia problem:

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

Nie ma reprezentacji A jako interfejsu, dlatego nie jest możliwe sprawdzenie typu środowiska wykonawczego.

Rozumiem, że javascript jako język dynamiczny nie ma pojęcia interfejsów. Czy jest jakiś sposób na sprawdzenie typu dla interfejsów?

Automatyczne uzupełnianie placu zabaw maszynopisu ujawnia, że ​​maszynopis oferuje nawet metodę implements. Jak mogę tego użyć?

Możesz osiągnąć to, co chcesz bez instanceofsłowa kluczowego, ponieważ możesz teraz pisać zabezpieczenia typu niestandardowego:

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

Wielu członków

Jeśli musisz sprawdzić wiele członków, aby ustalić, czy obiekt pasuje do twojego typu, możesz zamiast tego dodać dyskryminator. Poniższy przykład jest najbardziej podstawowym przykładem i wymaga zarządzania własnymi dyskryminatorami ... musisz pogłębić wzorce, aby uniknąć duplikowania dyskryminatorów.

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

W TypeScript 1.6 strażnik typów zdefiniowany przez użytkownika 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 oznaczonego typu unii.

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 to też działa switch.

maszynopis 2.0 wprowadza oznaczony związek

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

Co powiesz na zdefiniowane przez użytkownika zabezpieczenia typu? 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();
}

Jest to teraz możliwe, właśnie wydałem ulepszoną wersję TypeScriptkompilatora, która zapewnia pełne możliwości odbicia. Możesz 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 ze swoich plików maszynopisu utwórz interfejs i klasę, która implementuje 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ę zaimplementowanych interfejsów.

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

skompiluj z reflec-ts i uruchom:

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

Szczegółowe informacje na temat Interfacemeta-typów znajdują się na stronie reflection.d.ts .

AKTUALIZACJA: Pełny przykład działa tutaj

tak samo jak powyżej, gdzie zastosowano zabezpieczenia zdefiniowane 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);

Oto kolejna opcja: moduł ts-interface-builder zapewnia narzędzie do kompilacji, które konwertuje interfejs TypeScript na deskryptor środowiska wykonawczego, a ts-interface-checker może sprawdzić, czy obiekt go spełnia.

Na przykład OP

interface A {
  member: string;
}

Najpierw uruchomisz, ts-interface-builderktó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żesz utworzyć jednokierunkową funkcję ochrony typu:

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

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

Zamiast tego kod TypeScript może korzystać z techniki JavaScript do sprawdzania, czy w obiekcie znajduje się odpowiedni zestaw elementów. 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;
}

W oparciu o odpowiedź Fentona , oto moja implementacja funkcji sprawdzającej, czy dana objectma klucze i interfacema, zarówno w pełni, jak i częściowo.

W zależności od przypadku użycia może być konieczne sprawdzenie typów właściwości każdego interfejsu. Poniższy kod tego nie robi.

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

Przykład użycia:

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

Ponieważ typ jest nieznany w czasie wykonywania, napisałem kod w następujący sposób, aby porównać nieznany obiekt, nie z typem, ale z obiektem znanego typu:

1. Utwórz przykładowy obiekt odpowiedniego typu
2. Określ, który z jego elementów jest opcjonalny
3. Dokonaj dokładnego porównania swojego nieznanego obiektu z tym obiektem przykładowym

Oto kod (niezależny od interfejsu), którego używam do głębokiego porównania:

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

Poniżej znajduje się przykład tego, jak go używam.

W tym przykładzie oczekuję, że JSON zawiera tablicę krotek, z których drugi element jest instancją interfejsu o nazwie User(która ma dwa opcjonalne elementy).

Sprawdzanie typu TypeScript zapewni, że mój przykładowy obiekt jest poprawny, a następnie funkcja assertTypeT sprawdzi, czy nieznany (załadowany z JSON) obiekt pasuje do obiektu przykładowego.

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

Możesz wywołać taką kontrolę w implementacji funkcji ochrony zdefiniowanej przez użytkownika.

Możesz sprawdzić typ TypeScript w czasie wykonywania, używając ts-validate-type , podobnie jak to (wymaga wtyczki Babel):

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