ब्लॉक (प्रोग्रामिंग)

Not to be confused with ब्लॉक प्रोग्रामिंग.

"कोड ब्लॉक" redirects here. For द आईडीइ, see कोड ::ब्लॉक्स. For ब्लॉक-बेस्ड प्रोग्रामिंग, see विसुअल प्रोग्रामिंग भाषा.

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

ब्लॉक के दो फंक्शन्स हैं: स्टेटमेंट्स को समूहित करना ताकि उन्हें एक स्टेटमेंट् के रूप में माना जा सके, और नाम स्कोप को परिभाषित करना ताकि उन्हें उसी नाम से अलग किया जा सके जो कहीं और उपयोग किया गया हो। एक ब्लॉक-संरचित प्रोग्रामिंग भाषा में, बाहरी ब्लॉकों में नामित ऑब्जेक्ट आंतरिक ब्लॉकों के अंदर दिखाई देते हैं, जब तक कि वे उसी नाम से घोषित ऑब्जेक्ट द्वारा नाम मास्किंग न हों।

इतिहास

ब्लॉक संरचना के विचार 1950 के दशक में पहले ऑटोकोड के विकास के दौरान विकसित किए गए थे, और उन्हें एल्गोल 58 और एल्गोल 60 विवरण में औपचारिक रूप दिया गया था। एल्गोल 58 ने "कंपाउंड स्टेटमेंट्" की धारणा पेश की, जो केवल पूरी तरह से कन्ट्रोल फ्लो से संबंधित थी। बाद की संशोधित विवरण जिसमें अल्गोल 60 के सिंटेक्स और सिमेंटिक का वर्णन किया गया है, एक ब्लॉक और ब्लॉक स्कोप की धारणा को पेश करता है, जिसमें एक ब्लॉक होता है जिसमें डिक्लेरेशन का एक क्रम होता है, "जिसके बाद स्टेटमेंट्स का एक क्रम होता है और शुरुआत और अंत के बीच संलग्न होता है।" जिसमें [e] बहुत डिक्लेरेशन एक ब्लॉक में इस तरह से प्रकट होती है और केवल उस ब्लॉक के लिए मान्य होती है।

सिंटेक्स

ब्लॉक अलग-अलग भाषाओं में अलग-अलग सिंटैक्स का उपयोग करते हैं। दो व्यापक परिवार हैं:

• एल्गोल परिवार जिसमें ब्लॉक "begin"और"end"या उसके बराबर को कीवर्ड द्वारा सीमांकित किया गया है। C में, ब्लॉक को कर्ली ब्रेसेस(मझला कोष्ठकों) द्वारा सीमांकित किया जाता है -{और}. एल्गोल 68 कोष्ठकों का उपयोग करता है।
• कोष्ठक -(और), MS-DOS बैच भाषा में उपयोग किए जाते हैं
• इंडेंटेशन, जैसा कि पायथन में है
• एस-एक्सप्रेशन जैसे सिंटैक्टिक कीवर्ड के साथ prog या let (जैसा कि लिस्प परिवार में है)
• 1968 में (एल्गोल 68 के साथ), फिरएडस्गेर डब्ल्यू. डिजकस्रा की 1974 में गार्डेड कमांड भाषा में सशर्त और पुनरावृत्त कोड ब्लॉक को वैकल्पिक रूप से ब्लॉक आरक्षित शब्द के साथ समाप्त कर दिया गया: उदा। if ~ then ~ elif ~ else ~ fi, case ~ in ~ out ~ esac और for ~ while ~ do ~ od

सीमाएं

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

मूल शब्दार्थ

एक ब्लॉक का शब्दार्थ अर्थ द्विमुखी है। सबसे पहले, यह प्रोग्रामर को मनमाने ढंग से बड़े और जटिल ढांचे बनाने का एक तरीका प्रदान करता है जिसे इकाइयों के रूप में माना जा सकता है। दूसरे, यह प्रोग्रामर को वेरिएबल्स के दायरे को सीमित करने और कभी-कभी अन्य ऑब्जेक्ट्स को डिक्लेअर करने में सक्षम बनाता है।

