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

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

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

एक खाली सूची ब्लॉक, जो वर्गमूल ब्लॉक से कनेक्ट होता है, अपरकेस ब्लॉक

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

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

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

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

  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());
  }
}

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

कनेक्शन चेकर

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

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