בדיקות חיבור

בדיקות החיבור מגבילות את החיבורים (ולכן את החסימות) שיכולים להתחבר זה לזה.

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

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

איך הם פועלים

ניתן לשייך כל חיבור ל'בדיקת חיבור', שהיא מערך מחרוזות של ערכים ריקים (null).

שני חיבורים יכולים להתחבר אם:

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

לדוגמה, יכול להיות ששתי הבדיקות הבאות יחוברו, כי הן חולקות את המחרוזת 'apple':

['apple', 'ball', 'cat']
['apple', 'bear', 'caterpillar']

אבל לא ניתן לחבר בין שתי הבדיקות האלה, כי הן לא חולקות מחרוזות:

['apple', 'ball', 'cat']
['ape', 'bear', 'caterpillar']

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

null
['ape', 'bear', 'caterpillar]

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

הגדרת בדיקות

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

האופן שבו מקצים בדיקות חיבור לחיבורים משתנה בהתאם להגדרות החסימה של JSON או להגדרות החסימה של JavaScript.

JSON

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

{
  'type': 'custom_block',

  'output': null,
  'nextStatement': 'a connection check entry',
  'previousStatement': ['four', 'connection', 'check', 'entries']
}

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

{
  'type': 'custom_block',
  'message0': '%1 %2',

  'args0': [
    {
      'type': 'input_value',
      'check': 'a connection check entry'
    },
    {
      'type': 'input_statement',
      'check': ['four', 'connection', 'check', 'entries']
    }
  ]
}

JavaScript

בחיבורים ברמה העליונה, אפשר להעביר את הבדיקה ישירות לשיטה שמגדירה את החיבור. אם לא מעבירים ערך, הבדיקה נחשבת כnull. הערך שמעבירים יכול להיות מחרוזת (שהופכת לערך היחיד בבדיקת החיבור) או מערך של מחרוזות.

Blockly.Blocks['custom_block'] = {
  init: function() {
    this.setOutput(true); // null check
    this.setNextStatement(true, 'a connection check entry');
    this.setPreviousStatement(true, ['four', 'connection', 'check', 'entries']);
  }
}

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

Blockly.Blocks['custom_block'] = {
  init: function() {
    this.appendValueInput('NAME')
        .setCheck('a connection check entry');
    this.appendStatementInput('NAME')
        .setCheck(['four', 'connection', 'check', 'entries']);
  }
}

מחרוזות ביקורת מובנות

לבלוקים המובְנים יש בדיקות חיבור עם הערכים 'Array', 'Boolean', 'Colour', 'Number' ו-'String'. אם רוצים שהבלוקים יפעלו בצורה הדדית עם הבלוקים המובְנים, תוכלו להשתמש בערכים האלה כדי שיהיו תואמים.

דוגמאות לערכים

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

בדיקות הקלט צריכות לכלול כל 'סוג' שהוא מקבל, ובדיקות הפלט צריכות לכלול בדיוק את מה שהן "מחזירות".

אישור סוג יחיד

במקרה הבסיסי ביותר שבו רוצים ליצור בלוק ש"מאשר" או "מחזיר" סוג אחד, צריך לכלול את הסוג הזה בבדיקת החיבור של החיבור.

אישור סוגים מרובים

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

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

אישור כל סוג

כדי ליצור בלוק ש"מקבל" סוג כלשהו, צריך להגדיר את בדיקת החיבור של הקלט כ-null.

החזרת סוגי משנה

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

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

החזרת סוגים עם פרמטרים

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

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

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

דוגמאות למקבצים או להצהרות

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

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

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

שומרים על סדר הבלוקים

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

לאפשר הרבה בלוקים אמצעיים

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

אין לאפשר בלוקים אמצעיים

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

או מקבצים

כדי ליצור בלוק שאחריו אפשר לעקוב רק על ידי בלוקים מקבוצה אחת או בלוקים מקבוצה אחרת (ולא משתיהן), צריך לבצע שתי פעולות:

1. בבדיקת החיבור הבאה בבלוק הראשון, אתם צריכים לכלול לפחות רשומה אחת משתי הקבוצות מבדיקות החיבור הקודמות.

2. צריך להגדיר את בדיקות החיבור הבאות של הקבוצות כך שיכללו רק ערכים שנמצאים בבדיקות החיבור הקודמות שלהן (כך שרק בלוקים של אותה קבוצה יוכלו לעקוב אחריהם).

מגבלות

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

הגבלת ההקשר הרחב יותר

המערכת כשלעצמה לא תומכת בהגבלה של "ההקשר הרחב יותר" שבו מותר להתחבר. לדוגמה, לא ניתן לקבוע שבלוק break יכול להתקיים רק בתוך בלוק loop. מערכת בדיקת החיבור מביאה בחשבון רק את שני החיבורים המיידיים שמחוברים.

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

Blockly.Blocks['custom_block'] = {
  init: function() { }

  onchange: function(e) {
    if (this.workspace.isDragging()) return;
    if (e.type !== Blockly.Events.BlockMove) return;
    if (!this.getSurroundLoop()) this.outputConnection.disconnect();
  }

  loopTypes: new Set(); // Your valid *block types* (not connection checks).

  getSurroundLoop: function () {
    let block = this.getSurroundParent();
    do {
      if (loopTypes.has(block.type)) return block;
      block = block.getSurroundParent();
    } while (block);
    return null;
  },
}

סוגים גנריים

המערכת הזו לא תומכת בהגדרה של סוגים גנריים. לדוגמה, לא ניתן ליצור בלוק של "Identity" (זהות), ש "מחזיר" את הקלט שלו ללא קשר.

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

Blockly.Blocks['custom_block'] = {
  init: function() { }

  onchange: function(e) {
    if (e.type !== Blockly.Events.BlockMove) return;
    this.setOutput(
        true, this.getInputTargetBlock()?.outputConnection.getCheck());
  }
}

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

בודקי חיבור

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

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