javascript - टाइपस्क्रिप्ट के साथ इंटरफ़ेस प्रकार की जांच




compiler-construction interface (6)

TypeGuards

interface MyInterfaced {
    x: number
}

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

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

यह प्रश्न टाइपस्क्रिप्ट के साथ कक्षा प्रकार की जांच के लिए प्रत्यक्ष अनुरूप है

मुझे रनटाइम पर पता लगाना होगा कि किसी प्रकार का चर किसी इंटरफ़ेस को लागू करता है। मेरा कोड यहाँ है:

interface A{
    member:string;
}

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

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

यदि आप इस कोड को टाइपस्क्रिप्ट खेल के मैदान में दर्ज करते हैं, तो अंतिम पंक्ति को एक त्रुटि के रूप में चिह्नित किया जाएगा, "नाम ए वर्तमान दायरे में मौजूद नहीं है"। लेकिन यह सच नहीं है, नाम मौजूदा दायरे में मौजूद है। मैं परिवर्तनीय घोषणा को var a:A={member:"foobar"}; भी बदल सकता हूं var a:A={member:"foobar"}; संपादक से शिकायतों के बिना। वेब ब्राउज़ करने और अन्य प्रश्नों को खोजने के बाद मैंने इंटरफ़ेस को कक्षा में बदल दिया लेकिन फिर मैं उदाहरण बनाने के लिए ऑब्जेक्ट अक्षर का उपयोग नहीं कर सकता।

मुझे आश्चर्य हुआ कि टाइप ए इस तरह गायब हो सकता है लेकिन जेनरेट की गई जावास्क्रिप्ट पर एक नजर समस्या बताती है:

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

इंटरफ़ेस के रूप में ए का कोई प्रतिनिधित्व नहीं है, इसलिए कोई रनटाइम प्रकार की जांच संभव नहीं है।

मैं समझता हूं कि एक गतिशील भाषा के रूप में जावास्क्रिप्ट में इंटरफेस की कोई अवधारणा नहीं है। इंटरफेस के लिए चेक टाइप करने का कोई तरीका है?

टाइपस्क्रिप्ट खेल का मैदान स्वत: पूर्णता से पता चलता है कि टाइपस्क्रिप्ट एक विधि implements भी प्रदान करता है। मुझे इसे कैसे प्रयोग में लाना है ?


अब यह संभव है, मैंने अभी TypeScript कंपाइलर का एक उन्नत संस्करण जारी किया है जो पूर्ण प्रतिबिंब क्षमताओं को प्रदान करता है। आप कक्षाओं को उनके मेटाडेटा ऑब्जेक्ट्स से तुरंत चालू कर सकते हैं, क्लास कन्स्ट्रक्टर से मेटाडेटा पुनर्प्राप्त कर सकते हैं और रनटाइम पर इंटरफ़ेस / कक्षाओं का निरीक्षण कर सकते हैं। आप इसे here देख सकते here

उपयोग उदाहरण:

अपनी टाइपस्क्रिप्ट फ़ाइलों में से एक में, एक इंटरफ़ेस और एक वर्ग बनाएं जो इसे निम्न की तरह कार्यान्वित करता है:

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-ts के साथ संकलित करें और इसे लॉन्च करें:

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

Interface मेटा-प्रकार के विवरण के लिए reflection.d.ts देखें।

अद्यतन: आप here एक पूर्ण कामकाजी उदाहरण पा सकते हैं


उपरोक्त के समान, जहां उपयोगकर्ता द्वारा परिभाषित गार्ड का उपयोग किया गया था लेकिन इस बार तीर फ़ंक्शन के साथ भविष्यवाणी की गई थी

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

टाइपस्क्रिप्ट 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;
}

और जैसा कि जो यांग ने उल्लेख किया: टाइपस्क्रिप्ट 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 साथ काम करता है।


मैं यह इंगित करना चाहता हूं कि टाइपस्क्रिप्ट गतिशील रूप से परीक्षण करने के लिए प्रत्यक्ष तंत्र प्रदान नहीं करता है कि कोई ऑब्जेक्ट किसी विशेष इंटरफ़ेस को लागू करता है या नहीं।

इसके बजाए, टाइपस्क्रिप्ट कोड जावास्क्रिप्ट तकनीक का उपयोग यह जांचने के लिए कर सकता है कि ऑब्जेक्ट पर सदस्यों का उचित सेट मौजूद है या नहीं। उदाहरण के लिए:

var obj : any = new Foo();

if (obj.someInterfaceMethod) {
    ...
}

यहां एक और विकल्प है: मॉड्यूल ts-interface-builder एक बिल्ड-टाइम टूल प्रदान करता है जो एक टाइपस्क्रिप्ट इंटरफ़ेस को रनटाइम डिस्क्रिप्टर में परिवर्तित करता है, और 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