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

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

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

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

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

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

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

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

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

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

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

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

มีกรณีพิเศษอีก 1 กรณี ถ้าอาร์เรย์ใดอาร์เรย์หนึ่งเป็น 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']);
  }
}

สำหรับอินพุต คุณสามารถผ่านการตรวจสอบไปยังเมธอด 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' หากคุณต้องการให้การบล็อก ทำงานร่วมกับบล็อกที่ติดตั้งมาในตัว คุณสามารถใช้ค่าเหล่านี้เพื่อสร้าง ที่เข้ากันได้

ตัวอย่างค่า

เมื่อกำหนดการตรวจสอบการเชื่อมต่อสำหรับอินพุตและเอาต์พุต โดยปกติแล้วคุณสามารถ ควรคิดว่าการตรวจสอบคือการแสดงประเภท

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

ยอมรับประเภทเดียว

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

ยอมรับหลายประเภท

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

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

ยอมรับทุกประเภท

วิธีสร้างการบล็อกที่ "ยอมรับ" ประเภทใดก็ได้ คุณต้องตั้งค่า ตรวจสอบการเชื่อมต่อกับ null

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

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

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

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

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

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

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

ตัวอย่างสแต็กหรือคำสั่ง

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

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

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

เก็บบล็อกต่างๆ ตามลำดับ

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

อนุญาตให้มีบล็อกตรงกลางจำนวนมาก

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

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

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

สแต็กหรือสแต็ก

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

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

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;
  },
}

ประเภททั่วไป

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

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

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

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

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

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

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

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