ऐसा न हो कि मैं कहना है इस प्रकार
type foo = {
go: string;
start: string;
}
कैसे कर सकते हैं मैं dynamicaly बनाया है कि एक समारोह में वापस आ जाएगी
{ go: '', start: '' }
वहाँ पर किसी भी तरह से स्क्रिप्ट प्रकार हम गतिशील रूप से उत्पन्न खाली वस्तु के आधार पर पूरी तरह से बस प्रकार? या यह असंभव है, क्योंकि हम नहीं कर सकते सिर्फ पाश
मैं सोच रहा था की तरह कुछ इन
function generate<T>(T)<T> {
const obj = {}
for (const key of keyof T) {
obj[key] = ''
}
return obj
}
जब आप चलाने के टाइपप्रति संकलक (tscकरने के लिए ) transpile टाइपप्रति कोड में runnable, जावास्क्रिप्ट भाषा के स्थिर प्रकार की प्रणाली है, मिट जाता है. तो अपने Foo प्रकार (नाम करने के लिए अपरकेस को पूरा करने के लिए टीएस नामकरण सम्मेलनों) मौजूद नहीं है किसी भी रूप में क्रम में. वहाँ कुछ भी नहीं है आप कर सकते हैं पुनरावृति करने के लिए कुंजी मिल go और start.
सबसे सीधा तरीका है के लिए कुछ पाने के लिए ऐसा करने के क्रम में लिखने के लिए है, जावास्क्रिप्ट यह करने के लिए आवश्यक है, और फिर यह सुनिश्चित करने के लिए टाइपप्रति संकलक दे सकते हैं आप मजबूत प्रकार आप की जरूरत है जब तुम लिख रहे हैं । यह मूल रूप से रिवर्स के क्या आप की कोशिश कर रहे हैं करने के लिए करते हैं.
अपने मामले में क्या करता है generate() की जरूरत है काम करने के क्रम में क्रम में? अच्छी तरह से, अगर हम मान सकते हैं कि मूल्यों के द्वारा उत्पन्न generate() हो जाएगा वस्तुओं पकड़े केवल string-मूल्यवान गुण है, तो हम इसे पारित करने की जरूरत की एक सूची कुंजी की वस्तु है । तो क्या हुआ अगर हम लिखने generate() ऐसा करने के लिए, और फिर से परिभाषित Foo के मामले में उत्पादन की generate() के बजाय दूसरी तरह के आसपास?
उदाहरण के लिए:
function generate<K extends PropertyKey>(...keys: K[]) {
return Object.fromEntries(keys.map(k => [k, ""])) as { [P in K]: string };
}
const myFooObject = generate("go", "start");
type Foo = typeof myFooObject;
/* type Foo = {
go: string;
start: string;
} */
console.log(myFooObject)
/* {
"go": "",
"start": ""
} */
यहाँ generate() एक सामान्य समारोह है कि एक सूची लेता है की कुंजी (के प्रकार K) पैदा करता है और एक मूल्य का एक प्रकार के साथ कुंजी में K और मूल्यों के प्रकार string. कि {[P in K]: string} एक मैप के प्रकार के लिए बराबर Record<K, string> का उपयोग कर के Record<K, V> उपयोगिता प्रकार.
कार्यान्वयन का उपयोग करता है Object.fromEntries() का निर्माण करने के लिए वस्तु, और वापसी प्रकार है कहा जा करने के लिए सही प्रकार क्योंकि टाइपप्रति देखता है Object.fromEntries() लौटने के रूप में एक प्रकार है कि बहुत विस्तृत हमारे प्रयोजनों के लिए.
वैसे भी जब आप कॉल const myFooObject = generate("go", "start")पैदा करता है , एक मूल्य के प्रकार {go: string; start: string}है , जो एक ही है के रूप में अपने Foo प्रकार । तो हम कर सकते हैं बस को परिभाषित Foo के रूप में type Foo = typeof myFooObject के बजाय यह कर मैन्युअल रूप से । तुम सकता है अभी भी स्वयं इसे करते हैं, लेकिन बात मैं दिखा रहा हूँ यहाँ है कि यह बहुत आसान लिखने के लिए सूखी कोड में टाइपप्रति यदि आप के साथ शुरू मूल्यों और उत्पन्न प्रकार से उन्हें कोशिश कर के बजाय, यह करने के लिए अन्य तरह के आसपास.
फिर से, यदि आप का उपयोग कर रहे हैं टाइपप्रति संकलक tsc के रूप में है, तो प्रकार विलोपन से रोकता है लेखन generate() की परिभाषा से Foo. लेकिन...
यदि आप तैयार कर रहे हैं जोड़ने के लिए एक का निर्माण करने के लिए कदम अपनी परियोजना और प्रदर्शन कोड पीढ़ी का उपयोग कर टाइपप्रति संकलक एपीआई या कुछ और की तरह, आप कर सकते हैं तो मनमाने ढंग से चीजों के साथ प्रकार. पुस्तकालयों रहे हैं कि क्या इसी तरह की बातें करने के लिए क्या आप चाहते हैं; उदाहरण के लिए, टीएस-ऑटो-नकली का दावा उत्पन्न करने के लिए नकली वस्तुओं दिए गए एक वस्तु प्रकार है, जो की तरह लग रहा है वास्तव में अपने उपयोग के मामले में ।
इस तरह के एक अतिरिक्त का निर्माण हो सकता है एक उचित दृष्टिकोण के लिए आप, लेकिन अगर आप नीचे जाना है कि मार्ग आप ध्यान दें चाहिए कि आप उपयोग नहीं कर रहे हैं सिर्फ सादा टाइपप्रति अब (और इसलिए विषय है, शायद के बाहर गुंजाइश के लिए एक सवाल के साथ सिर्फ एक टाइपप्रति टैग).
आप बना सकता है, यह सामान्य है, इस तरह:
type foo<T extends string = string> = {
go: T;
start: T;
}
const test: foo<''> = {
go: '',
start: '',
};