कनेक्शन की जांच

कनेक्शन की जांच से तय होता है कि कौनसे कनेक्शन (और ब्लॉक से) एक-दूसरे से कनेक्ट हो सकते हैं.

कनेक्शन की जांच करना, मॉडलिंग के टाइप के लिए फ़ायदेमंद होता है. उदाहरण के लिए, इन तीन ब्लॉक में कोई कारोबार नहीं जोड़ा जा रहा है, क्योंकि ये अलग-अलग तरह के कोड दिखाने वाले कोड को दिखाते हैं:

इन ब्लॉक को कनेक्ट होने से रोकने के लिए, कनेक्शन की जांच की जा सकती है. इससे उपयोगकर्ताओं को तुरंत फ़ीडबैक मिलता है और कई छोटी-मोटी गलतियां कम हो जाती हैं.

कीवर्ड के काम करने का तरीका

हर कनेक्शन को "कनेक्शन की जांच" से जोड़ा जा सकता है. यह स्ट्रिंग का एक ऐसा कलेक्शन होता है जिसे शून्य किया जा सकता है.

दो कनेक्शन कनेक्ट हो सकते हैं, अगर:

1. ये काम करने के टाइप होते हैं (जैसे कि इनपुट से कनेक्ट होने वाला आउटपुट).
2. कनेक्शन की जांच में कम से कम एक स्ट्रिंग एक जैसी हो.

उदाहरण के लिए, ये दो जांच कनेक्ट हो सकती हैं, क्योंकि ये 'apple' स्ट्रिंग शेयर करती हैं:

['apple', 'ball', 'cat']
['apple', 'bear', 'caterpillar']

हालांकि, ये दोनों जांच कनेक्ट नहीं की जा सकीं, क्योंकि इनमें कोई स्ट्रिंग शेयर नहीं है:

['apple', 'ball', 'cat']
['ape', 'bear', 'caterpillar']

एक और खास मामला है. अगर दोनों में से कोई भी ऐरे null है, तो दोनों कनेक्शन भी कनेक्ट हो सकते हैं. इससे ऐसे कनेक्शन तय किए जा सकते हैं जो किसी भी चीज़ से कनेक्ट हो सकते हैं.

