การตรวจสอบการเชื่อมต่อ

การตรวจสอบการเชื่อมต่อจะจำกัดการเชื่อมต่อ (และการบล็อก) ที่เชื่อมต่อซึ่งกันและกันได้

การตรวจสอบการเชื่อมต่อมีประโยชน์สําหรับประเภทการประมาณ ตัวอย่างเช่น บล็อก 3 บล็อกต่อไปนี้ไม่มีธุรกิจที่เชื่อมต่อ เนื่องจากบล็อกดังกล่าวแสดงถึงโค้ดที่แสดงผลคนละประเภท

คุณใช้การตรวจสอบการเชื่อมต่อเพื่อป้องกันไม่ให้การบล็อกเหล่านี้เชื่อมต่อได้ วิธีนี้ช่วยให้ผู้ใช้ได้รับความคิดเห็นในทันทีและป้องกันไม่ให้เกิดข้อผิดพลาดง่ายๆ อีก

วิธีการทำงาน

การเชื่อมต่อทุกรายการจะเชื่อมโยงกับ "การตรวจสอบการเชื่อมต่อ" ได้ ซึ่งเป็นอาร์เรย์ของสตริงที่มีค่าว่างได้

การเชื่อมต่อ 2 อย่างจะเชื่อมต่อกันได้ในกรณีต่อไปนี้

1. โดยเป็นประเภทที่เข้ากันได้ (เช่น เอาต์พุตที่เชื่อมต่อกับอินพุต)
2. เนื่องจากมีสตริงอย่างน้อย 1 สตริงในการตรวจสอบการเชื่อมต่อที่เหมือนกัน

ตัวอย่างเช่น การตรวจสอบ 2 รายการต่อไปนี้อาจเชื่อมต่อกันได้ เนื่องจากมีการแชร์สตริง 'apple'

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

แต่การตรวจสอบทั้ง 2 รายการกลับเชื่อมต่อไม่ได้เนื่องจากไม่มีสตริงร่วมกัน

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

มีกรณีพิเศษอีกอย่างหนึ่ง หากอาร์เรย์ใดเป็น null เส้นเชื่อมต่อทั้ง 2 เส้นก็จะเชื่อมต่อได้ด้วย สิ่งนี้ช่วยให้คุณกำหนดการเชื่อมต่อ ที่เชื่อมต่อกับทุกอย่างได้

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

สำคัญ: ประเภทการบล็อกและการตรวจสอบการเชื่อมต่อนั้นแตกต่างกัน สตริงทั้ง 2 ชุด แยกกันอย่างสิ้นเชิง การใส่ประเภทการบล็อกในการตรวจสอบการเชื่อมต่อไม่ทำให้บล็อกประเภทนั้นเชื่อมต่อได้

ตั้งค่าการตรวจสอบ

โดยค่าเริ่มต้น การเชื่อมต่อทั้งหมดจะมีการตรวจสอบการเชื่อมต่อแบบ 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']);
  }
}

สำหรับอินพุต คุณสามารถผ่านการตรวจสอบไปยังเมธอด 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

แสดงผลประเภทย่อย

หากต้องการสร้างการบล็อกที่ "แสดงผล" ประเภทย่อย คุณต้องรวมทั้งประเภทและ Supertype ในการตรวจสอบการเชื่อมต่อของเอาต์พุต

ในกรณีของประเภทย่อย การตรวจสอบเอาต์พุตแต่ละครั้งอาจเป็นการตรวจสอบหลายครั้งได้ เนื่องจากการบล็อกจะ "แสดงผล" ทั้ง 2 ประเภทเสมอ

แสดงประเภทพารามิเตอร์

หากต้องการสร้างบล็อกที่ "แสดงผล" ประเภทพารามิเตอร์ คุณต้องรวมทั้งเวอร์ชันที่มีพารามิเตอร์และเวอร์ชันที่ไม่มีพารามิเตอร์ในการตรวจสอบการเชื่อมต่อของเอาต์พุต

คุณอาจต้องการใส่ความแปรปรวนของประเภทด้วย ทั้งนี้ขึ้นอยู่กับระดับความเข้มงวดที่คุณต้องการภาษาที่ใช้บล็อก

คุณตรวจสอบเอาต์พุตได้ทั้ง 2 ประเภทเช่นเดียวกับประเภทย่อยนี้ เนื่องจากการบล็อกจะ "แสดงผล" ทั้ง 2 ประเภทเสมอ

ตัวอย่างกลุ่มหรือคำสั่ง

มีวิธีทั่วไป 2-3 วิธีที่นักพัฒนาแอปจะกำหนดการตรวจสอบสำหรับการเชื่อมต่อก่อนหน้าและการเชื่อมต่อถัดไป โดยปกติแล้ว คุณคิดว่าสิ่งนี้เป็นการจำกัดการจัดลำดับบล็อก

การเชื่อมต่อถัดไปควรมีการบล็อกที่เหมาะกับการบล็อกปัจจุบัน และการเชื่อมต่อก่อนหน้ารวมถึงการบล็อกปัจจุบัน "เป็น"

