JSON में ब्लॉक का स्ट्रक्चर

इस दस्तावेज़ में, हम आपके ब्लॉक में इनपुट, फ़ील्ड (लेबल शामिल हैं), और कनेक्शन तय करने के लिए, JSON का इस्तेमाल करने का तरीका बताएंगे. अगर आपको इन शब्दों के बारे में जानकारी नहीं है, तो आगे बढ़ने से पहले ब्लॉक की बनावट देखें.

JavaScript में भी अपने इनपुट, फ़ील्ड, और कनेक्शन तय किए जा सकते हैं.

खास जानकारी

JSON में, एक या उससे ज़्यादा मैसेज स्ट्रिंग (message0, message1, ...) और उनके संबंधित आर्ग्युमेंट कलेक्शन (args0, args1, ...) की मदद से, ब्लॉक के स्ट्रक्चर के बारे में बताया जाता है. मैसेज स्ट्रिंग में टेक्स्ट होता है, जिसे लेबल में बदला जाता है. साथ ही, इंटरपोलेशन टोकन (%1, %2, ...) भी होते हैं, जो कनेक्शन और ग़ैर-लेबल फ़ील्ड की जगहों को मार्क करते हैं. आर्ग्युमेंट कलेक्शन से, इंटरपोलेशन टोकन को मैनेज करने का तरीका पता चलता है.

उदाहरण के लिए, यह ब्लॉक:

को इस JSON से तय किया जाता है:

JSON

{
  "message0": "set %1 to %2",
  "args0": [
    {
      "type": "field_variable",
      "name": "VAR",
      "variable": "item",
      "variableTypes": [""]
    },
    {
      "type": "input_value",
      "name": "VALUE"
    }
  ]
}

पहला इंटरपोलेशन टोकन (%1), वैरिएबल फ़ील्ड (type: "field_variable") दिखाता है. इसकी जानकारी, args0 ऐरे में मौजूद पहले ऑब्जेक्ट से मिलती है. दूसरा टोकन (%2), वैल्यू इनपुट (type: "input_value") के आखिर में मौजूद इनपुट कनेक्शन को दिखाता है. इसकी जानकारी, args0 ऐरे में मौजूद दूसरे ऑब्जेक्ट से मिलती है.

मैसेज और इनपुट

जब कोई इंटरपोलेशन टोकन किसी कनेक्शन को मार्क करता है, तो वह असल में उस इनपुट के आखिर को मार्क करता है जिसमें कनेक्शन मौजूद होता है. ऐसा इसलिए होता है, क्योंकि वैल्यू और स्टेटमेंट इनपुट में मौजूद कनेक्शन, इनपुट के आखिर में रेंडर किए जाते हैं. इनपुट में, पिछले इनपुट के बाद और मौजूदा टोकन तक के सभी फ़ील्ड (लेबल शामिल हैं) शामिल होते हैं. यहां दिए गए सेक्शन में, मैसेज के सैंपल और उनसे बनाए गए इनपुट दिखाए गए हैं.

उदाहरण 1

JSON

{
  "message0": "set %1 to %2",
  "args0": [
    {"type": "field_variable", ...} // token %1
    {"type": "input_value", ...}    // token %2
  ],
}

इससे तीन फ़ील्ड वाला एक वैल्यू इनपुट बनता है: एक लेबल ("set"), एक वैरिएबल फ़ील्ड, और एक और लेबल ("to").

उदाहरण 2

JSON

{
  "message0": "%1 + %2",
  "args0": [
    {"type": "input_value", ...} // token %1
    {"type": "input_value", ...} // token %2
  ],
}

इससे दो वैल्यू इनपुट बनते हैं. पहले में कोई फ़ील्ड नहीं है और दूसरे में एक फ़ील्ड ("+") है.

उदाहरण 3

JSON

{
  "message0": "%1 + %2 %3",
  "args0": [
    {"type": "input_value", ...}   // token %1
    {"type": "input_end_row", ...} // token %2
    {"type": "input_value", ...}   // token %3
  ],
}

इससे ये चीज़ें बनती हैं:

• कोई फ़ील्ड नहीं होने पर वैल्यू का इनपुट,
• लेबल फ़ील्ड ("+") के साथ लाइन के आखिर में मौजूद इनपुट, जिसकी वजह से वैल्यू का यह इनपुट नई लाइन पर रेंडर होता है, और
• बिना किसी फ़ील्ड वाला वैल्यू इनपुट.

मैसेज के आखिर में डमी इनपुट