null
['ape', 'bear', 'caterpillar]

अहम जानकारी: ब्लॉक टाइप और कनेक्शन की जांच अलग-अलग होती हैं. ये स्ट्रिंग के पूरी तरह से अलग सेट होते हैं. कनेक्शन की जांच में ब्लॉक टाइप को शामिल करने से, उस तरह के ब्लॉक कनेक्ट नहीं होते.

चेक सेट करें

डिफ़ॉल्ट रूप से, सभी कनेक्शन में null कनेक्शन की जांच होती है. इसका मतलब है कि वे किसी भी डिवाइस से कनेक्ट कर सकते हैं. कनेक्शन की जांच मैन्युअल तरीके से करनी होगी.

कनेक्शन की जांच करने का तरीका इस हिसाब से अलग-अलग होता है कि JSON ब्लॉक की परिभाषाओं का इस्तेमाल किया जा रहा है या JavaScript ब्लॉक की परिभाषाओं का.

JSON

टॉप-लेवल कनेक्शन के लिए, आप सीधे उस प्रॉपर्टी को चेक असाइन करते हैं जो कनेक्शन के बारे में बताती है. इसके लिए, आपकी ओर से असाइन की जाने वाली वैल्यू null हो सकती है. यह एक स्ट्रिंग (जो कनेक्शन जांच में इकलौती स्ट्रिंग बन जाती है) या स्ट्रिंग का कलेक्शन हो सकता है.

{
  'type': 'custom_block',

  'output': null,
  'nextStatement': 'a connection check entry',
  'previousStatement': ['four', 'connection', 'check', 'entries']
}

इनपुट के लिए, चेक को इनपुट परिभाषा की check प्रॉपर्टी असाइन किया जा सकता है. अगर check प्रॉपर्टी मौजूद नहीं है, तो जांच को null माना जाता है. आपकी ओर से असाइन की जाने वाली वैल्यू, स्ट्रिंग या स्ट्रिंग का कलेक्शन हो सकती है.

{
  'type': 'custom_block',
  'message0': '%1 %2',

  'args0': [
    {
      'type': 'input_value',
      'check': 'a connection check entry'
    },
    {
      'type': 'input_statement',
      'check': ['four', 'connection', 'check', 'entries']
    }
  ]
}

JavaScript

टॉप-लेवल कनेक्शन के लिए, आप जांच को सीधे उस तरीके पर पास कर सकते हैं जो कनेक्शन तय करता है. अगर कोई वैल्यू पास नहीं होती, तो चेक को null माना जाता है. आपकी पास की जाने वाली वैल्यू कोई स्ट्रिंग (जो कनेक्शन जांच में इकलौती एंट्री बन जाती है) या स्ट्रिंग का कलेक्शन हो सकता है.

Blockly.Blocks['custom_block'] = {
  init: function() {
    this.setOutput(true); // null check
    this.setNextStatement(true, 'a connection check entry');
    this.setPreviousStatement(true, ['four', 'connection', 'check', 'entries']);
  }
}

इनपुट के लिए, इनपुट तय करने के बाद चेक को setCheck तरीके में पास किया जा सकता है. अगर setCheck तरीके का इस्तेमाल नहीं किया जाता है, तो जांच को null माना जाता है. जो वैल्यू पास की जाती है वह कोई स्ट्रिंग या स्ट्रिंग का कलेक्शन हो सकती है.

Blockly.Blocks['custom_block'] = {
  init: function() {
    this.appendValueInput('NAME')
        .setCheck('a connection check entry');
    this.appendStatementInput('NAME')
        .setCheck(['four', 'connection', 'check', 'entries']);
  }
}

पहले से मौजूद चेक स्ट्रिंग

पहले से मौजूद ब्लॉक में, 'Array', 'Boolean', 'Colour', 'Number', और 'String' वैल्यू के साथ कनेक्शन की जांच की जाती है. अगर आपको अपने ब्लॉक, पहले से मौजूद ब्लॉक के साथ इंटरऑपरेट करना है, तो इन्हें इस्तेमाल करने के लिए इन वैल्यू का इस्तेमाल करें.

वैल्यू के उदाहरण

इनपुट और आउटपुट के लिए कनेक्शन की जांच करते समय, आपको अलग-अलग तरह की जांच करनी चाहिए.

इनपुट की जांच में, हर उस "टाइप" की जांच शामिल होनी चाहिए जिसे वे स्वीकार करते हैं. साथ ही, आउटपुट की जांच में ठीक वही शामिल होना चाहिए जो "वे" दिखाते हैं.

सिर्फ़ एक टाइप स्वीकार करें

सबसे सामान्य मामलों में, अगर आपको ऐसा ब्लॉक बनाना है जो एक तरह का "स्वीकार करता है" या "लौटाता है", तो आपको कनेक्शन की जांच में उस टाइप को शामिल करना होगा.

एक से ज़्यादा टाइप स्वीकार करें

कई तरह के "स्वीकार" करने वाला ब्लॉक बनाने के लिए, आपको इनपुट के कनेक्शन की जांच में सभी स्वीकार किए गए टाइप को शामिल करना होगा.

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

कोई भी प्रकार स्वीकार करें

किसी भी तरह का "स्वीकार" करने वाला ब्लॉक बनाने के लिए, आपको इनपुट के कनेक्शन की जांच को null पर सेट करना होगा.

नतीजे के सब-टाइप

ऐसा ब्लॉक बनाने के लिए जो सब-टाइप "दिखाता है". आपको आउटपुट की कनेक्शन जांच में टाइप और सुपरटाइप, दोनों को शामिल करना होगा.

सब-टाइप के मामले में, आउटपुट जांच में कई जांच करना ठीक है, क्योंकि ब्लॉक हमेशा दोनों तरह की जांच "लौटता है".

पैरामीटर वाले टाइप दिखाएं

पैरामीटर वाला टाइप "लौटाने" वाला ब्लॉक बनाने के लिए, आपको आउटपुट के कनेक्शन की जांच में पैरामीटर वाले वर्शन और बिना पैरामीटर वाले वर्शन, दोनों को शामिल करना होगा.

इस आधार पर कि ब्लॉक की भाषा कितनी सख्त होनी चाहिए, आपके पास उस टाइप के वैरियंस को भी शामिल करने का विकल्प है.

इस मामले में, सब-टाइप की तरह ही, आउटपुट की जांच में कई बार जांच करने से कोई फ़र्क़ नहीं पड़ता. ऐसा इसलिए है, क्योंकि ब्लॉक हमेशा "रिटर्न" करता है.

स्टैक या स्टेटमेंट के उदाहरण

कुछ ऐसे सामान्य तरीके हैं जिनसे डेवलपर पिछले और अगले कनेक्शन की जांच तय करते हैं. आम तौर पर, आपको ये ब्लॉक के क्रम को सीमित करने की तरह ही लगते हैं.

अगले कनेक्शन में यह शामिल होना चाहिए कि कौनसे ब्लॉक मौजूदा ब्लॉक के बाद होने चाहिए, और पिछले कनेक्शन में मौजूदा ब्लॉक "है" शामिल होना चाहिए.

अहम जानकारी: ब्लॉक टाइप और कनेक्शन की जांच अलग-अलग होती हैं. जब यह लिखा हो कि "कौनसे ब्लॉक को मौजूदा प्रोसेस के हिसाब से होना चाहिए", तो इसका मतलब है कि कनेक्शन की जांच में सही जांच स्ट्रिंग शामिल होनी चाहिए, न कि ब्लॉक टाइप की.

ब्लॉक को क्रम से रखें

तय किए गए क्रम में कनेक्ट होने वाले ब्लॉक का सेट बनाने के लिए, आपको यह शामिल करना होगा कि अगले कनेक्शन की जांच में, कौनसे ब्लॉक मौजूदा ब्लॉक के हिसाब से होने चाहिए. साथ ही, पिछली कनेक्शन जांच में, मौजूदा ब्लॉक "क्या" है.

बीच के बहुत सारे ब्लॉक को अनुमति दें

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

बीच में कोई ब्लॉक न रखें

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

इनमें से कोई एक या स्टैक

एक ऐसा ब्लॉक बनाने के लिए जिसके बाद सिर्फ़ एक ग्रुप से ब्लॉक किया जा सके या किसी दूसरे ग्रुप से ब्लॉक किया जा सके (दोनों नहीं), आपको दो काम करने होंगे:

1. पहले ब्लॉक की अगली कनेक्शन जांच में, आपको दोनों समूहों के पिछले कनेक्शन की जांच में कम से कम एक एंट्री शामिल करनी होगी.

2. आपको ग्रुप के कनेक्शन की अगली जांच तय करनी होगी, ताकि सिर्फ़ वे वैल्यू शामिल की जा सकें जो उनकी पिछली कनेक्शन जांच में की गई थीं. ऐसा इसलिए, ताकि उनके बाद सिर्फ़ उसी ग्रुप के ब्लॉक की गई वैल्यू ही शामिल की जा सकें.

सीमाएं

यह सिस्टम काफ़ी मज़बूत है और इसमें कई समस्याओं को हल किया जा सकता है. हालांकि, इसकी कुछ सीमाएं होती हैं.

बड़े संदर्भ पर पाबंदी लगाएं

यह सिस्टम, खुद में ऐसे "ज़्यादा संदर्भ" को सीमित करने की सुविधा नहीं देता जिसमें किसी कनेक्शन को कनेक्ट करने की अनुमति हो. उदाहरण के लिए, यह नहीं कहा जा सकता कि break ब्लॉक को सिर्फ़ loop ब्लॉक के अंदर ही इस्तेमाल किया जा सकता है. कनेक्शन की जांच करने वाला सिस्टम, सिर्फ़ दो कनेक्शन को ध्यान में रखता है.

इवेंट सिस्टम का इस्तेमाल करके, डेटा को दूसरी जगह ले जाने की सुविधा को ब्लॉक किया गया इवेंट को सुना जा सकता है. साथ ही, यह भी देखा जा सकता है कि ब्लॉक को गलत जगह पर रखा गया है या नहीं.

Blockly.Blocks['custom_block'] = {
  init: function() { }

  onchange: function(e) {
    if (this.workspace.isDragging()) return;
    if (e.type !== Blockly.Events.BlockMove) return;
    if (!this.getSurroundLoop()) this.outputConnection.disconnect();
  }

  loopTypes: new Set(); // Your valid *block types* (not connection checks).

  getSurroundLoop: function () {
    let block = this.getSurroundParent();
    do {
      if (loopTypes.has(block.type)) return block;
      block = block.getSurroundParent();
    } while (block);
    return null;
  },
}

सामान्य टाइप

यह सिस्टम, खुद में जेनरिक टाइप तय करने में मदद नहीं करता. उदाहरण के लिए, "पहचान" ब्लॉक नहीं बनाया जा सकता. इसका इनपुट कुछ भी "दिखता है".

ब्लॉक के आउटपुट पर कनेक्शन की जांच को सक्रिय रूप से बदलकर, उसके इनपुट से मिलान करने के लिए, कुछ हद तक इसका इस्तेमाल किया जा सकता है. इसके लिए, इवेंट सिस्टम का इस्तेमाल करके, मूव इवेंट को ब्लॉक किया जा सकता है.

Blockly.Blocks['custom_block'] = {
  init: function() { }

  onchange: function(e) {
    if (e.type !== Blockly.Events.BlockMove) return;
    this.setOutput(
        true, this.getInputTargetBlock()?.outputConnection.getCheck());
  }
}

हालांकि, अगर कनेक्ट किया गया ब्लॉक सामान्य भी है, तो यह ठीक से काम नहीं करता है. इस मामले में कोई अच्छा विकल्प नहीं है.

कनेक्शन चेकर

अगर यह सिस्टम आपके इस्तेमाल के उदाहरण के लिए काम नहीं करता है, तो कस्टम कनेक्शन चेकर बनाकर, कनेक्शन जांचों की तुलना करने के तरीके को भी बदला जा सकता है.

उदाहरण के लिए, अगर आपको एक ऐसा बेहतर सिस्टम बनाना है जो इसकी कुछ सीमाओं को हैंडल कर ले, तो आपके पास कस्टम कनेक्शन चेकर बनाने का विकल्प है.