หน้านี้ได้รับการแปลโดย Cloud Translation API

โครงสร้างบล็อกใน JSON

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

นอกจากนี้ คุณยังกำหนดอินพุต ฟิลด์ และการเชื่อมต่อใน JavaScript ได้ด้วย

ภาพรวม

ใน JSON คุณจะอธิบายโครงสร้างของบล็อกด้วยสตริงข้อความอย่างน้อย 1 รายการ (message0, message1, ...) และอาร์เรย์อาร์กิวเมนต์ที่เกี่ยวข้อง (args0, args1, ...) สตริงข้อความประกอบด้วยข้อความซึ่งจะแปลงเป็นป้ายกำกับ และโทเค็นการประมาณค่า (%1, %2, ...) ซึ่งทำเครื่องหมายตำแหน่งของ การเชื่อมต่อและฟิลด์ที่ไม่ใช่ป้ายกำกับ อาร์เรย์อาร์กิวเมนต์จะอธิบายวิธีจัดการโทเค็นการประมาณค่า

เช่น บล็อกนี้

บล็อกตัวตั้งค่าตัวแปร โดยจะมีป้ายกำกับ "set" เมนูแบบเลื่อนลงสำหรับเลือกตัวแปร ป้ายกำกับ "to" และช่องป้อนค่า

กำหนดโดย JSON ต่อไปนี้

JSON

{
  "message0": "set %1 to %2",
  "args0": [
    {
      "type": "field_variable",
      "name": "VAR",
      "variable": "item",
      "variableTypes": [""]
    },
    {
      "type": "input_value",
      "name": "VALUE"
    }
  ]
}

โทเค็นการประมาณค่าแรก (%1) แสดงถึงฟิลด์ตัวแปร (type: "field_variable") ซึ่งอธิบายโดยออบเจ็กต์แรกในอาร์เรย์ args0 โทเค็นที่ 2 (%2) แสดงถึงการเชื่อมต่ออินพุตที่ส่วนท้ายของอินพุตค่า (type: "input_value") อธิบายโดยออบเจ็กต์ที่ 2 ในอาร์เรย์ args0

ข้อความและอินพุต

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

ตัวอย่างที่ 1

JSON

{
  "message0": "set %1 to %2",
  "args0": [
    {"type": "field_variable", ...} // token %1
    {"type": "input_value", ...}    // token %2
  ],
}

ซึ่งจะสร้างอินพุตค่าเดียวที่มี 3 ฟิลด์ ได้แก่ ป้ายกำกับ ("set") ฟิลด์ตัวแปร และป้ายกำกับอีกรายการ ("to")

แมปข้อความ "ตั้งค่า %1 เป็น %2" กับอินพุตค่าที่มี 3 ฟิลด์

ตัวอย่างที่ 2

JSON

{
  "message0": "%1 + %2",
  "args0": [
    {"type": "input_value", ...} // token %1
    {"type": "input_value", ...} // token %2
  ],
}

ซึ่งจะสร้างอินพุตค่า 2 รายการ รายการแรกไม่มีฟิลด์ ส่วนรายการที่ 2 มีฟิลด์ 1 รายการ ("+")

แมปข้อความ "%1 + %2" กับอินพุตค่า 2 รายการ

ตัวอย่างที่ 3

JSON

{
  "message0": "%1 + %2 %3",
  "args0": [
    {"type": "input_value", ...}   // token %1
    {"type": "input_end_row", ...} // token %2
    {"type": "input_value", ...}   // token %3
  ],
}

ซึ่งจะสร้างสิ่งต่อไปนี้

ค่าที่ป้อนโดยไม่มีฟิลด์
อินพุตท้ายแถว ที่มีช่องป้ายกำกับ ("+") ซึ่งทำให้ระบบแสดงค่าอินพุตต่อไปนี้ ในแถวใหม่ และ
ป้อนค่าโดยไม่มีฟิลด์

แมปข้อความ "%1 + %2 %3" กับอินพุตค่า 2 รายการและอินพุตท้ายแถว

อินพุตจำลองที่ท้ายข้อความ

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

JSON

{
  "message0": "%1 is empty %2",
  "args0": [
    {"type": "input_value", ...} // token %1
    {"type": "input_dummy", ...} // token %2
  ],
}