अगर आपकी message स्ट्रिंग टेक्स्ट या फ़ील्ड के साथ खत्म होती है, तो आपको डमी इनपुट के लिए इंटरपोलेशन टोकन जोड़ने की ज़रूरत नहीं है. Blockly इसे आपके लिए जोड़ता है. उदाहरण के लिए, lists_isEmpty ब्लॉक को इस तरह से तय करने के बजाय:

JSON

{
  "message0": "%1 is empty %2",
  "args0": [
    {"type": "input_value", ...} // token %1
    {"type": "input_dummy", ...} // token %2
  ],
}

Blockly को डमी इनपुट जोड़ने की अनुमति दी जा सकती है और इसे इस तरह से तय किया जा सकता है:

JSON

{
  "message0": "%1 is empty",
  "args0": [
    {"type": "input_value", ...} // token %1
  ],
}

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

implicitAlign

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

नीचे दिए गए उदाहरण में, message0 "send email to %1 subject %2 secure %3" है और Blockly तीसरी पंक्ति के लिए अपने-आप एक डमी इनपुट जोड़ता है. implicitAlign0 को "RIGHT" पर सेट करने से, यह पंक्ति दाईं ओर अलाइन हो जाती है.

implicitAlign उन सभी इनपुट पर लागू होता है जिन्हें JSON ब्लॉक की परिभाषा में साफ़ तौर पर नहीं बताया गया है. इनमें लाइन के आखिर में मौजूद वे इनपुट भी शामिल हैं जो नए लाइन वर्ण ('\n') की जगह लेते हैं. साथ ही, एक ऐसी प्रॉपर्टी lastDummyAlign0 भी है जिसका काम implicitAlign0 की तरह ही होता है. हालांकि, इसे इस्तेमाल नहीं किया जाना चाहिए.

दाईं से बाईं ओर (अरेबिक और हिब्रू) लिखी जाने वाली भाषाओं के लिए ब्लॉक डिज़ाइन करते समय, बाईं और दाईं ओर की जगह बदल जाती है. इसलिए, "RIGHT" फ़ील्ड को बाईं ओर अलाइन करेगा.

एक से ज़्यादा मैसेज

कुछ ब्लॉक अपने-आप दो या उससे ज़्यादा हिस्सों में बंट जाते हैं. इस दो लाइन वाले दोहराए जाने वाले ब्लॉक को देखें:

अगर इस ब्लॉक को एक मैसेज के साथ बताया गया था, तो message0 प्रॉपर्टी "repeat %1 times %2 do %3" होगी. यहां %2, पंक्ति के आखिर में डाले गए इनपुट को दिखाता है. अनुवादक के लिए यह स्ट्रिंग मुश्किल है, क्योंकि %2 के बदले इस्तेमाल किए गए शब्द का मतलब समझाना मुश्किल है. ऐसा हो सकता है कि कुछ भाषाओं में, %2 लाइन के आखिर में डाले जाने वाले इनपुट की ज़रूरत न पड़े. साथ ही, ऐसे कई ब्लॉक हो सकते हैं जो दूसरी पंक्ति का टेक्स्ट शेयर करना चाहते हैं. एक से ज़्यादा message और args प्रॉपर्टी का इस्तेमाल करना बेहतर तरीका है:

JSON

{
  "message0": "repeat %1 times",
  "args0": [
    {"type": "input_value", ...} // token %1 in message0
  ],
  "message1": "do %1",
  "args1": [
    {"type": "input_statement", ...} // token %1 in message1
  ],
}

JSON फ़ॉर्मैट में, message, args, और implicitAlign प्रॉपर्टी की कोई भी संख्या तय की जा सकती है. यह संख्या 0 से शुरू होती है और क्रम से बढ़ती जाती है. ध्यान दें कि ब्लॉक फ़ैक्ट्री, मैसेज को कई हिस्सों में बांटने की सुविधा नहीं देता. हालांकि, मैन्युअल तरीके से ऐसा करना आसान है.

इंटरपोलेशन टोकन का क्रम

ब्लॉक को स्थानीय भाषा में अनुवाद करते समय, आपको मैसेज में इंटरपोलेशन टोक़न का क्रम बदलना पड़ सकता है. यह खास तौर पर उन भाषाओं के लिए ज़रूरी है जिनमें शब्दों का क्रम, अंग्रेज़ी से अलग होता है. उदाहरण के लिए, हमने मैसेज "set %1 to %2" से तय किए गए ब्लॉक से शुरू किया:

