reflection - आत्मनिरीक्षण और प्रतिबिंब के बीच क्या अंतर है?




language-agnostic introspection (2)

क्या कोई भाषा / पर्यावरण अज्ञेय परिप्रेक्ष्य से इन दो विचारों के बीच अंतर बता सकता है?

क्या ऐसी स्थितियों का एक सेट भी है जो प्रोग्रामिंग भाषाओं को प्रतिबिंबित करने और / या आत्मनिर्भर होने के लिए संतुष्ट करने की आवश्यकता है?

और यदि वहां है, तो ये शर्तें क्या हैं?


आत्मनिरीक्षण टाइप करें:

रनटाइम पर ऑब्जेक्ट के प्रकार या गुणों की जांच करने के लिए प्रोग्रामिंग भाषा की क्षमता।

उदाहरण (जावा):

String myObj1 = new String();
MyCustomObject myObj2 = new MyCustomObject();
if(myObj2 instanceof MyCustomObject) {
    System.out.println("This is an example of type interospection");
}


प्रतिबिंब:

रनटाइम पर नीचे की चीज़ों को प्राप्त करने के लिए प्रोग्रामिंग भाषा की क्षमता।

  • आत्मनिरीक्षण टाइप करें (जैसा कि ऊपर देखा गया है)
  • किसी ऑब्जेक्ट की जांच करें और संशोधित करें।
  • और भी बहुत कुछ

en.wikipedia.org/wiki/Type_introspection में एक सुंदर सभ्य सारांश है:

कंप्यूटिंग में, आत्मनिरीक्षण टाइप करें किसी ऑब्जेक्ट के प्रकार या गुणों को रनटाइम पर जांचने की क्षमता है। कुछ प्रोग्रामिंग भाषाओं में यह क्षमता होती है।

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

एक स्थिर टाइप, संकलित कार्यक्रम ले लो:

SomeType function foo(int i) {
    return new SomeType(i);
}

संकलन समय पर सभी प्रकार ज्ञात और लागू होते हैं, कार्यक्रम को संकलित नहीं करना चाहिए यदि यह अपनी स्पष्ट प्रकार की बाधाओं को पूरा नहीं करता है। गतिशील प्रोग्रामिंग भाषाएं आमतौर पर इस प्रकार की कठोरता को प्रदर्शित नहीं करती हैं, चर के प्रकारों को संकलित समय पर जरूरी नहीं माना जाता है। वे इस तरह दिख सकते हैं:

function foo(i) {
    return new SomeType(i);
}

फ़ंक्शन यह गारंटी नहीं दे सकता कि i वास्तव में क्या कर रहा i , यह बस इसे पार कर रहा है। इससे कहीं समस्याएं हो सकती हैं या नहीं भी हो सकती हैं, टाइप सिस्टम यहां मदद नहीं कर सकता है। इस प्रकार की त्रुटि जांच को आम तौर पर उपयोगकर्तालैंड कोड पर ले जाया जाता है, जिसके लिए इस कोड को आत्मनिरीक्षण क्षमताओं की आवश्यकता होती है:

function foo(i) {
    if (!is_int(i)) {
        throw new InvalidArgumentException;
    }
    return new SomeType(i);
}

आत्मनिरीक्षण और प्रतिबिंब के बीच रेखा को वास्तव में आकर्षित करने के लिए कहां कुछ हद तक बहस योग्य है। कोई कह सकता है कि आत्मनिरीक्षण कुछ भी है जो कोड को जांचने की अनुमति देता है कि कुछ क्या है ("मैं क्या हूं?"), जबकि प्रतिबिंब कार्यक्रम संरचना में हेरफेर करने की क्षमता है। उदाहरण के लिए, एक PHP उदाहरण:

$ref = new ReflectionClass('Foo');
$foo = $ref->newInstanceWithoutConstructor();

इसके ऊपर एक नया उदाहरण बनाते समय उपरोक्त कोड वर्ग Foo के निर्माता को चलाता है। रनटाइम पर कोड मैनिपुलेशन है। अभ्यास में हालांकि, PHP में प्रतिबिंब एपीआई में आत्मनिरीक्षण क्षमता भी शामिल है। इनमें से कुछ क्षमताएं "निचले" आत्मनिरीक्षण क्षमताओं के साथ क्या किया जा सकता है इसका एक डुप्लिकेट है। उदाहरण के लिए:

$ref = new ReflectionClass($obj);
if ($ref->getName() == 'Foo') ...

if ($obj instanceof Foo) ...

दोनों स्निपेट अनिवार्य रूप से एक ही काम करते हैं, लेकिन एक प्रतिबिंब का उपयोग करता है और दूसरा जिसे आत्मनिरीक्षण कहा जाता है। जैसा कि आप देखते हैं, शायद ही कोई स्पष्ट विभाजन रेखा है। हालांकि, प्रतिबिंब आमतौर पर आत्मनिरीक्षण से अधिक शक्तिशाली है। उदाहरण के लिए, PHP में आपको फ़ंक्शन स्वीकार करने वाले तर्कों के प्रकारों के बारे में जानकारी प्राप्त करने के लिए प्रतिबिंब API का उपयोग करना होगा। यह सिर्फ "निष्क्रिय" आत्मनिरीक्षण है, लेकिन प्रतिबिंब एपीआई से संबंधित है। हालांकि यह ज्यादातर व्यावहारिक कार्यान्वयन का मामला है।

संक्षेप में, सामान्य परिभाषा के अनुसार, आत्मनिर्भर होने के लिए एक कार्यक्रम को रनटाइम पर अपने आप के हिस्सों की जांच करने और इस जानकारी के आधार पर अलग-अलग कोड निष्पादित करने में सक्षम होना चाहिए। इससे परे एक परावर्तक कार्यक्रम रनटाइम पर अपना कोड निष्पादन नियम बदल सकता है, उदाहरण के लिए एक कन्स्ट्रक्टर का आह्वान न करने का विकल्प चुनना, जो अन्यथा भाषा द्वारा परिभाषित अनिवार्य संचालन है।





introspection