แมปข้อความ "%1 ว่างเปล่า" กับอินพุตค่าและอินพุตจำลองที่สร้างขึ้นโดยอัตโนมัติ

คุณสามารถให้ Blockly เพิ่มอินพุตจำลองและกำหนดอินพุตดังกล่าวได้ดังนี้

JSON

{
  "message0": "%1 is empty",
  "args0": [
    {"type": "input_value", ...} // token %1
  ],
}

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

implicitAlign

ในบางกรณีที่พบได้น้อย อินพุตดัมมี่ต่อท้ายที่สร้างขึ้นโดยอัตโนมัติจะต้องสอดคล้องกับ "RIGHT" หรือ "CENTRE" ค่าเริ่มต้นหากไม่ได้ระบุคือ "LEFT"

ในตัวอย่างด้านล่าง message0 คือ "send email to %1 subject %2 secure %3" และ Blockly จะเพิ่มอินพุตจำลองสำหรับแถวที่ 3 โดยอัตโนมัติ การตั้งค่า implicitAlign0 เป็น "RIGHT" จะบังคับให้แถวนี้จัดชิดขวา

การบล็อกการส่งอีเมล แถวแรกมีป้ายกำกับ "ส่งอีเมลถึง" และ
ช่องป้อนค่า แถวที่ 2 มีป้ายกำกับ "subject" และช่องป้อนค่า
บรรทัดที่ 3 มีป้ายกำกับ "ปลอดภัย" และช่องทำเครื่องหมาย โดยจะ
จัดแนวไปทางขวา

implicitAlign ใช้กับอินพุตทั้งหมดที่ไม่ได้กำหนดไว้อย่างชัดเจนในคำจำกัดความของบล็อก JSON รวมถึงอินพุตท้ายแถวที่แทนที่อักขระขึ้นบรรทัดใหม่ ('\n') นอกจากนี้ ยังมีพร็อพเพอร์ตี้ที่เลิกใช้งานแล้ว lastDummyAlign0 ซึ่งมีลักษณะการทำงานเหมือนกับ implicitAlign0

เมื่อออกแบบบล็อกสำหรับ RTL (อาหรับและฮีบรู) ระบบจะกลับด้านซ้ายและขวา ดังนั้น "RIGHT" จะจัดแนวฟิลด์ไปทางซ้าย

ข้อความหลายรายการ

บางบล็อกจะแบ่งออกเป็น 2 ส่วนหรือมากกว่านั้นโดยอัตโนมัติ ลองพิจารณาบล็อกทำซ้ำนี้ซึ่งมี 2 แถว

บล็อกการทำซ้ำที่มี 2 แถว แถวแรกมีป้ายกำกับ "repeat" ค่า
input และป้ายกำกับ "times" แถวที่ 2 มีป้ายกำกับ "do" และคำสั่ง
input

หากอธิบายบล็อกนี้ด้วยข้อความเดียว พร็อพเพอร์ตี้ message0 จะเป็น "repeat %1 times %2 do %3" โดย %2 แสดงถึงการป้อนข้อมูล ท้ายแถว สตริงนี้ทำให้นักแปลรู้สึกอึดอัดเนื่องจาก อธิบายได้ยากว่าการแทนที่ %2 หมายความว่าอย่างไร นอกจากนี้ %2 สิ้นแถว อินพุตอาจไม่เป็นที่ต้องการในบางภาษา และอาจมีหลายบล็อกที่ต้องการแชร์ข้อความของแถวที่ 2 แนวทางที่ดีกว่า คือการใช้พร็อพเพอร์ตี้ message และ args มากกว่า 1 รายการ

JSON

{
  "message0": "repeat %1 times",
  "args0": [
    {"type": "input_value", ...} // token %1 in message0
  ],
  "message1": "do %1",
  "args1": [
    {"type": "input_statement", ...} // token %1 in message1
  ],
}

แมปข้อความ "ทำซ้ำ %1 ครั้ง" กับอินพุตค่าและอินพุตจำลองที่สร้างขึ้นโดยอัตโนมัติ
และข้อความ "ทำ %1" กับอินพุตคำสั่ง

คุณกำหนดพร็อพเพอร์ตี้ message, args และ implicitAlign ได้ตามต้องการ ในรูปแบบ JSON โดยเริ่มจาก 0 และเพิ่มขึ้นตามลำดับ โปรดทราบว่า Block Factory ไม่สามารถแยกข้อความออกเป็นหลายส่วนได้ แต่คุณสามารถแยกข้อความด้วยตนเองได้ง่ายๆ