फोरट्रान चतुर्थ और बेसिक जैसी शुरुआती भाषाओं में, कोई स्टेटमेंट ब्लॉक या कंट्रोल स्ट्रक्चर नहीं थे। कंडीशनल के लिए गो टू स्टेटमेंट्स का उपयोग करके सशर्त लागू किए गए थे:

     C     LANGUAGE: ANSI STANDARD FORTRAN 66

C     INITIALIZE VALUES TO BE CALCULATED
      PAYSTX = .FALSE.
      PAYSST = .FALSE.
      TAX = 0.0
      SUPTAX = 0.0
C     SKIP TAX DEDUCTION IF EMPLOYEE EARNS LESS THAN TAX THRESHOLD
      IF (WAGES .LE. TAXTHR) GOTO 100
      PAYSTX = .TRUE.
      TAX = (WAGES - TAXTHR) * BASCRT
C     SKIP SUPERTAX DEDUCTION IF EMPLOYEE EARNS LESS THAN SUPERTAX THRESHOLD
      IF (WAGES .LE. SUPTHR) GOTO 100
      PAYSST = .TRUE.
      SUPTAX = (WAGES - SUPTHR) * SUPRAT
  100 TAXED = WAGES - TAX - SUPTAX

प्रोग्राम की तार्किक संरचना भाषा में परिलक्षित नहीं होती है, और जब किसी दिए गए कथन को निष्पादित किया जाता है तो उसका विश्लेषण करना कठिन हो सकता है।

ब्लॉक प्रोग्रामर को बयानों के एक समूह को एक इकाई के रूप में व्यवहार करने की अनुमति देते हैं, और पूर्व निर्धारित मान जो प्रोग्रामिंग की इस शैली में आरंभीकरण में प्रकट होते हैं, उन्हें ब्लॉक संरचना के साथ, निर्णय के करीब रखा जा सकता है:

      { Language: Jensen and Wirth Pascal }

    if wages > tax_threshold then
        begin
        paystax := true;
        tax := (wages - tax_threshold) * tax_rate
        { The block structure makes it easier to see how the code could
          be refactored for clarity, and also makes it easier to do,
          because the structure of the inner conditional can easily be moved
          out of the outer conditional altogether and the effects of doing
          so are easily predicted. }
        if wages > supertax_threshold then begin
            pays_supertax := true;
            supertax := (wages - supertax_threshold) * supertax_rate
        end
        else begin
            pays_supertax := false;
            supertax := 0
        end
    end
    else begin
        paystax := false; pays_supertax := false;
        tax := 0; supertax := 0
    end;
    taxed := wages - tax - supertax;

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

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

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

 ;; Language: R5RS Standard Scheme

(let ((empno (ssn-of employee-name)))
  (while (is-manager empno)
    (let ((employees (length (underlings-of empno))))
      (printf "~a has ~a employees working under him:~%" employee-name employees)
      (for-each
        (lambda (empno)
          ;; Within this lambda expression the variable empno refers to the ssn
          ;; of an underling. The variable empno in the outer expression,
          ;; referring to the manager's ssn, is shadowed.
          (printf "Name: ~a, role: ~a~%"
                  (name-of empno)
                  (role-of empno)))
        (underlings-of empno)))))

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

उत्थापन

कुछ भाषाओं में, एक वेरिएबल को संलग्न ब्लॉकों के भीतर भी फंक्शन्स में घोषित किया जा सकता है। उदाहरण के लिए, जावास्क्रिप्ट में, var के साथ घोषित वेरिएबल्स में फंक्शन स्कोप है।

यह भी देखें

• मूल ब्लॉक
• ब्लॉक गुंजाइश
• क्लोजर (कंप्यूटर प्रोग्रामिंग)
• बहाव को काबू करें