angular जेनेरिक कुंजी(टी) के बीच अंतर क्या टाइपस्क्रिप्ट में किसी भी




typescript generics (4)

generic key (T) बीच अंतर क्या टाइपस्क्रिप्ट में बना है?

फ़ंक्शन 1

function identity(arg: any): any {
    return arg;
}

फ़ंक्शन 2 और 3

function identity<T>(arg: T): T {
    return arg;
}

function identity<T>(arg: T[]): T[] {
    return arg;
}

फ़ंक्शन 1 और 3 स्वीकार करते हैं अगर हम किसी प्रकार के data type को पारित करते हैं, लेकिन फ़ंक्शन 2 स्वीकार नहीं करता है, अगर हम array पास करते हैं सामान्य पद्धति का मतलब है कि यह संकलन समय पर सभी प्रकार के डेटा प्रकार को स्वीकार करता है । लेकिन यहाँ क्यों हम सामान्य तरीके में Array घोषित करने की आवश्यकता है?

इसके अलावा प्रदर्शन के लिए कौन सा समारोह अच्छा है (फ़ंक्शन 1 या फ़ंक्शन 3)?


इसमें कोई अंतर नहीं है यदि यह पहचान फ़ंक्शन है जो सिर्फ तर्क देता है और बिना किसी प्रकार के प्रतिबंधों का उपयोग करता है:

const foo: any = fn(['whatever']);

और टाइप कोड के लिए एक अंतर है:

const foo: string = fn('ok');
const bar: string = fn([{ not: 'ok' }]);

इसके अलावा, जेनेरिक प्रकार का उपयोग सिमेंटिक प्रदान करता है। यह हस्ताक्षर बताता है कि फ़ंक्शन अन्तर्हित है और कुछ भी रिटर्न देता है:

function fn(arg: any): any { ... }

यह हस्ताक्षर बताता है कि फ़ंक्शन उसके तर्क के समान प्रकार देता है:

function fn<T>(arg: T): T { ... }

असली फ़ंक्शन आमतौर पर केवल return arg उदाहरण की तुलना में अधिक सार्थक होते हैं। सामान्य प्रकार से प्रकार प्रतिबंधों का फायदा हो सकता है (जबकि any स्पष्ट रूप से नहीं कर सकता):

function fn<T>(arg: T[]): T[] {
  return arg.map((v, i) => arg[i - 1]);
}

लेकिन लाभ अधिक स्पष्ट हो जाते हैं, जब फ़ंक्शन का उपयोग अन्य सामान्य वर्गों और सामान्य कार्यों के साथ किया जाता है (और यदि गैर-जेनरिक शामिल है तो समाप्त होता है):

function fn<T>(arg: T[]): T[] {
  return Array.from(new Set<T>(arg));
}

यह इनपुट (तर्क) और आउटपुट (लौटा हुआ मूल्य) के बीच लगातार T प्रकार को बनाए रखने की अनुमति देता है:

const foo: string[] = fn(['ok']);
const bar: string[] = fn([{ not: 'ok' }]);

प्रदर्शन में कोई अंतर नहीं हो सकता क्योंकि टाइपस्क्रिप्ट प्रकार केवल डिजाइन समय पर मौजूद होते हैं।


T का मुख्य उपयोग जब आप किसी पद्धति को कॉल करते हैं तो प्रकार को तोड़ने से बचने के लिए है।

उदाहरण:

यदि तुम करो :

let foo = new Foo();
identity(foo).bar();

दूसरी पंक्ति कम्पाइलर के लिए ठीक है, लेकिन नहीं क्योंकि वह जानता है कि bar Foo प्रकार में मौजूद है, क्योंकि यह any , और any भी तरीका हो सकता है।

यदि तुम करो :

let foo = new Foo();
identity<Foo>(foo).bar();
identity<Foo>(foo).notExistingMethod();

दूसरी पंक्ति ठीक से संकलित करेगी, तीसरा नहीं, क्योंकि Foo में एक नहीं है notExistingMethod विधि विधि

किसी भी अक्सर जब आप अधिक जावास्क्रिप्ट-रास्ता में कुछ बनाने की जरूरत है, जिसका अर्थ है कि आप वास्तव में क्या आपके ऑब्जेक्ट में नहीं पता है प्रयोग किया जाता है, क्योंकि जावास्क्रिप्ट किसी भी प्रकार नहीं है (मैं es6 बारे में बात नहीं कर रहा हूँ)


रनटाइम पर सब कुछ है और इसके शीर्ष पर यह JavaScript में समय संकलित करने के लिए है यही कारण है कि कंपाइल समय में प्रकार-सुरक्षा प्रदान करने के लिए TypeScript है।

any और T / T extends आदि में अंतर यह है कि उदाहरण के लिए संकलन समय के दौरान आपके पास सुरक्षा प्रकार है

protected typeSafety = <T extends String>(args:T):T =>{
    return args;
}

this.typeSafety(1); // compile error
this.typeSafety("string"); // good to go

यदि फ़ंक्शन कुछ स्वीकार करता है, तो आपको रनटाइम पर त्रुटि होती, जो बहुत देर हो जाएगी।


इनमें से किसी भी तरीके का उपयोग करते हुए बिल्कुल कोई प्रदर्शन अंतर नहीं है, क्योंकि ये सभी फैंसी चीजें केवल Typescript शर्करा हैं और केवल विकास के लिए हैं

सभी प्रकार की जांच केवल संकलन के समय में होती है (जब आपकी साइट को सामान्य जावास्क्रिप्ट पर टाइपस्क्रिप्ट पारस्परिक रूप से बदलता / परिवर्तित किया जाता है, तो आपके सर्वर में)।

किसी भी तरह से, जब आपका कोड उपयोगकर्ता के ब्राउज़र में भेज दिया जाता है, तो ऐसा दिखता है:

function identity(arg){
    return arg;
}

लेकिन अंतर की व्याख्या करने के लिए:

any प्रकार का उपयोग करते समय आप सभी प्रकार की जांच और सुरक्षा की जांच कर सकते हैं जो कि टाइपस्क्रिप्ट की पेशकश कर रहे हैं, जबकि, T एक वेरिएबल की तरह व्यवहार करता है, जो कि प्रकार को पकड़ता है जिसे आप नहीं जानते हैं कि यह क्या हो रहा है।

इसलिए

function identity<T>(arg: T): T {
    return arg;
}

उपर्युक्त में, हम जानते हैं कि यदि identify number स्वीकार करता है, तो वह number और इतने पर वापस लौटाएगा, जहां पर:

function identity(arg: any): any {
    return arg;
}

लेकिन अब, आप नहीं जानते हैं कि क्या arg और returned मूल्य एक ही प्रकार हैं या नहीं

T मुद्दा हल होगा जब आप एक वर्ग के भीतर एक विधि बना रहे हैं और यह एक तर्क की उम्मीद कर रहा है जो आप यह सुनिश्चित करना चाहते हैं कि यह पद्धति केवल उसी प्रकार के वर्ग के निर्माता के तर्क के साथ तर्क स्वीकार करेगी जब तत्काल होगा।

export class MyClass<T>{

   myMethod(anotherArg:T){}

}

तो ऊपर का उपयोग कर:

let str = "string";
let instance = new MyClass(str);
instance.myMethod("other string") // will compile

जहाँ तक :

let num = 32423423;
let instance = new MyClass(num);
instance.myMethod("other string") // won't compile






types