ลำดับโทเค็นการประมาณค่า

เมื่อแปลบล็อก คุณอาจต้องเปลี่ยนลำดับของโทเค็นการประมาณค่า ในข้อความ ซึ่งเป็นสิ่งสำคัญอย่างยิ่งในภาษาที่มี ลำดับคำแตกต่างจากภาษาอังกฤษ เช่น เราเริ่มต้นด้วยบล็อกที่กำหนดโดยข้อความ"set %1 to %2":

บล็อกตัวตั้งค่าตัวแปรที่มีป้ายกำกับ "set" ฟิลด์แบบเลื่อนลงสำหรับ
ตัวแปร ป้ายกำกับ "to" และอินพุตค่าภายนอก

ตอนนี้ลองพิจารณาภาษาที่สมมติขึ้นซึ่งต้องกลับด้าน "set %1 to %2" เพื่อพูดว่า "put %2 in %1" การเปลี่ยนข้อความ (รวมถึงลำดับของโทเค็นการประมาณค่า) และปล่อยให้อาร์เรย์อาร์กิวเมนต์ไม่เปลี่ยนแปลงจะส่งผลให้เกิดบล็อกต่อไปนี้

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

Blockly เปลี่ยนลำดับของฟิลด์โดยอัตโนมัติ สร้างอินพุต จำลอง และเปลี่ยนจากอินพุตภายนอกเป็นอินพุต ภายใน

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

การจัดการข้อความ

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

นอกจากนี้ Blockly ยังแทนที่อักขระขึ้นบรรทัดใหม่ (\n) ในสตริงข้อความด้วยอินพุตท้ายแถวโดยอัตโนมัติ

JSON

{
  "message0": "set %1\nto %2",
  "args0": [
    {"type": "field_variable", ...}, // token %1
    {"type": "input_value", ...},    // token %2
  ]
}

$แมปอักขระขึ้นบรรทัดใหม่ใน "set %1\nto %2" กับอินพุตท้ายแถว$

อาร์เรย์อาร์กิวเมนต์

สตริงข้อความแต่ละรายการจะจับคู่กับอาร์เรย์ args ที่มีหมายเลขเดียวกัน เช่น message0 ใช้กับ args0 โทเค็นการประมาณค่า (%1, %2, ...) อ้างอิงถึงรายการของอาร์เรย์ args และต้องตรงกับอาร์เรย์ args0 อย่างสมบูรณ์ โดยต้องไม่มีรายการที่ซ้ำกันและไม่มีการละเว้นรายการ หมายเลขโทเค็นหมายถึง ลำดับของรายการในอาร์เรย์อาร์กิวเมนต์ ไม่จำเป็นต้อง อยู่ในลำดับในสตริงข้อความ

ออบเจ็กต์ทุกรายการในอาร์เรย์อาร์กิวเมนต์มีสตริง type ส่วนพารามิเตอร์อื่นๆ จะแตกต่างกันไปตามประเภท ดังนี้

ฟิลด์:
อินพุต
- input_value
- input_statement
- input_dummy
- input_end_row

นอกจากนี้ คุณยังกำหนดฟิลด์ที่กำหนดเองและ อินพุตที่กำหนดเอง แล้วส่งเป็นอาร์กิวเมนต์ได้ด้วย

ฟิลด์ alt

ออบเจ็กต์ทุกรายการอาจมีช่อง alt ด้วย ในกรณีที่ Blockly ไม่รู้จัก type ของออบเจ็กต์ ระบบจะใช้ออบเจ็กต์ alt แทน เช่น หากมีการเพิ่มฟิลด์ใหม่ชื่อ field_time ลงใน Blockly บล็อกที่ใช้ฟิลด์นี้จะใช้ alt เพื่อกำหนด field_input สำรองสำหรับ Blockly เวอร์ชันเก่าได้

JSON

{
  "message0": "sound alarm at %1",
  "args0": [
    {
      "type": "field_time",
      "name": "TEMPO",
      "hour": 9,
      "minutes": 0,
      "alt":
        {
          "type": "field_input",
          "name": "TEMPOTEXT",
          "text": "9:00"
        }
    }
  ]
}

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