अर्ली और लेट बाइंडिंग में क्या अंतर है?

Question

शुरुआती और देर से बाध्यकारी के बीच अंतर क्या है?

Comments

देर से और जल्दी बाध्यकारी

— jfs

क्या मुझे देर से कहना = सीधे फ़ंक्शन कॉल करना गलत होगा जबकि फ़ंक्शन पॉइंटर के माध्यम से कार्य करने के लिए देर से कॉल करना =? यह कभी भी मुझे विस्मित नहीं करता है कि कैसे प्रोग्रामर के पास सरल अवधारणाओं को लेने का एक तरीका है और उन्हें ऐसा लगता है कि वे जिस तरह से हैं उससे कहीं अधिक जटिल हैं (जैसे कि बुद्धिमत्ता का प्रदर्शन?)। प्रोग्रामिंग स्वाभाविक रूप से अध्ययन का एक बहुत ही आसान क्षेत्र है जब तक कि आप चीजों के लिए नीचे नहीं आते जैसे कि एक फ्लोट प्रकार कैसे बनाया जाता है या कंपाइलर्स का विकास होता है।

— बॉब ब्लॉग

प्रारंभिक और देर से बाध्यकारी के

— बर्कले

Answer 1

संक्षिप्त उत्तर यह है कि प्रारंभिक (या स्थैतिक) बाइंडिंग का अर्थ है टाईम बाइंडिंग और लेट (या डायनामिक) बाइंडिंग रनटाइम बाइंडिंग को संदर्भित करता है (उदाहरण के लिए जब आप प्रतिबिंब का उपयोग करते हैं)।

Comments

लेकिन देर से बाध्यकारी ( en.wikipedia.org/wiki/Late_binding ) पर विकिपीडिया लेख कहता है कि "देर से बाध्यकारी अक्सर गतिशील प्रेषण के साथ भ्रमित होता है, लेकिन महत्वपूर्ण अंतर हैं"। तो क्या वे वही हैं या नहीं? यदि वे समान हैं, तो उस विकिपीडिया पृष्ठ को बदलने की आवश्यकता है।

— अलेक्जेंडर बर्ड

बेहतर stackoverflow जवाब यहाँ stackoverflow.com/questions/484214/early-and-late-binding

— baggers

Answer 2

संकलित भाषाओं में, अंतर स्पष्ट है।

जावा:

//early binding:
public create_a_foo(*args) {
 return new Foo(args)
}
my_foo = create_a_foo();

//late binding:
public create_something(Class klass, *args) {
  klass.new_instance(args)
}
my_foo = create_something(Foo);

पहले उदाहरण में, संकलनकर्ता संकलन समय पर सभी प्रकार के साफ-सुथरे सामान कर सकता है। दूसरे में, आपको बस यह आशा करनी होगी कि जो भी विधि का उपयोग करता है वह जिम्मेदारी से करता है। (बेशक, नए जेवीएम Class<? extends Foo> klassसंरचना का समर्थन करते हैं, जो इस जोखिम को काफी कम कर सकते हैं।)

एक और लाभ यह है कि आईडीई क्लास की परिभाषा को हॉटलिंक कर सकता है, क्योंकि यह विधि में वहीं घोषित किया गया है। Create_something (Foo) का कॉल विधि परिभाषा से बहुत दूर हो सकता है , और यदि आप विधि की परिभाषा देख रहे हैं, तो कार्यान्वयन को देखना अच्छा हो सकता है।

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

Answer 3

Http://word.mvps.org/fAQs/InterDev/EarlyvsLateB.bm से सीधे लिया गया

प्रोग्राम को किसी अन्य एप्लिकेशन को नियंत्रित करने के लिए स्वचालन (या OLE स्वचालन) का उपयोग करने के दो तरीके हैं।

लेट बाइंडिंग Create ऑब्जेक्ट का उपयोग और अनुप्रयोग ऑब्जेक्ट के उदाहरण के लिए करता है, जिसे आप तब नियंत्रित कर सकते हैं। उदाहरण के लिए, लेट बाइंडिंग का उपयोग करके एक्सेल का एक नया उदाहरण बनाने के लिए:

 Dim oXL As Object
 Set oXL = CreateObject("Excel.Application")

दूसरी ओर, एक्सेल के मौजूदा उदाहरण (यदि एक्सेल पहले से खुला है) में हेरफेर करने के लिए, आप गेटऑबजेक्ट (चाहे आप जल्दी या देर से बाध्यकारी उपयोग कर रहे हों) का उपयोग करेंगे:

 Dim oXL As Object
 Set oXL = GetObject(, "Excel.Application")

शुरुआती बंधन का उपयोग करने के लिए, आपको सबसे पहले अपने प्रोजेक्ट में एक संदर्भ सेट करना होगा जिस एप्लिकेशन में आप हेरफेर करना चाहते हैं। किसी भी Office अनुप्रयोग के VB संपादक में, या स्वयं VB में, आप टूल + सन्दर्भों का चयन करके, और उस सूची से इच्छित अनुप्रयोग का चयन करते हैं (जैसे "Microsoft Excel 8.0 ऑब्जेक्ट लाइब्रेरी")।

