वैरिएबल

वैरिएबल, प्रोग्रामिंग का एक अहम सिद्धांत है. ब्लॉकली, डाइनैमिक रूप से टाइप की गई भाषाओं, जैसे कि Python और JavaScript के साथ काम करती है. हालांकि, इसके लिए थोड़ा और काम करके, Java या C जैसी मज़बूती से टाइप की गई भाषाओं (या स्टैटिक टाइप की गई भाषाओं) के लिए जानकारी जोड़ी जा सकती है.

यहां डाइनैमिक और स्टैटिक टाइप की गई भाषाओं के बारे में ज़्यादा जानकारी दी गई है.

ब्लॉक रूप से ऐसे वैरिएबल फ़ील्ड उपलब्ध कराता है जो डाइनैमिक ड्रॉपडाउन बॉक्स होते हैं. इनमें उपयोगकर्ता ने जो वैरिएबल दिए हैं उनके नाम दिखाते हैं. नीचे एक उदाहरण दिया गया है.

डिफ़ॉल्ट रूप से, Blockly, किसी भी टाइप को वैरिएबल के लिए असाइन करने की अनुमति देता है. साथ ही, Blockly के दिए गए सभी जनरेटर, डाइनैमिक तरीके से टाइप की गई भाषाओं के लिए हैं. इसके बजाय, अगर टाइप की गई भाषा का इस्तेमाल किया जा रहा है, तो Blockly को कॉन्फ़िगर किया जा सकता है, ताकि यह सुविधा काम कर सके. इसके लिए, यह तरीका अपनाएं:

टाइप नहीं किए गए वैरिएबल ब्लॉक

किसी वैरिएबल को ऐक्सेस करने और उसमें बदलाव करने के लिए सबसे ज़रूरी ब्लॉक गैटर और सेटर ब्लॉक हैं. आइए, उन गैटर और सेटर ब्लॉक के बारे में जानते हैं जो Blockly उपलब्ध कराता है.

JSON

// Block for variable getter.
{
  "type": "variables_get",
  "message0": "%1",
  "args0": [
    {    // Beginning of the field variable dropdown
      "type": "field_variable",
      "name": "VAR",    // Static name of the field
      "variable": "%{BKY_VARIABLES_DEFAULT_NAME}"    // Given at runtime
    }    // End of the field variable dropdown
  ],
  "output": null,    // Null means the return value can be of any type
  ...
},

// Block for variable setter.
{
  "type": "variables_set",
  "message0": "%{BKY_VARIABLES_SET}",
  "args0": [
    {
      "type": "field_variable",
      "name": "VAR",
      "variable": "%{BKY_VARIABLES_DEFAULT_NAME}"
    },
    {
      "type": "input_value",    // This expects an input of any type
      "name": "VALUE"
    }
  ],
  ...
}

JavaScript

// Block for variable getter.
Blockly.Blocks['variables_get'] = {
  init: function() {
    this.appendDummyInput()
      .appendField(new Blockly.FieldVariable("VAR_NAME"), "FIELD_NAME");
    this.setOutput(true, null);
    ...
  }
};

// Block for variable setter.
Blockly.Blocks['variables_set'] = {
  init: function() {
    this.appendValueInput("NAME")
        .setCheck(null)
        .appendField("set")
        .appendField(new Blockly.FieldVariable("VAR_NAME"), "FIELD_NAME")
        .appendField("to");
    this.setOutput(true, null);
    ...
  }
};

इससे ये दो ब्लॉक बन जाते हैं:

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

टाइप किए गए वैरिएबल ब्लॉक

टाइप की जांच को लागू करने वाले गैटर और सेटर जोड़े जा सकते हैं. उदाहरण के लिए, अगर आपने "Panda" टाइप का वैरिएबल बनाया है, तो यहां दी गई परिभाषाएं, सही टाइप के साथ गेटर और सेटर बनाती हैं.