अब एक ऐसी भाषा के बारे में सोचें जिसमें "put %2 in %1" कहने के लिए, "set %1 to %2" को उलटा करना पड़ता है. मैसेज में बदलाव करने (इसमें इंटरपोलेशन टोकन का क्रम भी शामिल है) और आर्ग्युमेंट कलेक्शन में कोई बदलाव न करने पर, यह ब्लॉक दिखता है:

Blockly ने फ़ील्ड का क्रम अपने-आप बदल दिया, डमी इनपुट बनाया, और बाहरी इनपुट से इंटरनल इनपुट पर स्विच कर दिया.

मैसेज में इंटरपोलेशन टोकन का क्रम बदलने की सुविधा से, स्थानीय भाषा में अनुवाद करना आसान हो जाता है. ज़्यादा जानकारी के लिए, JSON मैसेज का इंटरपोलेशन देखें.

टेक्स्ट मैनेज करना

इंटरपोलेशन टोकन के दोनों ओर मौजूद टेक्स्ट को खाली जगह से काट दिया जाता है. % वर्ण का इस्तेमाल करने वाले टेक्स्ट (उदाहरण के लिए, किसी प्रतिशत का रेफ़रंस देते समय) में %% का इस्तेमाल किया जाना चाहिए, ताकि इसे इंटरपोलेशन टोकन के तौर पर न समझा जाए.

Blockly, मैसेज स्ट्रिंग में मौजूद किसी भी न्यूलाइन वर्ण (\n) को, लाइन के आखिर में डाले जाने वाले इनपुट से अपने-आप बदल देता है.

JSON

{
  "message0": "set %1\nto %2",
  "args0": [
    {"type": "field_variable", ...}, // token %1
    {"type": "input_value", ...},    // token %2
  ]
}

आर्ग्युमेंट के अरे

हर मैसेज स्ट्रिंग को एक ही नंबर के args कलेक्शन के साथ जोड़ा जाता है. उदाहरण के लिए, message0, args0 के साथ जाता है. इंटरपोलेशन टोकन (%1, %2, ...) args कलेक्शन के आइटम के बारे में बताते हैं. साथ ही, इन टोकन को args0 कलेक्शन से पूरी तरह मैच करना चाहिए. इसमें डुप्लीकेट आइटम नहीं होने चाहिए और कोई आइटम छूटना नहीं चाहिए. टोकन नंबर, आर्ग्युमेंट कलेक्शन में मौजूद आइटम के क्रम को दिखाते हैं. हालांकि, यह ज़रूरी नहीं है कि वे मैसेज स्ट्रिंग में क्रम से हों.

आर्ग्युमेंट कलेक्शन में मौजूद हर ऑब्जेक्ट में एक type स्ट्रिंग होती है. बाकी पैरामीटर, टाइप के हिसाब से अलग-अलग होते हैं:

• फ़ील्ड:
  • field_input
  • field_dropdown
  • field_checkbox
  • field_colour
  • field_number
  • field_angle
  • field_variable
  • field_label
  • field_image.
• इनपुट:
  • input_value
  • input_statement
  • input_dummy
  • input_end_row

आपके पास अपने कस्टम फ़ील्ड और कस्टम इनपुट तय करने का विकल्प भी होता है. साथ ही, उन्हें आर्ग्युमेंट के तौर पर पास किया जा सकता है.

alt फ़ील्ड

हर ऑब्जेक्ट में alt फ़ील्ड भी हो सकता है. अगर Blockly, ऑब्जेक्ट के type को पहचान नहीं पाता है, तो उसकी जगह alt ऑब्जेक्ट का इस्तेमाल किया जाता है. उदाहरण के लिए, अगर Blockly में field_time नाम का नया फ़ील्ड जोड़ा जाता है, तो इस फ़ील्ड का इस्तेमाल करने वाले ब्लॉक, Blockly के पुराने वर्शन के लिए field_input फ़ॉलबैक तय करने के लिए alt का इस्तेमाल कर सकते हैं:

JSON

{
  "message0": "sound alarm at %1",
  "args0": [
    {
      "type": "field_time",
      "name": "TEMPO",
      "hour": 9,
      "minutes": 0,
      "alt":
        {
          "type": "field_input",
          "name": "TEMPOTEXT",
          "text": "9:00"
        }
    }
  ]
}

किसी alt ऑब्जेक्ट में अपना alt ऑब्जेक्ट हो सकता है. इससे चेनिंग की सुविधा मिलती है. आखिर में, अगर Blockly किसी alt ऑब्जेक्ट को बनाने की कोशिश करने के बाद भी, args0 कलेक्शन में कोई ऑब्जेक्ट नहीं बना पाता है, तो उस ऑब्जेक्ट को स्किप कर दिया जाता है.