त्रुटि हैंडलर के साथ टाइपस्क्रिप्ट मानचित्र का उपयोग कैसे करें?

Question

टाइपस्क्रिप्ट इस कोड के बारे में शिकायत क्यों करता है?

class FooError extends Error { 
} 

const map = new Map<ErrorConstructor, any> ([ 
    [Error, 'do this'], 
    [FooError, 'do that'] 
]) 

प्रकार 'typeof FooError' 'ErrorConstructor' टाइप करने के लिए आबंटित नहीं है। ,

interface ErrorConstructor { 
    new(message?: string): Error; // is a constructor 
    (message?: string): Error; // is callable 
    readonly prototype: Error; // has an Error prototype 
} 

तो, एक ErrorConstructor जरूरतों एक निर्माता जो एक वैकल्पिक स्ट्रिंग तर्क लेता है, और यह भी एक समारोह के रूप में प्रतिदेय होने की जरूरत है:

Answer 1

ठीक है, ErrorConstructor की परिभाषा को देखो और इसे Error प्रोटोटाइप होना चाहिए। के अपने FooError वर्ग पर नजर डालते हैं:

class FooError extends Error { 
} 
FooError.prototype; // okay, type FooError 
new FooError("okay"); // okay 
FooError("oops"); // error 

यह एक FooError प्रोटोटाइप है, जो ठीक है के बाद से FooErrorError की एक उप-प्रकार है। यह एक कन्स्ट्रक्टर है, और यह एक तर्क स्वीकार करता है क्योंकि यह सुपरक्लास Error पर रोकता है, जो ErrorConstructor है। लेकिन यह एक समारोह के रूप में कॉल करने योग्य नहीं है। तो FooErrorErrorConstructor नहीं है।

---

इस बिंदु पर, आप अगर आप वास्तव में देखभाल इसके बारे में एक ErrorConstructor जा रहा है तय करने के लिए की जरूरत है। क्या आप इसे new FooError('msg') के बजाय FooError('msg') पर कॉल करने की योजना बना रहे हैं? मुझे शक है। उस मामले के लिए, क्या आप परवाह है कि निर्माता का prototype टाइप FooError है? शायद ऩही। उस स्थिति में, ErrorConstructor का उपयोग न करें। इसके बजाय, निम्न इंटरफ़ेस जो केवल किसी वैकल्पिक-एक स्ट्रिंग-आर्ग निर्माता होने के बारे में परवाह करता है का उपयोग करें:

interface NoFrillsErrorConstructor { 
    new(message?: string): Error; 
} 

अब आप अपने कोड काम करेगा:

const map = new Map<NoFrillsErrorConstructor, any> ([ 
    [Error, 'do this'], 
    [FooError, 'do that'] 
]) 

और यह सब अच्छी तरह से जब तक हो जाएगा, आप केवल निर्माताओं के रूप में नक्शे की कुंजियों का उपयोग करें:

map.forEach((val, err) => { 
    err.prototype; // exists, but is type any. Who cares, right? 
    new err(); // okay 
    err(); // not okay 
}) 

(आप देखभाल के बारे में FooErrorके अनुरूप कर हैं, जिसे व्यवस्थित किया जा सकता है, लेकिन यह थोड़ा और परेशान है। अगर आप मुझे विस्तृत करना चाहते हैं तो मुझे बताएं।)

वैसे भी, उम्मीद है कि मदद करता है; सौभाग्य!