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

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

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

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

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

ליצור פלט "נכון"

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

כדי להבטיח שהשיחות יהיו נכונות, תמיד צריך להעביר קריאות מסוג 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 כדי ליצור את הקוד של בלוק פנימי, נותנים לו עדיפות של האופרטור החזקה ביותר שפועל על הקוד של הבלוק הפנימי. זהו האופרטור שעליו צריך להגן על הקוד של הבלוק הפנימי.

לדוגמה, בבלוקים הבאים, גם האופרטור Unary וגם האופרטור של התוספת פועלים על הקוד של הבלוק הפנימי. השלילה האונרית חזקה יותר, לכן יש לתת עדיפות גבוהה יותר ל-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, שכולל את כל הקדימות של השפה הזו.

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

כאן ניתן למצוא את מספרי הטיפוסים (enums) Order לכל השפות המובנות:

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

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

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

  • כדאי לוודא שהקוד תמיד בסוגריים, אז מעבירים אותו ל-valueToCode.
  • הבלוק שלכם לא כולל אופרטורים, ולכן אתם מחזירים אותו ממחולל קודי הבלוקים.

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

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