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

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

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

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

इनके काम करने का तरीका

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

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

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;
  },
}

सामान्य टाइप

यह सिस्टम, अपने-आप जेनरिक टाइप तय करने की सुविधा नहीं देता. उदाहरण के लिए, "Identity" ब्लॉक नहीं बनाया जा सकता, यानी कि "Returns" है, भले ही उसका इनपुट कुछ भी हो.

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

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

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

हालांकि, अगर कनेक्ट किया गया ब्लॉक भी जेनरिक है, तो यह सही तरीके से काम नहीं करता. इस मामले में आगे कोई समाधान नहीं होगा.

कनेक्शन चेकर

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

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