JSON

 // Block for Panda variable getter.
 {
  "type": "variables_get_panda",
  "message0": "%1",
  "args0": [
    {
      "type": "field_variable",
      "name": "VAR",
      "variable": "%{BKY_VARIABLES_DEFAULT_NAME}",
      "variableTypes": ["Panda"],    // Specifies what types to put in the dropdown
      "defaultType": "Panda"
    }
  ],
  "output": "Panda",    // Returns a value of "Panda"
  ...
},

 // Block for Panda variable setter.
{
  "type": "variables_set_panda",
  "message0": "%{BKY_VARIABLES_SET}",
  "args0": [
    {
      "type": "field_variable",
      "name": "VAR",
      "variable": "%{BKY_VARIABLES_DEFAULT_NAME}",
      "variableTypes": ["Panda"],
      "defaultType": "Panda"
    },
    {
      "type": "input_value",
      "name": "VALUE",
      "check": "Panda"    // Checks that the input value is of type "Panda"
    }
  ],
  "previousStatement": null,
  "nextStatement": null,
  ...
}

JavaScript

// Block for variable getter.
Blockly.Blocks['variables_get_panda'] = {
  init: function() {
    this.appendDummyInput()
      .appendField(new Blockly.FieldVariable(
          "VAR_NAME", ['Panda'], 'Panda'), "FIELD_NAME");
    this.setOutput(true, 'Panda');
    ...
  }
};

// Block for variable setter.
Blockly.Blocks['variables_set_panda'] = {
  init: function() {
    this.appendValueInput("NAME")
        .setCheck('Panda')
        .appendField("set")
        .appendField(new Blockly.FieldVariable(
            "VAR_NAME", null, ['Panda'], 'Panda'), "FIELD_NAME")
        .appendField("to");
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
    ...
  }
};

इससे दो तरह के ब्लॉक बनते हैं, गैटर और सेटर. उनके ड्रॉपडाउन में सिर्फ़ Panda टाइप के वैरिएबल दिखते हैं. उनके इनपुट और आउटपुट सिर्फ़ Panda टाइप वाले कनेक्शन स्वीकार करते हैं. फ़ील्ड का defaultType, variableTypes कलेक्शन की किसी एक वैल्यू पर सेट होना चाहिए. variableTypes कलेक्शन देते समय, defaultType को सेट न करने पर गड़बड़ी होगी.

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

टूलबॉक्स में वैरिएबल जोड़ें

इस नए तरह के वैरिएबल को अपने उपयोगकर्ताओं के लिए काम का बनाने के लिए, आपको नए वैरिएबल बनाने और उनका इस्तेमाल करने का तरीका जोड़ना होगा.

अगर आपके पास पहले से वैरिएबल नहीं है, तो वैरिएबल के लिए एक नई डाइनैमिक कैटगरी बनाएं.

कैटगरी में अपने नए गैटर और सेटर जोड़ें.

वैरिएबल बटन बनाएं

इसके बाद, आपके उपयोगकर्ता को वैरिएबल बनाने का कोई तरीका चाहिए. सबसे आसान तरीका है, "वैरिएबल बनाएं" बटन.

बटन बनाते समय, कॉलबैक कॉल करें

Blockly.Variables.createVariableButtonHandler(button.getTargetWorkspace(), null, 'panda');

और Panda टाइप किया गया एक वैरिएबल बनाया जाएगा!

उपयोगकर्ताओं को कई तरह के वैरिएबल बनाने की सुविधा देने का सबसे आसान तरीका यह है कि हर टाइप के हिसाब से एक "बनाएं" बटन बनाया जाए (उदाहरण के लिए, स्ट्रिंग वैरिएबल बनाएं, नंबर वैरिएबल बनाएं, पांडा वैरिएबल बनाएं).

अगर आपके पास दो या तीन से ज़्यादा वैरिएबल टाइप हैं, तो आपको फटाफट कई बटन दिख सकते हैं. ऐसे मामले में, एक पॉप-अप दिखाने के लिए @blockly/plugin-typed-variable-modal का इस्तेमाल करें, ताकि उपयोगकर्ता अपनी पसंद के मुताबिक वैरिएबल टाइप चुन सकें.

जनरेटर तय करें

आखिर में, आपको अपने नए वैरिएबल ब्लॉक के लिए ब्लॉक-कोड जनरेटर तय करने होंगे. सभी टाइप के सभी वैरिएबल पाने के लिए, सीधे ब्लॉकी.Workspace.getAllVariables() की मदद से वैरिएबल की सूची को ऐक्सेस किया जा सकता है. इसके अलावा, किसी खास टाइप के सभी वैरिएबल पाने के लिए, Blockly.Workspace.getVariablesOfType() को भी ऐक्सेस किया जा सकता है.