नाम संकल्प (प्रोग्रामिंग भाषाएं)

प्रोग्रामिंग भाषाओं में, नाम संकल्प इच्छित प्रोग्राम घटकों के लिए प्रोग्राम अभिव्यक्तियों के साथ लेक्सिकल विश्लेषण का संकल्प है।

सिंहावलोकन

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

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

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

स्थिर बनाम गतिशील

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

कुछ हद तक एक सामान्य गलत धारणा यह है कि गतिशील टाइपिंग का अर्थ गतिशील नाम समाधान है। उदाहरण के लिए, Erlang (प्रोग्रामिंग भाषा) गतिशील रूप से टाइप किया गया है, लेकिन स्थिर नाम रिज़ॉल्यूशन है। हालाँकि, स्थैतिक टाइपिंग स्थिर नाम संकल्प का संकेत देती है।

स्थैतिक नाम समाधान, संकलन के समय, उन चरों के उपयोग को पकड़ता है जो दायरे में नहीं हैं; प्रोग्रामर त्रुटियों को रोकना। डायनेमिक स्कोप रिज़ॉल्यूशन वाली भाषाएँ अधिक लचीलेपन के लिए इस सुरक्षा का त्याग करती हैं; वे आमतौर पर रनटाइम पर एक ही दायरे में चर सेट और प्राप्त कर सकते हैं।

उदाहरण के लिए, पायथन (प्रोग्रामिंग भाषा) इंटरैक्टिव आरईपीएल में:

>>> number = 99
>>> first_noun = "problems"
>>> second_noun = "hound"
>>> # Which variables to use are decided at runtime
>>> print(f"I got {number} {first_noun} but a {second_noun} ain't one.")
I got 99 problems but a hound ain't one.

हालाँकि, कोड में डायनेमिक नाम रिज़ॉल्यूशन पर भरोसा करना पायथन समुदाय द्वारा हतोत्साहित किया जाता है।^[1]^[2] सुविधा को पायथन के बाद के संस्करण में भी हटाया जा सकता है।^[3] स्थैतिक नाम रिज़ॉल्यूशन का उपयोग करने वाली भाषाओं के उदाहरणों में C (प्रोग्रामिंग भाषा), C++, E (प्रोग्रामिंग भाषा), एरलांग (प्रोग्रामिंग भाषा), हास्केल (प्रोग्रामिंग भाषा), जावा (प्रोग्रामिंग भाषा), पास्कल (प्रोग्रामिंग भाषा), स्कीम (प्रोग्रामिंग) शामिल हैं भाषा), और स्मॉलटाक। गतिशील नाम समाधान का उपयोग करने वाली भाषाओं के उदाहरणों में कुछ लिस्प (प्रोग्रामिंग भाषा) बोलियाँ, पर्ल, PHP, पायथन (प्रोग्रामिंग भाषा), REBOL और Tcl शामिल हैं।

नाम मास्किंग

मास्किंग तब होती है जब एक ही पहचानकर्ता का उपयोग ओवरलैपिंग लेक्सिकल स्कोप में विभिन्न संस्थाओं के लिए किया जाता है। चरों के स्तर पर (नामों के बजाय), इसे चर छायांकन के रूप में जाना जाता है। एक आइडेंटिफ़ायर I' (वैरिएबल X के लिए) एक आइडेंटिफ़ायर I (वेरिएबल X के लिए) को मास्क करता है जब दो शर्तें पूरी होती हैं

I' का वही नाम है जो I का है
I' को एक स्कोप में परिभाषित किया गया है जो I के स्कोप का एक सबसेट है

बाहरी चर X को आंतरिक चर X द्वारा छायांकित कहा जाता है।

उदाहरण के लिए, पैरामीटर फू इस सामान्य पैटर्न में स्थानीय चर फू को छायांकित करता है:

private int foo;  // Name "foo" is declared in the outer scope

public void setFoo(int foo) {  // Name "foo" is declared in the inner scope, and is function-local.
    this.foo = foo;  // Since "foo" will be first found (and resolved) in the ''innermost'' scope,
                     // in order to successfully overwrite the stored value of the attribute "foo"
                     // with the new value of the incoming parameter "foo", a distinction is made
                     // between "this.foo" (the object attribute) and "foo" (the function parameter). 
}

public int getFoo() {
    return foo;
}

नाम मास्किंग फ़ंक्शन ओवरलोडिंग#जटिलताओं का कारण बन सकता है, कुछ भाषाओं में ओवरलोडिंग नहीं होने के कारण, विशेष रूप से C++, इस प्रकार सभी ओवरलोडेड फ़ंक्शंस को फिर से घोषित करने या किसी दिए गए नामस्थान में स्पष्ट रूप से आयात करने की आवश्यकता होती है।

नाम संकल्प तुच्छ बनाने के लिए अल्फा का नाम बदलना

लेक्सिकल स्कूपिंग वाली प्रोग्रामिंग भाषाओं में जो चर नामों पर प्रतिबिंब (कंप्यूटर विज्ञान) नहीं करते हैं, लैम्ब्डा कैलकुलस#.CE.B1-रूपांतरण|α-रूपांतरण (या α-नामकरण) का उपयोग नाम समाधान को आसान बनाने के लिए एक प्रतिस्थापन खोज कर किया जा सकता है यह सुनिश्चित करता है कि कोई चर नाम चर किसी अन्य नाम को एक युक्त दायरे में छायांकित नहीं करता है। अल्फा-नाम बदलने से स्थिर कोड विश्लेषण आसान हो सकता है क्योंकि केवल अल्फा नाम बदलने वाले को भाषा के स्कोपिंग नियमों को समझने की आवश्यकता होती है।

उदाहरण के लिए, इस कोड में:

class Point {
private:
  double x, y;

public:
  Point(double x, double y) {  // x and y declared here mask the privates
    setX(x);
    setY(y);
  }

  void setX(double newx) { x = newx; }
  void setY(double newy) { y = newy; }
}

के अंदर Point कंस्ट्रक्टर, वर्ग चर x और y एक ही नाम के स्थानीय चरों द्वारा परिवर्तनीय छायांकन हैं। इसका अल्फ़ा-नाम बदला जा सकता है:

class Point {
private:
  double x, y;

public:
  Point(double a, double b) {
    setX(a);
    setY(b);
  }

  void setX(double newx) { x = newx; }
  void setY(double newy) { y = newy; }
}

नए संस्करण में, कोई मास्किंग नहीं है, इसलिए यह तुरंत स्पष्ट हो जाता है कि कौन सा उपयोग किस घोषणा के अनुरूप है।

यह भी देखें

नेमस्पेस (प्रोग्रामिंग)
स्कोप (प्रोग्रामिंग)
नामकरण टकराव

संदर्भ

↑ "[Python-Ideas] str.format utility function". 9 May 2009. Retrieved 2011-01-23.
↑ "8.6. Dictionary-based string formatting". diveintopython.org. Mark Pilgrim. Retrieved 2011-01-23.
↑ "9. Classes - Python documentation". Retrieved 2019-07-24. It is important to realize that scopes are determined textually: the global scope of a function defined in a module is that module's namespace, no matter from where or by what alias the function is called. On the other hand, the actual search for names is done dynamically, at run time — however, the language definition is evolving towards static name resolution, at "compile" time, so don't rely on dynamic name resolution! (In fact, local variables are already determined statically.)

[1] "[Python-Ideas] str.format utility function". 9 May 2009. Retrieved 2011-01-23.

[2] "8.6. Dictionary-based string formatting". diveintopython.org. Mark Pilgrim. Retrieved 2011-01-23.

[3] "9. Classes - Python documentation". Retrieved 2019-07-24. It is important to realize that scopes are determined textually: the global scope of a function defined in a module is that module's namespace, no matter from where or by what alias the function is called. On the other hand, the actual search for names is done dynamically, at run time — however, the language definition is evolving towards static name resolution, at "compile" time, so don't rely on dynamic name resolution! (In fact, local variables are already determined statically.)

[1]

[2]

[3]