फ़ंक्शन पैरामीटर के लिए अनाम संरचना प्रकार
टाइपस्क्रिप्ट में, मैं यह कर सकता हूं:
function foo(param: { a: string, b: number }) { }
किसी फ़ंक्शन को एक ऑब्जेक्ट घोषित करने के लिए, पैरामीटर प्रकार को स्पष्ट रूप से घोषित किए बिना इस प्रकार का नाम दिया जाता है:
interface Parameter {
a: string;
b: number;
}
function foo(param: Parameter) {}
क्या कोई ऐसा तरीका है जो मैं रस्ट में कर सकता हूं, या क्या मुझे पैरामीटर प्रकार को स्पष्ट रूप से नामित प्रकार के रूप में घोषित करना है?
जवाब
रस्ट में ट्यूपल्स, एरेज़ और स्ट्रक्चर्स पर फंक्शन पैरामीटर्स के लिए पैटर्न डिकंस्ट्रक्शन है:
fn f((a, b): (u32, i32), [x, y, z]: [String; 3]) { }
struct A { a: u32, b: String }
fn g(A { a, b }: A) { }
लेकिन इसमें अनाम प्रकारों / ऑब्जेक्ट्स के लिए ऐसा कोई सिंटैक्स नहीं है, क्योंकि ऑब्जेक्ट केवल जंग में मौजूद नहीं हैं। कल्पना कीजिए कि जंग में इसके लिए एक सिंटैक्स था:
fn f(param: {a: String, b: String}) {} // Invalid code!
कोई उस फ़ंक्शन को कैसे कॉल करेगा? इस प्रकार के उदाहरण का निर्माण करने का कोई तरीका नहीं है। जावास्क्रिप्ट (/ टाइपस्क्रिप्ट) में यह संभव है, गतिशील टाइपिंग के कारण, लेकिन जंग में आपको इसका निर्माण करने में सक्षम होने के लिए एक प्रकार जानना होगा।
यदि आप कार्यों में कीवर्ड तर्कों में रुचि रखते हैं, तो यह मदद कर सकता है: जंग में सबसे अच्छा * नकली * कीवर्ड शैली के तर्क कैसे?
यदि आप ट्यूपल्स को एक नाम देना चाहते हैं और साथ ही उनके मापदंडों का नाम भी रखते हैं, तो bindings_after_at
इस वाक्यविन्यास को सक्षम करने वाला अस्थिर -सक्षम होना चाहिए:
#![feature(bindings_after_at)]
fn f(my_tuple @ (a, b): (u32, u32)) {
println!("this: {:?}", my_tuple);
println!("is the same as: {:?}", (a, b));
}
// or this
fn g(arr @ [.., tail] : [u32; 5]) {
println!("this: {}", arr[4]);
println!("is the same as: {}", tail);
}
आप एक टपल का उपयोग कर सकते हैं:
fn foo(param: (String, usize)) {
let a: String = param.0;
let b: usize = param.1;
}
संरचना जैसे क्षेत्रों के नाम रखने के बजाय, टपल मूल्यों को अनुक्रमित किया जाता है। टपल को नष्ट करने से मूल्यों का ट्रैक रखना थोड़ा आसान हो जाता है:
fn foo((a, b): (String, usize)) {
// you can now access `a` and `b` here
}
आप रस्ट में ऐसी चीजें नहीं कर सकते क्योंकि इसमें नाममात्र प्रकार की प्रणाली है और आपका कोड संरचनात्मक प्रकार प्रणालियों का उदाहरण है। आप विकिपीडिया में उनके बारे में पढ़ सकते हैं:https://en.wikipedia.org/wiki/Nominal_type_system https://en.wikipedia.org/wiki/Structural_type_system
संरचनात्मक प्रकार की प्रणाली में, प्रकार अभी इसके खेतों का सेट है और यह नाम और परिभाषा से कोई फर्क नहीं पड़ता। इसके विपरीत, नाममात्र प्रकार की प्रणाली अलग-अलग घोषणा के साथ 2 प्रकारों का इलाज करती है लेकिन विभिन्न क्षेत्रों के समान सेट (मतलब, सामग्री से अधिक महत्वपूर्ण प्रकार का नाम)।
जंग ने नाममात्र को चुना क्योंकि यह विकराल है और प्रकार के स्तर पर कार्यक्रम के कुछ गुणों को लागू करने की अनुमति देता है। इस उदाहरण पर विचार करें:
struct Employee(String);
struct Customer(String);
fn handle_order(employee: Employee, customer: Customer){}
यदि प्रोग्रामर ने गलती की और इसे कॉल किया handle_order(customer, employee)
, तो यह एक गलती है जिसे संरचनात्मक टाइपिंग के साथ भाषा में नहीं देखा जाएगा, लेकिन नाममात्र टाइपिंग में संकलन त्रुटि को ट्रिगर करेगा।
इसके अलावा, ऐसी स्थिति भी हो सकती है जब प्रोग्रामर को प्रकार की परिभाषा बदलने की आवश्यकता होती है, उदाहरण के लिए, एक फ़ील्ड को इसमें जोड़ें Employee
। इस तरह के मामले में, कोई यह सुनिश्चित कर सकता है कि कर्मचारी के सभी उपयोगों को ठीक करने के बाद रिफैक्टिंग किया जाता है। संरचनात्मक टाइपिंग के साथ कार्यक्रम में, कोई भी निश्चित नहीं हो सकता क्योंकि एक कोड हो सकता है जो ग्राहक को भेजता है और इस प्रकार संरचनात्मक टाइप किए गए कार्यक्रमों को फिर से भरना थोड़ा कठिन है।
रस्ट में नाममात्र टाइपिंग का एक और प्रसिद्ध उदाहरण जीवनकाल है । समान परिभाषित प्रकार और अलग-अलग जीवनकाल वाले प्रकार के चर वास्तव में अलग-अलग नाममात्र होते हैं। और सभी रस्ट्स सुरक्षा इस पर आधारित है।
टाइपस्क्रिप्ट संरचनात्मक टाइपिंग का उपयोग करता है क्योंकि इसे जावास्क्रिप्ट में मैप करना आसान है।