สําคัญ: ประเภทการบล็อกและการตรวจสอบการเชื่อมต่อนั้นแตกต่างกัน หากระบุว่า "การบล็อกใดควรตามหลังการบล็อกปัจจุบัน" หมายความว่าการตรวจสอบการเชื่อมต่อควรมีสตริงการตรวจสอบที่เกี่ยวข้อง ไม่ใช่ประเภทการบล็อก

จัดเรียงบล็อกต่างๆ ให้เป็นระเบียบ

หากต้องการสร้างชุดบล็อกที่เชื่อมต่อตามลำดับที่กำหนด คุณจะต้องใส่การบล็อกว่าควรเป็นไปตามบล็อกปัจจุบันในการตรวจสอบการเชื่อมต่อครั้งถัดไป และระบุการบล็อกปัจจุบัน "เท่ากับ" ในการตรวจสอบการเชื่อมต่อก่อนหน้านี้

อนุญาตให้มีบล็อกกลางได้เป็นจำนวนมาก

ในการสร้างชุดบล็อกตามลำดับที่อนุญาตบล็อกกลางจำนวนมาก คุณต้องรวมอย่างน้อย 1 รายการจากการตรวจสอบการเชื่อมต่อก่อนหน้าของบล็อกตรงกลางในการตรวจสอบการเชื่อมต่อครั้งถัดไปของบล็อกตรงกลาง วิธีนี้จะช่วยให้เกิดการบล็อก ด้วยตัวมันเองมากขึ้น

ไม่อนุญาตให้ใช้บล็อกกลาง

ในการสร้างชุดบล็อกตามลำดับที่บล็อกตรงกลางไม่บังคับ คุณจะต้องรวมอย่างน้อย 1 รายการจากการตรวจสอบการเชื่อมต่อก่อนหน้าของบล็อกตรงกลางและการตรวจสอบการเชื่อมต่อก่อนหน้าของบล็อกสุดท้ายในการตรวจสอบการเชื่อมต่อครั้งถัดไปของบล็อกแรก ซึ่งจะทำให้บล็อกแรกตามด้วยบล็อกกลางหรือบล็อกสุดท้ายได้

กลุ่มหรือชุด

หากต้องการสร้างการบล็อกที่สามารถตามด้วยการบล็อกจากกลุ่มหนึ่ง หรือบล็อกจากกลุ่มอื่น (ไม่ใช่ทั้ง 2 กลุ่ม) คุณต้องดำเนินการ 2 อย่างดังนี้

1. คุณต้องระบุรายการจากการตรวจสอบการเชื่อมต่อก่อนหน้าทั้ง 2 กลุ่มอย่างน้อย 1 รายการในการตรวจสอบการเชื่อมต่อครั้งถัดไปของบล็อกแรก

2. คุณต้องกำหนดการตรวจสอบการเชื่อมต่อถัดไปของกลุ่มให้รวมเฉพาะค่าที่อยู่ในการตรวจสอบการเชื่อมต่อก่อนหน้าเท่านั้น (เพื่อให้ติดตามได้ด้วยบล็อกของกลุ่มเดียวกันเท่านั้น)

ข้อจำกัด

ระบบนี้ค่อนข้างมีประสิทธิภาพและแก้ไขกรณีการใช้งานได้หลายกรณี แต่ก็มีข้อจำกัดบางประการ

จำกัดบริบทเพิ่มเติม

ระบบนี้ยังไม่รองรับการจำกัด "บริบทที่กว้างมากขึ้น" ซึ่งอนุญาตให้การเชื่อมต่อเชื่อมต่อ ตัวอย่างเช่น คุณไม่สามารถบอกว่าบล็อก break ได้รับอนุญาตให้อยู่ภายในบล็อก loop เท่านั้น ระบบตรวจสอบการเชื่อมต่อจะพิจารณาเฉพาะการเชื่อมต่อ 2 เครื่องที่เชื่อมต่อกันทันที

คุณสามารถรองรับเหตุการณ์ดังกล่าวได้โดยใช้ระบบเหตุการณ์เพื่อฟังเหตุการณ์บล็อกการย้าย และตรวจสอบว่าการบล็อกอยู่ในตำแหน่งที่ไม่ถูกต้องหรือไม่

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());
  }
}

แต่ถ้าบล็อกที่เชื่อมต่อทั่วไปด้วย จะทำให้ไม่สามารถใช้งานได้ได้อย่างถูกต้อง ไม่มีวิธีแก้ปัญหาที่ดีสำหรับกรณีนี้

เครื่องมือตรวจสอบการเชื่อมต่อ

หากระบบนี้ใช้ไม่ได้กับกรณีการใช้งานของคุณ คุณยังเปลี่ยนวิธีเปรียบเทียบการตรวจสอบการเชื่อมต่อได้โดยสร้างเครื่องมือตรวจสอบการเชื่อมต่อที่กำหนดเอง

เช่น หากต้องการสร้างระบบขั้นสูงขึ้นเพื่อจัดการข้อจำกัดบางอย่างของระบบนี้ คุณสร้างเครื่องมือตรวจสอบการเชื่อมต่อที่กำหนดเองได้