जल्दी बाध्यकारी का उपयोग करके एक्सेल का एक नया उदाहरण बनाने के लिए:

 Dim oXL As Excel.Application
 Set oXL = New Excel.Application

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

Comments

मुझे पता है कि यह उत्तर पुराना है, और यह कहीं और से लिया गया है, लेकिन यह सटीक नहीं है। लेट बाइंडिंग से CreateObject का उपयोग होता है, लेकिन क्रिएट ऑबजेक्ट जरूरी नहीं कि देर से बाइंडिंग हो। किसी वस्तु को तत्काल घोषित करने की विधि पर बाइंडिंग लागू नहीं होती है, केवल यह घोषित किया जाता है कि कैसे। यदि आप अपनी वस्तु "एक्सेल.ऐप्लिकेशन" के रूप में घोषित करते हैं, तो इससे कोई फर्क नहीं पड़ता कि आप इसे कैसे त्वरित करते हैं। मैं हमेशा बाहरी पुस्तकालयों के लिए ऑब्जेक्ट संदर्भों के तात्कालिक उपयोग के लिए CreateObject का उपयोग करता हूं, इस तरह से मैं जल्दी और देर से बाध्यकारी के बीच स्विच कर सकता हूं और केवल एक पंक्ति (दो नहीं) को स्विच करना होगा - वह रेखा जो ऑब्जेक्ट को घोषित करती है।

— जिम्मीपेना

Answer 4

हर्बर्ट शिल्ड्ट C ++ पुस्तक से समान लेकिन अधिक विस्तृत उत्तर: -

प्रारंभिक बाध्यकारी उन घटनाओं को संदर्भित करता है जो संकलन समय पर होती हैं। संक्षेप में, प्रारंभिक बाध्यकारी तब होता है जब किसी फ़ंक्शन को कॉल करने के लिए आवश्यक सभी जानकारी संकलन समय पर जानी जाती है। (अलग तरीके से कहें, तो शुरुआती बाध्यकारी का मतलब है कि एक ऑब्जेक्ट और एक फ़ंक्शन कॉल संकलन के दौरान बाध्य है।) शुरुआती बाइंडिंग के उदाहरणों में सामान्य फ़ंक्शन कॉल (मानक लाइब्रेरी फ़ंक्शन सहित), अतिभारित फ़ंक्शन कॉल और अतिभारित ऑपरेटर शामिल हैं। शुरुआती बंधन के लिए मुख्य लाभ दक्षता है। क्योंकि फ़ंक्शन को कॉल करने के लिए आवश्यक सभी जानकारी संकलन समय पर निर्धारित की जाती है, इस प्रकार के फ़ंक्शन कॉल बहुत तेज़ होते हैं।

शुरुआती बंधन के विपरीत देर से बाध्यकारी है। लेट बाइंडिंग फ़ंक्शन कॉल को संदर्भित करता है जो रन टाइम तक हल नहीं होते हैं। आभासी कार्यों का उपयोग देर से बंधन को प्राप्त करने के लिए किया जाता है। जैसा कि आप जानते हैं, जब पहुंच एक आधार सूचक या संदर्भ के माध्यम से होती है, तो वास्तव में कहा जाने वाला आभासी फ़ंक्शन सूचक द्वारा इंगित ऑब्जेक्ट के प्रकार से निर्धारित होता है। क्योंकि ज्यादातर मामलों में यह निर्धारित समय पर निर्धारित नहीं किया जा सकता है, ऑब्जेक्ट और फ़ंक्शन रन टाइम तक लिंक नहीं होते हैं। देर से बाँधने का मुख्य लाभ लचीलापन है। शुरुआती बाध्यकारी के विपरीत, देर से बाध्यकारी आपको ऐसे कार्यक्रम बनाने की अनुमति देता है जो होने वाली घटनाओं पर प्रतिक्रिया कर सकते हैं जबकि कार्यक्रम बड़ी मात्रा में "आकस्मिकता कोड" बनाए बिना निष्पादित होता है। ध्यान रखें कि क्योंकि फंक्शन कॉल को रन टाइम तक हल नहीं किया जाता है, देर से बाध्यकारी कुछ धीमी निष्पादन समय के लिए कर सकता है। हालाँकि आज,

Comments

"ऑब्जेक्ट और फ़ंक्शन को रन टाइम तक लिंक नहीं किया जाता है" यह कथन का अर्थ है कि एक ऑब्जेक्ट रन टाइम से पहले मौजूद है। क्या वस्तुएं विशुद्ध रूप से टाइम एंटिटी नहीं चलती हैं? संकलन के समय मौजूद वस्तु का वर्ग। यह बेहतर रूप में वर्णित किया जा सकता है "समारोह कॉल और इसके कार्यान्वयन रन समय तक जुड़े हुए नहीं हैं"

