ब्लॉक करने से ब्रैकेट दिखते हैं. उदाहरण के लिए, जब आपको ये ब्लॉक दिखते हैं, तो आप मान लेते हैं कि इसका मतलब -(5 + 2)
है, -5 + 2
नहीं, क्योंकि 5
और 2
एक ब्लॉक का हिस्सा हैं और -
दूसरे ब्लॉक का हिस्सा है.
हालांकि, अगर हर ब्लॉक के आस-पास ब्रैकेट डाले जाते हैं, तो कोड को पढ़ना और समझना आसान हो जाता है. (((5) * (2)) + (3))
की तुलना 5 * 2 + 3
से करें. ये दोनों एक्सप्रेशन एक ही चीज़ (13
) के हिसाब से आकलन करते हैं, लेकिन दूसरे वाले को पढ़ना ज़्यादा आसान होता है.
ब्लॉकली ऑपरेटर प्राथमिकता नियम, ब्रैकेट की कम से कम संख्या के साथ कोड जनरेट करने में आपकी मदद करता है, ताकि इसे ज़्यादा से ज़्यादा पढ़ा जा सके.
"सही" आउटपुट जनरेट करें
अगर जनरेट किए गए कोड की ज़रूरत नहीं है कि उसे कोई भी व्यक्ति आसानी से पढ़ सके, तो ब्रैकेट को छोटा करने की ज़रूरत नहीं है. हर ब्लॉक को रैप करना एक अच्छा तरीका है. इससे यह पक्का होता है कि आपके जनरेट किए गए कोड का हमेशा सही आकलन किया जाए.
सटीक होने के लिए, हमेशा Order.ATOMIC
से valueToCode
कॉल पास करें. साथ ही, ब्लॉक-कोड जनरेटर से हमेशा Order.NONE
का जवाब दें.
बेहतर ब्रैकेट जनरेट करें
ब्रैकेट सिर्फ़ तब डालने चाहिए, जब जनरेट किया गया कोड गलत हो. ऐसा तब होता है, जब बाहरी ब्लॉक में किसी ऑपरेटर की प्राथमिकता, अंदरूनी ब्लॉक में किसी ऑपरेटर की प्राथमिकता से ज़्यादा होती है.
उदाहरण के लिए, इन ब्लॉक में एक यूनरी निगेशन ऑपरेटर और एक एडिशन ऑपरेटर है. अतिरिक्त निगेशन को अतिरिक्त ऑपरेटर से ज़्यादा प्राथमिकता दी जाती है.
इसलिए, अगर ब्रैकेट नहीं जोड़े जाते, तो आपको -5 + 2
मिलता है और +
से पहले -
का आकलन किया जाता है, जो ब्लॉक से मेल नहीं खाता.
आपके अलग-अलग ऑपरेटर कितने मज़बूत हैं, इस बारे में बताकर, जनरेटर को यह बताया जा सकता है कि ब्रैकेट कब शामिल करने हैं. अगर बाहरी ऑपरेटर, अंदरूनी ऑपरेटर की तुलना में ज़्यादा मज़बूत है, तो अंदरूनी ऑपरेटर को सुरक्षित रखने के लिए ब्रैकेट शामिल किया जाता है.
valueToCode
, आउटर ऑपरेटर की प्राथमिकता लेता है और रिटर्न
टपल, इनर ऑपरेटर की प्राथमिकता बताता है.
यहां ऐसे ब्लॉक का उदाहरण दिया गया है जिसमें दो ऑपरेटर शामिल हैं:
import {javascriptGenerator, Order} from 'blockly/javascript';
javascriptGenerator.forBlock['negate_plus_two'] = function(block, generator) {
// valueToCode takes in the precedence of the outer operator.
const innerCode = generator.valueToCode(block, 'INNER', Order.UNARY_NEGATION);
const code = `-${innerCode} + 2`;
// The return tuple specifies the precedence of the inner operator.
return [code, Order.ADDITION];
}
valueToCode की प्राथमिकता
जब किसी इनर ब्लॉक का कोड जनरेट करने के लिए valueToCode
को कॉल किया जाता है, तो इसे इनर ब्लॉक के कोड पर काम करने वाले सबसे मज़बूत ऑपरेटर को प्राथमिकता दी जाती है. यह वह ऑपरेटर है जिससे अंदरूनी ब्लॉक के कोड को सुरक्षित रखने की ज़रूरत होती है.
उदाहरण के लिए, नीचे दिए गए ब्लॉक में, यूनरी निगेशन ऑपरेटर और
एडीशन ऑपरेटर, दोनों अंदरूनी ब्लॉक के कोड पर काम कर रहे हैं. एकतरफ़ा निगेशन
ज़्यादा मज़बूत होता है. इसलिए, आपको valueToCode
को भी यही प्राथमिकता देनी चाहिए.
// The - is the strongest operator acting on the inner code.
const innerCode = generator.valueToCode(block, 'INNER', Order.UNARY_NEGATION);
const code = `-${innerCode} + 2`;
रिटर्न प्राथमिकता
जब आप अपने ब्लॉक-कोड जनरेटर से प्राथमिकता देते हैं, तो ब्लॉक के कोड में सबसे कमजोर ऑपरेटर की वरीयता दिखाएं. यह एक ऑपरेटर है जिसे सुरक्षित करने की ज़रूरत है.
उदाहरण के लिए, नीचे दिए गए ब्लॉक में एक नेरी निगेशन ऑपरेटर और अतिरिक्त निगेशन ऑपरेटर, दोनों शामिल हैं. जोड़ा कमज़ोर होता है, इसलिए ब्लॉक-कोड जनरेटर से इसी प्राथमिकता को लौटाना चाहिए.
const code = `-${innerCode} + 2`;
// The + is the weakest operator in the block.
return [code, Order.ADDITION];
Enum को ऑर्डर करें
हर लैंग्वेज जनरेटर मॉड्यूल, एक Order
इनम के बारे में जानकारी देता है. इसमें उस भाषा की सभी प्राथमिकताएं शामिल होती हैं.
ज़्यादा प्राथमिकता के लिए बैकिंग वैल्यू कम होती है. वहीं, कमज़ोर प्राथमिकता के लिए बैकिंग वैल्यू ज़्यादा होती है. मज़बूत प्राथमिकता को, ताकत के हिसाब से "बेहतर रैंकिंग" और कम अहमियत को "खराब रैंकिंग" के तौर पर देखा जा सकता है - जैसे कि वे मुकाबले वाले योद्धाओं में से हैं.
पहले से मौजूद सभी भाषाओं के लिए, Order
की सूची आपको यहां मिल सकती है:
खास प्राथमिकता
जनरेटर की Order
एनम में दी गई ज़्यादातर प्राथमिकता, टेक्स्ट के मुताबिक बनी भाषाओं के हिसाब से तय की गई प्राथमिकताओं से मेल खाती हैं. हालांकि, इससे जुड़ी दो खास प्राथमिकताएं हैं, Order.ATOMIC
और Order.NONE
.
प्राथमिकता के लिए Order.ATOMIC
की सबसे ज़्यादा प्राथमिकता है. इसका इस्तेमाल तब किया जाता है, जब:
- आपको यह पक्का करना हो कि कोड हमेशा ब्रैकेट में रहे,
इसलिए इसे
valueToCode
को भेजें. - आपके ब्लॉक में कोई ऑपरेटर शामिल नहीं है, इसलिए आपको इसे अपने ब्लॉक-कोड जनरेटर से लौटाना होता है.
प्राथमिकता Order.NONE
सबसे कमज़ोर है. इसका इस्तेमाल तब किया जाता है, जब:
- यह पक्का करें कि कोड हमेशा ब्रैकेट में दिखे, ताकि आप उसे ब्लॉक-कोड जनरेटर से लौटा सकें.
- किसी अंदरूनी ब्लॉक पर कोई ऑपरेटर काम नहीं कर रहा है, इसलिए आप उसे
valueToCode
को पास कर देते हैं.