Bu soru TypeScript ile Sınıf türü denetimine doğrudan analogon

Herhangi bir tür değişken herhangi bir arabirim uygularsa zamanında öğrenmek gerekir. İşte benim kod:

interface A{
    member:string;
}

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

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

Bu kodu daktilo oyun alanına girerseniz, son satır "Geçerli kapsamda A adı yok" hatası olarak işaretlenir. Ama bu doğru değil, isim mevcut kapsamda mevcut. Değişken bildirimini var a:A={member:"foobar"};editörden şikayet etmeden bile değiştirebilirim . Web'e göz attıktan ve SO'daki diğer soruyu bulduktan sonra arayüzü bir sınıfa değiştirdim, ancak örnek oluşturmak için nesne değişmezlerini kullanamıyorum.

Nasıl A tipi böyle yok olabilir merak ama oluşturulan javascript bir bakışta sorunu açıklar:

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

A'nın arayüz olarak gösterimi yoktur, bu nedenle çalışma zamanı tipi kontrolleri mümkün değildir.

Dinamik bir dil olarak javascript'in arayüz kavramı olmadığını anlıyorum. Arayüzler için kontrol yazmanın bir yolu var mı?

Dizgi oyun alanının otomatik tamamlanması, dizginin bir yöntem bile sunduğunu ortaya koyuyor implements. Nasıl Kullanabilirim?

instanceofAnahtar kelime olmadan istediğinizi elde edebilirsiniz, çünkü şimdi özel tip korumalar yazabilirsiniz:

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

Çok Üye

Bir nesnenin türünüzle eşleşip eşleşmediğini belirlemek için çok sayıda üyeyi kontrol etmeniz gerekiyorsa, bunun yerine bir ayırıcı ekleyebilirsiniz. Aşağıdakiler en temel örnektir ve kendi ayırıcılarınızı yönetmenizi gerektirir ... yinelenen ayırıcılardan kaçınmak için kalıpların derinliklerine inmeniz gerekir.

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'da, kullanıcı tanımlı tür koruma işi yapar.

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

Joe Yang'ın bahsettiği gibi: TypeScript 2.0'dan beri, etiketli birleşim türünün avantajından bile yararlanabilirsiniz.

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

Ve de çalışıyor switch.

daktilo 2.0 etiketli birliği tanıtmak

Daktilo 2.0 özellikleri

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

Kullanıcı Tanımlı Tip Muhafızlara ne dersiniz? 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();
}

Artık mümkün, TypeScripttam yansıma özellikleri sağlayan derleyicinin gelişmiş bir sürümünü çıkardım . Sınıfları meta veri nesnelerinden başlatabilir, sınıf yapıcılarından meta verileri alabilir ve çalışma zamanında arabirimi / sınıfları inceleyebilirsiniz. Buradan kontrol edebilirsiniz

Kullanım örneği:

Daktilo dosyalarınızdan birinde, aşağıdaki gibi uygulayan bir arabirim ve bir sınıf oluşturun:

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

class MyClass implements MyInterface {
    counter = 0;

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

Şimdi bazı uygulanmış arayüzlerin listesini yazdıralım.

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

reflec-ts ile derleyin ve başlatın:

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

InterfaceMeta türü ayrıntıları için yansıma.d.ts dosyasına bakın.

GÜNCELLEME: Burada tam bir çalışma örneği bulabilirsiniz

kullanıcı tanımlı korumaların kullanıldığı yerlerle aynıdır ancak bu sefer bir ok işlevi yüklemiyle

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

İşte başka bir seçenek: ts-interface-builder modülü , bir TypeScript arabirimini bir çalışma zamanı tanımlayıcısına dönüştüren bir oluşturma zamanı aracı sağlar ve ts-interface-checker bir nesnenin onu tatmin edip etmediğini kontrol edebilir.

OP örneği için,

interface A {
  member: string;
}

İlk olarak ts-interface-builder, bir tanımlayıcıyla yeni bir özlü dosya üreten foo-ti.ts, örneğin şu şekilde kullanabileceğiniz bir çalışma yürüttünüz:

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" 

Tek astarlı tip koruma işlevi oluşturabilirsiniz:

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

TypeScript'in bir nesnenin belirli bir arabirimi uygulayıp uygulamadığını dinamik olarak sınamak için doğrudan bir mekanizma sağlamadığını belirtmek isterim.

Bunun yerine, TypeScript kodu, nesnede uygun bir üye kümesinin bulunup bulunmadığını denetlemek için JavaScript tekniğini kullanabilir. Örneğin:

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

Fenton'un cevabına dayanarak, verilen objectbir anahtarın interfacetamamen veya kısmen anahtarlarına sahip olup olmadığını doğrulamak için bir işlev uygulaması .

Kullanım durumunuza bağlı olarak, arabirim özelliklerinin her birinin türlerini de kontrol etmeniz gerekebilir. Aşağıdaki kod bunu yapmaz.

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

Kullanım örneği:

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

Tür çalışma zamanında bilinmediğinden, bilinmeyen nesneyi bir türe karşı değil, bilinen türde bir nesneye karşı karşılaştırmak için aşağıdaki gibi kod yazdım:

1. Doğru türde bir örnek nesne oluşturma
2. Hangi öğelerinin isteğe bağlı olduğunu belirtme
3. Bilinmeyen nesnenizi bu örnek nesneyle derinlemesine karşılaştırın

İşte derin karşılaştırma için kullandığım (arayüz agnostik) kodu:

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şağıda onu nasıl kullandığımın bir örneği var.

Bu örnekte JSON'un, ikinci öğesinin User(iki isteğe bağlı öğeye sahip) adlı bir arabirimin bir örneği olduğu bir dizi tuples içermesini bekliyorum .

TypeScript'in tür denetimi, örnek nesnemin doğru olduğundan emin olur, ardından assertTypeT işlevi, bilinmeyen (JSON'dan yüklenen) nesnenin örnek nesneyle eşleşip eşleşmediğini denetler.

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

Kullanıcı tanımlı bir tür koruyucunun uygulanmasında böyle bir denetimi çağırabilirsiniz.

Bir TypeScript türünü ts-validate-type kullanarak çalışma zamanında doğrulayabilirsiniz (böyle bir Babel eklentisi gerektirir):

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