— programmerravi

देर से बाध्यकारी का एक उदाहरण बहुरूपता (ओओपी में) है कि हम इंटरफेस या अमूर्त वर्गों का उपयोग करते हैं और फिर हम रनटाइम में बांधते हैं।

— मोहम्मद मिर्ज़ादेह

Answer 5

व्याख्या की गई भाषाओं में, अंतर थोड़ा अधिक सूक्ष्म है।

माणिक:

# early binding:
def create_a_foo(*args)
  Foo.new(*args)
end
my_foo = create_a_foo

# late binding:
def create_something(klass, *args)
  klass.new(*args)
end
my_foo = create_something(Foo)

क्योंकि रूबी (आम तौर पर) संकलित नहीं है, निफ्टी अप-फ्रंट सामान करने के लिए कोई कंपाइलर नहीं है। JRuby की वृद्धि का मतलब है कि इन दिनों अधिक रूबी संकलित है, हालांकि, यह जावा की तरह अधिक कार्य करता है, ऊपर।

आईडीई के साथ मुद्दा अभी भी खड़ा है: यदि आप उन्हें हार्ड-कोड करते हैं, तो ग्रहण की तरह एक प्लेटफॉर्म कक्षा की परिभाषाओं को देख सकता है, लेकिन अगर आप उन्हें कॉल करने वाले तक नहीं छोड़ते हैं।

रूबी में व्युत्क्रम नियंत्रण बहुत लोकप्रिय नहीं है, शायद इसकी चरम रनटाइम लचीलेपन के कारण, लेकिन रेल आपके एप्लिकेशन को प्राप्त करने के लिए आवश्यक कॉन्फ़िगरेशन की मात्रा को कम करने के लिए देर से बाध्यकारी का बहुत उपयोग करता है।

Comments

यह बिंदु उन संकलित भाषाओं पर भी लागू होता है, जिनमें JIT संकलित घटक शामिल हो सकते हैं और प्लग इन या डायनेमिक फ़्रेमवर्क को कार्यान्वित करने के लिए रनटाइम में शामिल हैं। इस के कुछ विहित उदाहरण जावा में मौजूद हैं, और निश्चित रूप से रूबी और पायथन के रूप में भी। एक चरम उदाहरण एर्लैंग है, जहां रनटाइम किसी भी मॉड्यूल के दो संस्करणों को एक साथ लाइव अपग्रेड / डाउनग्रेड के लिए लोड कर सकता है। इसलिए हालांकि बहुत सारे एरलांग कोड (अधिकांश?) को सांख्यिकीय रूप से टाइप किए गए शुद्ध कार्यों के रूप में लिखा गया है, रनटाइम की आवश्यकताएं हुड के नीचे देर से बाध्यकारी और गतिशील प्रकारों को जनादेश देती हैं।

— zxq9

Answer 6

public class child()
{    public void method1()
     {     System.out.println("child1");
     }
    public void method2()
     {     System.out.println("child2");
     }

}
public class teenager extends child()
{    public void method3()
     {      System.out.println("teenager3");
     }
}
public class adult extends teenager()
{     
    public void method1()
    {    System.out.println("adult1);
         super.method1();
     }
}


//In java
public static void main(String []args)
{    ((teenager)var).method1();
}

यह प्रिंट आउट लेगा

adult1
child1

शुरुआती बाइंडिंग में कंपाइलर के पास बच्चे और किशोरी में सभी तरीकों तक पहुंच होगी, लेकिन देर से बाइंडिंग (रनटाइम में), यह उन तरीकों की जांच करेगा जो रनटाइम में ओवरराइड हैं।

इसलिए मेथ 1 (बच्चे से - जल्दी बंधन) को रनटाइम (देर से बाध्यकारी) पर वयस्क से मेथ 1 द्वारा ओवरराइड किया जाएगा। तब यह बच्चे से मेथड 1 को लागू करेगा क्योंकि किशोरी में मेथड 1 में मेथड 1 नहीं है।

ध्यान दें कि यदि बच्चे के पास मेथड 1 नहीं है तो मुख्य में कोड संकलित नहीं होगा।

Answer 7

जब हम अलग-अलग व्यवहारों के साथ एक ही विधि का नाम लेते हैं, तो संकलन समय बहुरूपता को अतिभार या प्रारंभिक बंधन या स्थैतिक बंधन भी कहा जाता है। एक ही विधि के कई प्रोटोटाइप को लागू करने और इसमें अलग-अलग व्यवहार होता है। प्रारंभिक बाध्यकारी कार्यक्रम के पहले संकलन को संदर्भित करता है। लेकिन देर से बाध्यकारी वस्तु में रनटाइम प्रोग्राम में होता है। इसे डायनामिक बाइंडिंग या ओवरराइडिंग या रनटाइम पॉलीमोर्फिज्म भी कहा जाता है।