הוספת סוגריים

חסימות מרמזות על סוגריים. לדוגמה, כשרואים את הבלוקים הבאים, נניח שהמשמעות היא -(5 + 2) לא -5 + 2 כי 5 ו-2 הם חלק מ- בלוק אחד, וה-- הוא חלק מבלוק אחר.

בלוקים שמייצגים -(5 + 2)

אבל אם מוסיפים סוגריים מסביב לכל בלוק, הקוד הרבה יותר קטן קריא. השוואה בין (((5) * (2)) + (3)) לבין 5 * 2 + 3. גם וגם מעריכים את אותם הדברים (13), אבל ההבדל השני קל יותר לקריאה.

כללי הקדימות של האופרטורים של Blockly עוזרים ליצור קוד בכמות המינימלית מספר סוגריים, כדי להקל על הקריאה.

יצירת תשובה נכונה פלט

אם אתם לא צריכים שהקוד שנוצר יהיה קריא לאנשים, אין צורך לחשוש מהקטנת הסוגריים. לעטוף כל בלוק הוא גישה מצוינת, והוא מבטיח שהקוד שנוצר תמיד ייבדק בצורה נכונה.

כדי להבטיח את הדיוק, תמיד צריך להעביר את השיחות Order.ATOMIC אל valueToCode, וגם תמיד צריך להחזיר Order.NONE ממחולל הבלוקים שלכם.

יצירת סוגריים אופטימליים

צריך להוסיף סוגריים רק אם הקוד שנוצר שגוי בלי אותם. מצב זה מתרחש כשהקדימות של אופרטור בבלוק החיצוני היא גבוהה יותר מהקדימות של אופרטור בבלוק הפנימי.

לדוגמה, בבלוקים הבאים יש אופרטור שלילה אונרית אופרטור ההוספה. לשלילה אונארית יש קדימות חזקה יותר אופרטור הוספת.

שלילה וחיבור

לכן, אם לא מוסיפים סוגריים, מקבלים -5 + 2, והמערכת מעריכה את - לפני +, שלא תואם לבלוקים.

אפשר להורות למחולל מתי להוסיף סוגריים עגולים ולומר לו עד כמה האופרטורים השונים שלכם. אם רואים שהאופרטור החיצוני חזק אבל מוסיפה סוגריים כדי להגן על האופרטור הפנימי.

valueToCode מקבל עדיפות על פני האופרטור החיצוני וההחזרה tuple מציין את הקדימות של האופרטור הפנימי.

הנה דוגמה לבלוק שכולל שני אופרטורים:

בלוק עם אופרטור שלילה אונרית, אופרטור חיבור וצאצא חסימה. 

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

כל מודול של מחולל השפה מגדיר enum של Order שכולל את כל את הקדימות לשפה הזו.

קדימות גבוהה יותר כוללת ערכי גיבוי נמוכים יותר, וקדימות חלשות יותר ערכי גיבוי גבוהים יותר. אפשר לחשוב על קדימות חזקה בתור "דירוג גבוהה יותר" חוזק וקדימות חלשות יותר כ"דירוג נמוך יותר" - כאילו הם היו לוחמים תחרותיים.

כאן אפשר למצוא את טיפוסי ה-enum של Order לכל השפות המובנות:

קדימות מיוחדת

רוב הקדימות של המחוללים Order enums תואמים לקדימות מוגדרים לפי שפות הטקסט המתאימות. אבל יש שני תרחישים מיוחדים קדימות, Order.ATOMIC ו-Order.NONE.

Order.ATOMIC הוא העדיפות החזקה ביותר. משתמשים בה כאשר:

Order.NONE הוא העדיפות החלשה ביותר. משתמשים בה כאשר: