YAML - คู่มือฉบับย่อ

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

รูปแบบ

พิจารณาข้อความที่แสดงด้านล่าง -

Quick brown fox jumped over the lazy dog.

ข้อความ YAML สำหรับสิ่งนี้จะแสดงดังที่แสดงด้านล่าง -

yaml.load(Quick brown fox jumped over the lazy dog.)
>>'Quick brown fox jumped over the lazy dog.'

โปรดทราบว่า YAML รับค่าในรูปแบบสตริงและแสดงผลลัพธ์ตามที่กล่าวไว้ข้างต้น

ตัวอย่าง

ให้เราเข้าใจรูปแบบใน YAML โดยใช้ตัวอย่างต่อไปนี้ -

พิจารณาหมายเลขจุดต่อไปนี้ของ“ pi” ซึ่งมีค่า 3.1415926 ใน YAML แสดงเป็นตัวเลขลอยตามที่แสดงด้านล่าง -

>>> yaml.load('3.1415926536')
3.1415926536

สมมติว่าต้องโหลดหลายค่าในโครงสร้างข้อมูลเฉพาะดังที่กล่าวไว้ด้านล่าง -

eggs
ham
spam
French basil salmon terrine

เมื่อคุณโหลดสิ่งนี้ลงใน YAML ค่าจะถูกนำมาใช้ในโครงสร้างข้อมูลอาร์เรย์ซึ่งเป็นรูปแบบของรายการ ผลลัพธ์ดังแสดงด้านล่าง -

>>> yaml.load('''
   - eggs
   - ham
   - spam
   - French basil salmon terrine
   ''')
['eggs', 'ham', 'spam', 'French basil salmon terrine']

คุณสมบัติ

YAML มีภาษามาร์กอัปที่มีโครงสร้างที่สำคัญเพื่อแยกความแตกต่างของภาษาที่มุ่งเน้นข้อมูลด้วยมาร์กอัปเอกสาร เป้าหมายการออกแบบและคุณสมบัติของ YAML มีดังต่อไปนี้ -

• จับคู่โครงสร้างข้อมูลดั้งเดิมของวิธีการแบบ Agile และภาษาของมันเช่น Perl, Python, PHP, Ruby และ JavaScript

• ข้อมูล YAML เป็นแบบพกพาระหว่างภาษาโปรแกรม

• รวมรูปแบบข้อมูลที่สอดคล้องกันของข้อมูล

• มนุษย์สามารถอ่านได้ง่าย

• รองรับการประมวลผลทิศทางเดียว

• ติดตั้งและใช้งานง่าย

เมื่อคุณมีความคิดเกี่ยวกับ YAML และคุณลักษณะต่างๆแล้วให้เราเรียนรู้พื้นฐานเกี่ยวกับไวยากรณ์และการดำเนินการอื่น ๆ โปรดจำไว้ว่า YAML มีรูปแบบโครงสร้างที่มนุษย์อ่านได้

กฎสำหรับการสร้างไฟล์ YAML

เมื่อคุณสร้างไฟล์ใน YAML คุณควรจำกฎพื้นฐานต่อไปนี้ -

• YAML พิจารณาตัวพิมพ์เล็กและตัวพิมพ์ใหญ่

• ไฟล์ควรมี .yaml เป็นส่วนขยาย

• YAML ไม่อนุญาตให้ใช้แท็บในขณะที่สร้างไฟล์ YAML อนุญาตให้เว้นวรรคแทน

ส่วนประกอบพื้นฐานของไฟล์ YAML

ส่วนประกอบพื้นฐานของ YAML อธิบายไว้ด้านล่าง -

รูปแบบบล็อกธรรมดา

รูปแบบบล็อกนี้ใช้ hyphen+spaceเพื่อเริ่มรายการใหม่ในรายการที่ระบุ สังเกตตัวอย่างที่แสดงด้านล่าง -

--- # Favorite movies
 - Casablanca
 - North by Northwest
 - The Man Who Wasn't There

Inline Format

รูปแบบอินไลน์ถูกคั่นด้วย comma and spaceและรายการจะอยู่ใน JSON สังเกตตัวอย่างที่แสดงด้านล่าง -

--- # Shopping list
   [milk, groceries, eggs, juice, fruits]

Folded Text

ข้อความที่พับจะแปลงบรรทัดใหม่เป็นช่องว่างและลบช่องว่างที่นำหน้าออก สังเกตตัวอย่างที่แสดงด้านล่าง -

- {name: John Smith, age: 33}
- name: Mary Smith
  age: 27

โครงสร้างที่เป็นไปตามอนุสัญญาพื้นฐานทั้งหมดของ YAML แสดงไว้ด้านล่าง -

men: [John Smith, Bill Jones]
women:
  - Mary Smith
  - Susan Williams

เรื่องย่อของ YAML Basic Elements

• บทสรุปขององค์ประกอบพื้นฐานของ YAML มีให้ที่นี่: ความคิดเห็นใน YAML เริ่มต้นด้วย (#) ตัวละคร

• ความคิดเห็นต้องแยกออกจากโทเค็นอื่นด้วยช่องว่าง

• การเยื้องช่องว่างใช้เพื่อแสดงโครงสร้าง

• แท็บไม่รวมอยู่ในการเยื้องสำหรับไฟล์ YAML

• สมาชิกรายชื่อแสดงด้วยยัติภังค์นำหน้า (-).

• สมาชิกรายชื่ออยู่ในวงเล็บเหลี่ยมและคั่นด้วยเครื่องหมายจุลภาค

• อาร์เรย์ที่เชื่อมโยงจะแสดงโดยใช้เครื่องหมายจุดคู่ ( : )ในรูปแบบของคู่ค่าคีย์ พวกเขาอยู่ในวงเล็บปีกกา{}.

• เอกสารหลายชุดที่มีสตรีมเดียวจะถูกคั่นด้วยขีดกลาง 3 ตัว (---)

• โหนดที่ซ้ำกันในแต่ละไฟล์เริ่มต้นด้วยเครื่องหมายแอมเพอร์แซนด์ (&) และเครื่องหมายดอกจัน (*) ทำเครื่องหมายในภายหลัง

• YAML ต้องการโคลอนและเครื่องหมายจุลภาคที่ใช้เป็นตัวคั่นรายการตามด้วยช่องว่างที่มีค่าสเกลาร์เสมอ

• โหนดควรมีเครื่องหมายอัศเจรีย์ (!) หรือเครื่องหมายอัศเจรีย์คู่ (!!) ตามด้วยสตริงที่สามารถขยายเป็น URI หรือ URL

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

เยื้อง YAML

YAML ไม่มีช่องว่างบังคับ นอกจากนี้ไม่จำเป็นต้องสอดคล้องกัน การเยื้อง YAML ที่ถูกต้องแสดงอยู่ด้านล่าง -

a:
   b:
      - c
      -  d
      - e
f:
      "ghi"

• คุณควรจำกฎต่อไปนี้ในขณะที่ทำงานกับการเยื้องใน YAML: บล็อกโฟลว์ต้องมีช่องว่างอย่างน้อยบางส่วนที่มีระดับบล็อกปัจจุบันโดยรอบ

• เนื้อหาโฟลว์ของ YAML ครอบคลุมหลายบรรทัด จุดเริ่มต้นของเนื้อหาโฟลว์เริ่มต้นด้วย{ หรือ [.

• รายการบล็อกจะมีการเยื้องเช่นเดียวกับระดับบล็อกโดยรอบเนื่องจาก - ถือเป็นส่วนหนึ่งของการเยื้อง

ตัวอย่างของ Intended Block

สังเกตโค้ดต่อไปนี้ที่แสดงการเยื้องพร้อมตัวอย่าง -

--- !clarkevans.com/^invoice
invoice: 34843
date   : 2001-01-23
bill-to: &id001
   given  : Chris
   family : Dumars
   address:
      lines: |
            458 Walkman Dr.
            Suite #292
      city    : Royal Oak
      state   : MI
      postal  : 48046
ship-to: *id001
product:
    - sku         : BL394D
      quantity    : 4
      description : Basketball
      price       : 450.00
   - sku         : BL4438H
      quantity    : 1
      description : Super Hoop
      price       : 2392.00
tax  : 251.42
total: 4443.52
comments: >
    Late afternoon is best.
    Backup contact is Nancy
    Billsmer @ 338-4338.

การแยกสตริง

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

ตัวอย่าง

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

-
 - Cat
 - Dog
 - Goldfish
-
 - Python
 - Lion
 - Tiger

อีกตัวอย่างหนึ่งในการอธิบายการแสดงสตริงใน YAML มีการกล่าวถึงด้านล่าง

errors:
      messages:
         already_confirmed: "was already confirmed, please try signing in"
         confirmation_period_expired: "needs to be confirmed within %{period}, please request a new one"
         expired: "has expired, please request a new one"
         not_found: "not found"
         not_locked: "was not locked"
         not_saved:
            one: "1 error prohibited this %{resource} from being saved:"
            other: "%{count} errors prohibited this %{resource} from being saved:"

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

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

YAML supports single line comments. โครงสร้างของมันอธิบายไว้ด้านล่างด้วยความช่วยเหลือของตัวอย่าง -

# this is single line comment.

YAML does not support multi line comments. หากคุณต้องการแสดงความคิดเห็นสำหรับหลายบรรทัดคุณสามารถทำได้ดังที่แสดงในตัวอย่างด้านล่าง -

# this
# is a multiple
# line comment

คุณสมบัติของความคิดเห็น

คุณสมบัติของความคิดเห็นใน YAML แสดงไว้ด้านล่าง -

• บล็อกที่แสดงความคิดเห็นถูกข้ามระหว่างการดำเนินการ

• ความคิดเห็นช่วยเพิ่มคำอธิบายสำหรับบล็อกรหัสที่ระบุ

• ความคิดเห็นต้องไม่ปรากฏในสเกลาร์

• YAML ไม่รวมวิธีใด ๆ ในการหลีกเลี่ยงสัญลักษณ์แฮช (#) ดังนั้นภายในสตริงแบบหลายบรรทัดจึงไม่มีวิธีแบ่งข้อคิดเห็นจากค่าสตริงดิบ

ความคิดเห็นภายในคอลเลกชันแสดงอยู่ด้านล่าง -

key: #comment 1
   - value line 1
   #comment 2
   - value line 2
   #comment 3
   - value line 3

คีย์ลัดสำหรับการแสดงความคิดเห็นบล็อก YAML คือ Ctrl+Q.

หากคุณกำลังใช้ Sublime Text editorขั้นตอนในการแสดงความคิดเห็นเกี่ยวกับบล็อกดังต่อไปนี้ -

เลือกบล็อก ใช้“ CTRL + /” บน Linux และ Windows และ“ CMD + /” สำหรับระบบปฏิบัติการ Mac ดำเนินการบล็อก

โปรดทราบว่าขั้นตอนเดียวกันนี้สามารถใช้ได้หากคุณกำลังใช้ Visual Studio Code Editor. ขอแนะนำให้ใช้เสมอSublime Text Editor สำหรับการสร้างไฟล์ YAML เนื่องจากระบบปฏิบัติการส่วนใหญ่รองรับและรวมถึงปุ่มลัดที่เป็นมิตรกับนักพัฒนาซอฟต์แวร์

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

การแมปเป็นการแสดงค่าคีย์ที่รวมอยู่ในโครงสร้าง JSON มักใช้ในระบบสนับสนุนหลายภาษาและการสร้าง API ในแอปพลิเคชันมือถือ การแมปใช้การแทนค่าคู่คีย์ด้วยการใช้colon and space (:).

ตัวอย่าง

พิจารณาตัวอย่างลำดับของสเกลาร์เช่นรายชื่อผู้เล่นบอลดังที่แสดงด้านล่าง -

- Mark Joseph
- James Stephen
- Ken Griffey

ตัวอย่างต่อไปนี้แสดงการแมปสเกลาร์กับสเกลาร์ -

hr: 87
avg: 0.298
rbi: 149

ตัวอย่างต่อไปนี้แสดงการแม็ปสเกลาร์กับลำดับ -

European:
- Boston Red Sox
- Detroit Tigers
- New York Yankees

national:
- New York Mets
- Chicago Cubs
- Atlanta Braves

คอลเลกชันสามารถใช้สำหรับการแม็พลำดับซึ่งแสดงไว้ด้านล่าง -

-
   name: Mark Joseph
   hr: 87
   avg: 0.278
-
   name: James Stephen
   hr: 63
   avg: 0.288

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

[PHP, Perl, Python]

คอลเลกชันเหล่านี้ถูกเก็บไว้ในเอกสาร การแยกเอกสารใน YAML จะแสดงด้วยขีดกลางสามขีดหรือขีดกลาง (---) ท้ายเอกสารมีจุดสามจุด (…)

การแยกเอกสารใน YAML แสดงด้วยเครื่องหมายขีดกลางสามขีด (---) ส่วนท้ายของเอกสารแสดงด้วยจุดสามจุด (…)

การแสดงเอกสารเรียกว่ารูปแบบโครงสร้างซึ่งระบุไว้ด้านล่าง -

# Ranking of 1998 home runs
---
- Mark Joseph
- James Stephen
- Ken Griffey 

# Team ranking
---
- Chicago Cubs
- St Louis Cardinals

เครื่องหมายคำถามที่มีช่องว่างรวมกันบ่งบอกถึงการทำแผนที่ที่ซับซ้อนในโครงสร้าง ภายในคอลเลกชันบล็อกผู้ใช้สามารถรวมโครงสร้างที่มีขีดกลางโคลอนและเครื่องหมายคำถาม ตัวอย่างต่อไปนี้แสดงการแม็ประหว่างลำดับ -

- 2001-07-23
? [ New York Yankees,Atlanta Braves ]
: [ 2001-07-02, 2001-08-12, 2001-08-14]

สเกลาร์ใน YAML เขียนในรูปแบบบล็อกโดยใช้ประเภทตัวอักษรซึ่งแสดงเป็น (|). หมายถึงการนับเส้นแบ่ง ใน YAML สเกลาร์เขียนแบบพับ (>) โดยแต่ละบรรทัดหมายถึงพื้นที่พับซึ่งลงท้ายด้วย empty line หรือ more indented ไลน์.

บรรทัดใหม่จะถูกเก็บรักษาไว้ในตัวอักษรดังแสดงด้านล่าง -

ASCII Art
--- |
\//||\/||
// || ||__

บรรทัดใหม่ที่พับแล้วจะถูกเก็บรักษาไว้สำหรับ more indented lines และ blank lines ดังแสดงด้านล่าง -

>
Sammy Sosa completed another
fine season with great stats.
63 Home Runs
0.288 Batting Average
What a year!

สเกลาร์โฟลว์ YAML ประกอบด้วยรูปแบบธรรมดาและสไตล์ที่ยกมา รูปแบบที่ยกมาสองครั้งประกอบด้วยลำดับการหลบหนีต่างๆ Flow scalars สามารถรวมหลายบรรทัด การแบ่งบรรทัดจะถูกพับในโครงสร้างนี้เสมอ

plain:
This unquoted scalar
spans many lines.
quoted: "So does this
quoted scalar.\n"

ใน YAML โหนดที่ไม่ได้ติดแท็กจะถูกระบุด้วยประเภทเฉพาะของแอปพลิเคชัน ตัวอย่างของข้อกำหนดแท็กโดยทั่วไปใช้seq, map และ strประเภทสำหรับที่เก็บแท็ก YAML แท็กจะแสดงเป็นตัวอย่างที่กล่าวถึงด้านล่าง -

แท็กจำนวนเต็ม

แท็กเหล่านี้มีค่าจำนวนเต็มอยู่ด้วย เรียกอีกอย่างว่าแท็กตัวเลข

canonical: 12345
decimal: +12,345
sexagecimal: 3:25:45
octal: 014
hexadecimal: 0xC

ตัวเลขจุดลอย

แท็กเหล่านี้ประกอบด้วยค่าทศนิยมและเลขชี้กำลัง พวกเขาเรียกอีกอย่างว่าแท็กเลขชี้กำลัง

canonical: 1.23015e+3
exponential: 12.3015e+02
sexagecimal: 20:30.15
fixed: 1,230.15
negative infinity: -.inf
not a number: .NaN

แท็กเบ็ดเตล็ด

ประกอบด้วยจำนวนเต็มค่าลอยตัวและค่าสตริงที่ฝังอยู่ในค่าเหล่านี้ ดังนั้นจึงเรียกว่าแท็กเบ็ดเตล็ด

null: ~
true: y
false: n
string: '12345'

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

รูปแบบ YAML ด้านบนแสดงถึงแอตทริบิวต์ต่างๆของค่าดีฟอลต์อะแดปเตอร์และโฮสต์ที่มีแอตทริบิวต์อื่น ๆ YAML ยังเก็บบันทึกของทุกไฟล์ที่สร้างขึ้นซึ่งจะรักษาการติดตามข้อความแสดงข้อผิดพลาดที่สร้างขึ้น ในการแปลงไฟล์ YAML ที่ระบุในรูปแบบ JSON เราจะได้ผลลัพธ์ที่ต้องการดังที่กล่าวไว้ด้านล่าง -

defaults: &defaults
   adapter:  postgres
   host:     localhost

development:
   database: myapp_development
   <<: *defaults

test:
   database: myapp_test
   <<: *defaults

มาแปลง YAML เป็นรูปแบบ JSON และตรวจสอบผลลัพธ์

{
   "defaults": {
      "adapter": "postgres",
      "host": "localhost"
   },
   "development": {
      "database": "myapp_development",
      "adapter": "postgres",
      "host": "localhost"
   },
   "test": {
      "database": "myapp_test",
      "adapter": "postgres",
      "host": "localhost"
   }
}

คีย์เริ่มต้นที่มีคำนำหน้า“ <<: *” จะรวมอยู่ในและเมื่อจำเป็นโดยไม่จำเป็นต้องเขียนข้อมูลโค้ดเดิมซ้ำ ๆ

YAML ทำตามขั้นตอนมาตรฐานสำหรับโฟลว์กระบวนการ โครงสร้างข้อมูลดั้งเดิมใน YAML ประกอบด้วยการนำเสนออย่างง่ายเช่นโหนด เรียกอีกอย่างว่าแทนโหนดกราฟ

ซึ่งรวมถึงการแม็ปลำดับและปริมาณสเกลาร์ซึ่งกำลังถูกทำให้เป็นอนุกรมเพื่อสร้างแผนภูมิการทำให้เป็นอนุกรม ด้วยการทำให้เป็นอนุกรมวัตถุจะถูกแปลงด้วยกระแสของไบต์

แผนผังเหตุการณ์การทำให้เป็นอนุกรมช่วยในการสร้างการนำเสนอของสตรีมอักขระดังที่แสดงในแผนภาพต่อไปนี้

โพรซีเดอร์ย้อนกลับแยกวิเคราะห์สตรีมของไบต์ในแผนผังเหตุการณ์ที่ต่อเนื่องกัน ต่อมาโหนดจะถูกแปลงเป็นกราฟโหนด ค่าเหล่านี้จะถูกแปลงในโครงสร้างข้อมูลดั้งเดิมของ YAML ในภายหลัง รูปด้านล่างอธิบายสิ่งนี้ -

ข้อมูลใน YAML ใช้สองวิธี: machine processing และ human consumption. โปรเซสเซอร์ใน YAML ถูกใช้เป็นเครื่องมือสำหรับขั้นตอนการแปลงข้อมูลระหว่างมุมมองเสริมในแผนภาพที่ให้ไว้ข้างต้น บทนี้อธิบายโครงสร้างข้อมูลที่โปรเซสเซอร์ YAML ต้องจัดเตรียมไว้ภายในแอปพลิเคชันที่กำหนด

YAML มีขั้นตอนการทำให้เป็นอนุกรมสำหรับการแสดงวัตถุข้อมูลในรูปแบบอนุกรม การประมวลผลข้อมูล YAML ประกอบด้วยสามขั้นตอน:Representation, Serialization, Presentation and parsing. ให้เราคุยรายละเอียดแต่ละเรื่อง

การเป็นตัวแทน

YAML แสดงโครงสร้างข้อมูลโดยใช้โหนดสามประเภท: sequence, mapping และ scalar.

ลำดับ

ลำดับหมายถึงจำนวนรายการที่เรียงลำดับซึ่งแมปการเชื่อมโยงที่ไม่เรียงลำดับของคู่ค่าคีย์ สอดคล้องกับรายการอาร์เรย์ Perl หรือ Python

โค้ดที่แสดงด้านล่างเป็นตัวอย่างของการแสดงลำดับ -

product:
   - sku         : BL394D
     quantity    : 4
     description : Football
     price       : 450.00
   - sku         : BL4438H
     quantity    : 1
     description : Super Hoop
     price       : 2392.00

การทำแผนที่

การแมปในทางกลับกันแสดงถึงโครงสร้างข้อมูลพจนานุกรมหรือตารางแฮช ตัวอย่างเช่นเดียวกันได้กล่าวไว้ด้านล่าง -

batchLimit: 1000
threadCountLimit: 2
key: value
keyMapping: <What goes here?>

สเกลาร์

สเกลาร์แสดงถึงค่ามาตรฐานของสตริงจำนวนเต็มวันที่และชนิดข้อมูลอะตอม โปรดทราบว่า YAML ยังรวมถึงโหนดที่ระบุโครงสร้างชนิดข้อมูล สำหรับข้อมูลเพิ่มเติมเกี่ยวกับสเกลาร์โปรดดูบทที่ 6 ของบทช่วยสอนนี้

การทำให้เป็นอนุกรม

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

ตัวอย่างสำหรับการทำให้เป็นอนุกรมได้รับด้านล่าง -

consumer:
   class: 'AppBundle\Entity\consumer'
   attributes:
      filters: ['customer.search', 'customer.order', 'customer.boolean']
   collectionOperations:
      get:
         method: 'GET'
         normalization_context:
       groups: ['customer_list']
   itemOperations:
      get:
         method: 'GET'
         normalization_context:
            groups: ['customer_get']

การนำเสนอ

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

ตัวอย่างสำหรับกระบวนการนำเสนอ YAML คือผลลัพธ์ของค่า JSON ที่สร้างขึ้น สังเกตรหัสที่ระบุด้านล่างเพื่อความเข้าใจที่ดีขึ้น -

{
   "consumer": {
      "class": "AppBundle\\Entity\\consumer",
      "attributes": {
         "filters": [
            "customer.search",
            "customer.order",
            "customer.boolean"
         ]
      },
      "collectionOperations": {
         "get": {
            "method": "GET",
            "normalization_context": {
               "groups": [
                  "customer_list"
               ]
            }
         }
      },
      "itemOperations": {
         "get": {
            "method": "GET",
            "normalization_context": {
               "groups": [
                  "customer_get"
               ]
            }
         }
      }
   }
}

การแยกวิเคราะห์

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

ลองพิจารณาตัวอย่าง YAML ซึ่งระบุไว้ด้านล่าง -

---
   environment: production
   classes:
      nfs::server:
         exports:
            - /srv/share1
            - /srv/share3
   parameters:
      paramter1

ด้วยขีดกลางสามตัวแสดงถึงจุดเริ่มต้นของเอกสารที่มีแอตทริบิวต์ต่างๆที่กำหนดไว้ในภายหลัง

YAML lint เป็นตัวแยกวิเคราะห์ออนไลน์ของ YAML และช่วยในการแยกวิเคราะห์โครงสร้าง YAML เพื่อตรวจสอบว่าถูกต้องหรือไม่ ลิงก์อย่างเป็นทางการสำหรับผ้าสำลี YAML ระบุไว้ด้านล่าง:http://www.yamllint.com/

คุณสามารถดูผลลัพธ์ของการแยกวิเคราะห์ดังที่แสดงด้านล่าง -

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

สำหรับโมเดลข้อมูลสิ่งสำคัญคือต้องแสดงข้อมูลแอพพลิเคชั่นที่พกพาได้ระหว่างสภาพแวดล้อมการเขียนโปรแกรม

แผนภาพที่แสดงด้านบนแสดงถึงแบบจำลองข้อมูลปกติซึ่งแสดงในรูปแบบกราฟ ใน YAML การแสดงข้อมูลเนทีฟจะรูทเชื่อมต่อและกำกับกราฟของโหนดที่ติดแท็ก หากเรากล่าวถึงกราฟที่กำหนดทิศทางจะมีชุดของโหนดที่มีกราฟกำกับ ตามที่กล่าวไว้ในรูปแบบข้อมูล YAML รองรับโหนดสามชนิด ได้แก่ -

• Sequences
• Scalars
• Mappings

คำจำกัดความพื้นฐานของโหนดการแสดงเหล่านี้ถูกกล่าวถึงในบทสุดท้าย ในบทนี้เราจะเน้นไปที่แผนผังของคำเหล่านี้ แผนภาพลำดับต่อไปนี้แสดงถึงขั้นตอนการทำงานของตำนานที่มีแท็กและโหนดการแมปประเภทต่างๆ

โหนดมีสามประเภท: sequence node, scalar node และ mapping node.

ลำดับ

โหนดลำดับเป็นไปตามสถาปัตยกรรมแบบลำดับและรวมชุดลำดับของโหนดศูนย์ขึ้นไป ลำดับ YAML อาจมีโหนดเดียวกันซ้ำ ๆ กันหรือโหนดเดียว

สเกลาร์

เนื้อหาของสเกลาร์ใน YAML ประกอบด้วยอักขระ Unicode ซึ่งสามารถแสดงในรูปแบบด้วยชุดของศูนย์ โดยทั่วไปสเกลาร์โหนดจะมีปริมาณสเกลาร์

การทำแผนที่

โหนดการแม็พมีการแทนค่าคู่คีย์ เนื้อหาของโหนดการแมปประกอบด้วยการรวมกันของคู่คีย์ - ค่าที่มีเงื่อนไขบังคับว่าชื่อคีย์ควรจะไม่ซ้ำกัน ลำดับและการแมปรวมกันเป็นคอลเลกชัน

โปรดทราบว่าตามที่แสดงในแผนภาพที่แสดงด้านบนสเกลาร์ลำดับและการแมปจะแสดงในรูปแบบที่เป็นระบบ

อักขระประเภทต่างๆใช้สำหรับฟังก์ชันต่างๆ บทนี้พูดถึงรายละเอียดเกี่ยวกับไวยากรณ์ที่ใช้ใน YAML และมุ่งเน้นไปที่การจัดการอักขระ

อักขระตัวบ่งชี้

อักขระตัวบ่งชี้รวมถึงความหมายพิเศษที่ใช้อธิบายเนื้อหาของเอกสาร YAML ตารางต่อไปนี้แสดงรายละเอียดนี้

ซีเนียร์	ตัวละครและการทำงาน
1	_ หมายถึงรายการลำดับบล็อก
2	? หมายถึงคีย์การแมป
3	: หมายถึงค่าการแมป
4	, หมายถึงรายการคอลเลกชันการไหล
5	[ เริ่มลำดับการไหล
6	] สิ้นสุดลำดับการไหล
7	{ เริ่มต้นการแม็ปโฟลว์
8	} สิ้นสุดการแมปโฟลว์
9	# มันแสดงถึงความคิดเห็น
10	& หมายถึงคุณสมบัติจุดยึดของโหนด
11	* หมายถึงโหนดนามแฝง
12	! หมายถึงแท็กของโหนด
13	| หมายถึงสเกลาร์บล็อกตามตัวอักษร
14	> หมายถึงสเกลาร์บล็อกพับ
15	` อัญประกาศเดี่ยวล้อมรอบสเกลาร์โฟลว์ที่ยกมา
16	" อัญประกาศคู่ล้อมรอบสเกลาร์โฟลว์ที่ยกมาสองครั้ง
17	% หมายถึงคำสั่งที่ใช้

ตัวอย่างต่อไปนี้แสดงอักขระที่ใช้ในไวยากรณ์ -

%YAML 1.1
---
!!map {
   ? !!str "sequence"
   : !!seq [
      !!str "one", !!str "two"
   ],
   ? !!str "mapping"
   : !!map {
      ? !!str "sky" : !!str "blue",
      ? !!str "sea" : !!str "green",
   }
}

# This represents
# only comments.
---
!!map1 {
   ? !!str "anchored"
   : !local &A1 "value",
   ? !!str "alias"
   : *A1,
}
!!str "text"

ในบทนี้คุณจะได้เรียนรู้เกี่ยวกับลักษณะพื้นฐานของไวยากรณ์ใน YAML -

• พารามิเตอร์การผลิต
• ช่องว่างเยื้อง
• พื้นที่แยก
• คำนำหน้าบรรทัดที่ละเว้น
• การพับเส้น

ให้เราเข้าใจรายละเอียดในแต่ละด้าน

พารามิเตอร์การผลิต

พารามิเตอร์การผลิตประกอบด้วยชุดพารามิเตอร์และช่วงของค่าที่อนุญาตซึ่งใช้ในการผลิตเฉพาะ รายการพารามิเตอร์การผลิตต่อไปนี้ใช้ใน YAML -

เยื้อง

แสดงโดยอักขระ n หรือ mสตรีมตัวละครขึ้นอยู่กับระดับการเยื้องของบล็อกที่รวมอยู่ในนั้น การผลิตจำนวนมากได้กำหนดคุณลักษณะเหล่านี้

บริบท

แสดงโดย c. YAML รองรับบริบทสองกลุ่ม:block styles และ flow styles.

สไตล์

แสดงโดย s เนื้อหาสเกลาร์อาจนำเสนอในหนึ่งในห้ารูปแบบ:plain, double quoted and single quoted flow, literal and folded block.

ชมปิง

แสดงโดย t. บล็อกสเกลาร์มีกลไกมากมายที่ช่วยในการตัดแต่งบล็อก:strip, clip และ keep. Chomping ช่วยในการจัดรูปแบบสตริงบรรทัดใหม่ ใช้การแสดงลักษณะบล็อก กระบวนการ Chomping เกิดขึ้นด้วยความช่วยเหลือของตัวชี้วัด อินดิเคเตอร์จะควบคุมว่าเอาต์พุตใดที่ควรสร้างด้วยสตริงใหม่ บรรทัดใหม่จะถูกลบออกด้วย(-) มีการเพิ่มตัวดำเนินการและบรรทัดใหม่ด้วย (+) ตัวดำเนินการ

ตัวอย่างสำหรับกระบวนการ chomping แสดงไว้ด้านล่าง -

strip: |-
   text↓
clip: |
   text↓
keep: |+
   text↓

ผลลัพธ์หลังจากแยกวิเคราะห์ตัวอย่าง YAML ที่ระบุมีดังนี้ -

ช่องว่างเยื้อง

ในสตรีมอักขระ YAML การเยื้องถูกกำหนดให้เป็นอักขระตัวแบ่งบรรทัดด้วยอักขระศูนย์ขึ้นไป จุดสำคัญที่สุดที่ควรคำนึงถึงคือการเยื้องต้องไม่มีอักขระแท็บใด ๆ อักขระในการเยื้องไม่ควรถือเป็นส่วนหนึ่งของข้อมูลเนื้อหาของโหนด ปฏิบัติตามรหัสต่อไปนี้เพื่อความเข้าใจที่ดีขึ้น -

%YAML 1.1
---
!!map {
   ? !!str "Not indented"
   : !!map {
      ? !!str "By one space"
      : !!str "By four\n spaces\n",
      ? !!str "Flow style"
      : !!seq [
         !!str "By two",
         !!str "Still by two",
         !!str "Again by two",
      ]
   }
}

ผลลัพธ์ที่คุณสามารถเห็นได้หลังจากการเยื้องมีดังนี้ -

{
   "Not indented": {
      "By one space": "By four\n spaces\n", 
      "Flow style": [
         "By two", 
         "Still by two", 
         "Again by two"
      ]
   }
}

พื้นที่แยก

YAML ใช้อักขระเว้นวรรคเพื่อแยกระหว่างโทเค็น ข้อสังเกตที่สำคัญที่สุดคือการแยกใน YAML ไม่ควรมีอักขระแท็บ

รหัสเดียวต่อไปนี้แสดงการใช้ช่องว่างการแยก -

{ · first: · Sammy, · last: · Sosa · }

{
   "\u00b7 last": "\u00b7 Sosa \u00b7", 
   "\u00b7 first": "\u00b7 Sammy"
}

คำนำหน้าบรรทัดที่ละเว้น

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

ตัวอย่างต่อไปนี้แสดงการทำงานของคำนำหน้าบรรทัดที่ละเว้นอย่างเป็นระบบ -

%YAML 1.1
---
!!map {
   ? !!str "plain"
   : !!str "text lines",
   ? !!str "quoted"
   : !!str "text lines",
   ? !!str "block"
   : !!str "text·®lines\n"
}

ผลลัพธ์ที่ได้สำหรับสตรีมบล็อกมีดังนี้ -

{
   "plain": "text lines", 
   "quoted": "text lines", 
   "block": "text\u00b7\u00aelines\n"
}

สายพับ

Line Folding ช่วยให้สามารถทำลายเส้นยาว ๆ เพื่อให้อ่านง่าย จำนวนบรรทัดสั้นมากขึ้นหมายถึงการอ่านที่ดีขึ้น การพับเส้นทำได้โดยการสังเกตความหมายดั้งเดิมของสายยาว ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการพับเส้น -

%YAML 1.1
--- !!str
"specific\L\
trimmed\n\n\n\
as space"

คุณสามารถดูผลลัพธ์ของการพับบรรทัดในรูปแบบ JSON ได้ดังนี้ -

"specific\u2028trimmed\n\n\nas space"

ใน YAML คุณพบสตรีมตัวละครต่างๆดังนี้ -

• Directives
• เครื่องหมายขอบเขตเอกสาร
• Documents
• สตรีมสมบูรณ์

ในบทนี้เราจะพูดถึงรายละเอียด

คำสั่ง

Directives คือคำสั่งพื้นฐานที่ใช้ในโปรเซสเซอร์ YAML คำสั่งคือรายละเอียดการนำเสนอเช่นความคิดเห็นที่ไม่สะท้อนให้เห็นในแผนผังลำดับข้อมูล ใน YAML ไม่มีวิธีกำหนดคำสั่งส่วนตัว ส่วนนี้จะกล่าวถึงคำสั่งประเภทต่างๆพร้อมตัวอย่างที่เกี่ยวข้อง -

คำสั่งที่สงวนไว้

คำสั่งที่สงวนไว้จะเริ่มต้นด้วยอักขระยัติภังค์สามตัว (---) ดังที่แสดงในตัวอย่างด้านล่าง คำสั่งที่สงวนไว้จะถูกแปลงเป็นค่าเฉพาะของ JSON

%YAML 1.1
--- !!str
"foo"

คำสั่ง YAML

YAML Directives เป็นคำสั่งเริ่มต้น หากแปลงเป็น JSON ค่าที่ดึงมาจะรวมอักขระสแลชข้างหน้าในอักขระที่นำหน้าและสิ้นสุด

%YAML 1.1
---
!!str "foo"

เครื่องหมายขอบเขตเอกสาร

YAML ใช้เครื่องหมายเหล่านี้เพื่ออนุญาตให้มีเอกสารมากกว่าหนึ่งฉบับในสตรีมเดียว เครื่องหมายเหล่านี้ใช้เพื่อสื่อถึงโครงสร้างของเอกสาร YAML โดยเฉพาะ โปรดสังเกตว่าบรรทัดที่ขึ้นต้นด้วย“ ---“ ใช้เพื่อเริ่มเอกสารใหม่

รหัสต่อไปนี้อธิบายเกี่ยวกับเรื่องนี้พร้อมตัวอย่าง -

%YAML 1.1
---
!!str "foo"
%YAML 1.1
---
!!str "bar"
%YAML 1.1
---
!!str "baz"

เอกสาร

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

เอกสารที่ใช้ใน YAML มีสองประเภท มีคำอธิบายในส่วนนี้ -

เอกสารที่ชัดเจน

เริ่มต้นด้วยเครื่องหมายเริ่มต้นเอกสารตามด้วยการนำเสนอโหนดรูท ตัวอย่างของการประกาศอย่างชัดเจนของ YAML มีให้ด้านล่าง -

---

some: yaml

...

ประกอบด้วยเครื่องหมายจุดเริ่มต้นและจุดสิ้นสุดที่ชัดเจนซึ่ง ได้แก่ “ ---“ และ“ …” ในตัวอย่างที่กำหนด ในการแปลง YAML ที่ระบุในรูปแบบ JSON เราจะได้ผลลัพธ์ตามที่แสดงด้านล่าง -

{
   "some": "yaml"
}

เอกสารโดยปริยาย

เอกสารเหล่านี้ไม่ได้ขึ้นต้นด้วยเครื่องหมายเริ่มต้นเอกสาร สังเกตรหัสที่ระบุด้านล่าง -

fruits:
   - Apple
   - Orange
   - Pineapple
   - Mango

การแปลงค่าเหล่านี้ในรูปแบบ JSON เราได้ผลลัพธ์เป็นออบเจ็กต์ JSON อย่างง่ายดังที่ระบุด้านล่าง -

{
   "fruits": [
      "Apple",
      "Orange",
      "Pineapple",
      "Mango"
   ]
}

สตรีมสมบูรณ์

YAML มีลำดับของไบต์ที่เรียกว่าสตรีมอักขระ สตรีมเริ่มต้นด้วยคำนำหน้าที่มีลำดับไบต์แสดงถึงการเข้ารหัสอักขระ สตรีมที่สมบูรณ์เริ่มต้นด้วยคำนำหน้าที่มีการเข้ารหัสอักขระตามด้วยความคิดเห็น

ตัวอย่างสตรีมที่สมบูรณ์ (สตรีมอักขระ) แสดงอยู่ด้านล่าง -

%YAML 1.1
---
!!str "Text content\n"

โหนดการนำเสนอแต่ละโหนดมีลักษณะสำคัญสองประการที่เรียกว่า anchor และ tag. คุณสมบัติโหนดอาจถูกระบุด้วยเนื้อหาโหนดโดยละเว้นจากสตรีมอักขระ

ตัวอย่างพื้นฐานของการแสดงโหนดมีดังนี้ -

%YAML 1.1
---
!!map {
   ? &A1 !!str "foo"
   : !!str "bar",
   ? !!str &A2 "baz"
   : *a1
}

จุดยึดโหนด

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

%YAML 1.1
---
!!map {
   ? !!str "First occurence"
   : &A !!str "Value",
   ? !!str "Second occurence"
   : *A
}

ผลลัพธ์ของ YAML ที่สร้างด้วยโหนดจุดยึดแสดงอยู่ด้านล่าง -

---
!!map {
   ? !!str "First occurence"
   : !!str "Value",
   ? !!str "Second occurence"
   : !!str "Value",
}

แท็กโหนด

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

%YAML 1.1
---
!!map {
   ? !<tag:yaml.org,2002:str> "foo"
   : !<!bar> "baz"
}

เนื้อหาโหนด

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

%YAML 1.1
---
!!map {
   ? !!str "foo"
   : !!str "bar baz"
}

%YAML 1.1
---
!!str "foo bar"

%YAML 1.1
---
!!str "foo bar"

%YAML 1.1
---
!!str "foo bar\n"

ในบทนี้เราจะเน้นไปที่ประเภทสเกลาร์ต่างๆซึ่งใช้สำหรับแสดงเนื้อหา ใน YAML ความคิดเห็นอาจนำหน้าหรือติดตามเนื้อหาสเกลาร์ สิ่งสำคัญคือต้องทราบว่าไม่ควรรวมความคิดเห็นไว้ในเนื้อหาสเกลาร์

โปรดทราบว่าสไตล์สเกลาร์โฟลว์ทั้งหมดสามารถรวมได้หลายบรรทัดยกเว้นการใช้งานในหลายคีย์

การแสดงสเกลาร์แสดงไว้ด้านล่าง -

%YAML 1.1
---
!!map {
   ? !!str "simple key"
   : !!map {
      ? !!str "also simple"
      : !!str "value",
      ? !!str "not a simple key"
      : !!str "any value"
   }
}

ผลลัพธ์ที่สร้างขึ้นของส่วนหัวสเกลาร์บล็อกแสดงไว้ด้านล่าง -

{
   "simple key": {
      "not a simple key": "any value", 
      "also simple": "value"
   }
}

Document Marker Scalar เนื้อหา

อักขระทั้งหมดในตัวอย่างนี้ถือเป็นเนื้อหารวมถึงอักขระช่องว่างภายใน

%YAML 1.1
---
!!map {
   ? !!str "---"
   : !!str "foo",
   ? !!str "...",
   : !!str "bar"
}

%YAML 1.1
---
!!seq [
   !!str "---",
   !!str "...",
   !!map {
      ? !!str "---"
      : !!str "..."
   }
]

การแบ่งบรรทัดธรรมดาจะแสดงด้วยตัวอย่างด้านล่าง -

%YAML 1.1
---
!!str "as space \
trimmed\n\
specific\L\n\
none"

เอาต์พุต JSON ที่สอดคล้องกันสำหรับสิ่งเดียวกันมีการระบุไว้ด้านล่าง -

"as space trimmed\nspecific\u2028\nnone"

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

• โหนดนามแฝง
• โหนดว่าง
• รูปแบบ Flow Scalar
• รูปแบบการรวบรวมกระแส
• โหนดการไหล

ตัวอย่างของโหนดนามแฝงแสดงไว้ด้านล่าง -

%YAML 1.2
---
!!map {
   ? !!str "First occurrence"
   : &A !!str "Foo",
   ? !!str "Override anchor"
   : &B !!str "Bar",
   ? !!str "Second occurrence"
   : *A,
   ? !!str "Reuse anchor"
   : *B,
}

เอาต์พุต JSON ของโค้ดที่ระบุด้านบนแสดงไว้ด้านล่าง -

{
   "First occurrence": "Foo", 
   "Second occurrence": "Foo", 
   "Override anchor": "Bar", 
   "Reuse anchor": "Bar"
}

โหนดที่มีเนื้อหาว่างถือเป็นโหนดว่าง ตัวอย่างต่อไปนี้แสดงสิ่งนี้ -

%YAML 1.2
---
!!map {
   ? !!str "foo" : !!str "",
   ? !!str "" : !!str "bar",
}

ผลลัพธ์ของโหนดว่างใน JSON แสดงดังต่อไปนี้ -

{
   "": "bar", 
   "foo": ""
}

รูปแบบสเกลาร์ของโฟลว์ ได้แก่ ประเภทที่ยกมาสองครั้งแบบยกมาเดี่ยวและแบบธรรมดา ตัวอย่างพื้นฐานสำหรับสิ่งเดียวกันได้รับด้านล่าง -

%YAML 1.2
---
!!map {
   ? !!str "implicit block key"
   : !!seq [
      !!map {
         ? !!str "implicit flow key"
         : !!str "value",
      }
   ]  
}

ผลลัพธ์ในรูปแบบ JSON สำหรับตัวอย่างที่ระบุข้างต้นแสดงไว้ด้านล่าง -

{
   "implicit block key": [
      {
         "implicit flow key": "value"
      }
   ] 
}

คอลเลกชันโฟลว์ใน YAML ซ้อนกับบล็อกคอลเลกชันภายในคอลเลกชันโฟลว์อื่น รายการคอลเลกชันโฟลว์ถูกยกเลิกด้วยcomma (,) ตัวบ่งชี้ ตัวอย่างต่อไปนี้จะอธิบายบล็อกการรวบรวมโฟลว์โดยละเอียด -

%YAML 1.2
---
!!seq [
   !!seq [
      !!str "one",
      !!str "two",
   ],
   
   !!seq [
      !!str "three",
      !!str "four",
   ],
]

เอาต์พุตสำหรับการรวบรวมโฟลว์ใน JSON แสดงไว้ด้านล่าง -

[
   [
      "one", 
      "two"
   ], 
   [
      "three", 
      "four"
   ]
]

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

%YAML 1.2
---
!!seq [
!!seq [ !!str "a", !!str "b" ],
!!map { ? !!str "a" : !!str "b" },
!!str "a",
!!str "b",
!!str "c",]

ผลลัพธ์สำหรับโค้ดที่แสดงด้านบนในรูปแบบ JSON ได้รับด้านล่าง -

[
   [
      "a", 
      "b"
   ], 
   
   {
      "a": "b"
   }, 
   
   "a", 
   "b", 
   "c"
]

YAML มีรูปแบบสเกลาร์บล็อกสองแบบ: literal และ folded. บล็อกสเกลาร์ถูกควบคุมโดยมีตัวบ่งชี้เพียงไม่กี่ตัวที่มีส่วนหัวนำหน้าเนื้อหา ตัวอย่างของส่วนหัวของสเกลาร์บล็อกได้รับด้านล่าง -

%YAML 1.2
---
!!seq [
   !!str "literal\n",
   !!str "·folded\n",
   !!str "keep\n\n",
   !!str "·strip",
]

ผลลัพธ์ในรูปแบบ JSON ที่มีพฤติกรรมเริ่มต้นจะได้รับด้านล่าง -

[
   "literal\n", 
   "\u00b7folded\n", 
   "keep\n\n", 
   "\u00b7strip"
]

ประเภทของรูปแบบบล็อก

รูปแบบบล็อกมีสี่ประเภท: literal, folded, keep และ stripรูปแบบ รูปแบบบล็อกเหล่านี้ถูกกำหนดด้วยความช่วยเหลือของสถานการณ์บล็อกจอมปิง ตัวอย่างสถานการณ์การบล็อก chomping แสดงไว้ด้านล่าง -

%YAML 1.2
---
!!map {
   ? !!str "strip"
   : !!str "# text",
   ? !!str "clip"
   : !!str "# text\n",
   ? !!str "keep"
   : !!str "# text\n",
}

คุณสามารถดูผลลัพธ์ที่สร้างขึ้นด้วยสามรูปแบบใน JSON ตามที่ระบุด้านล่าง -

{
   "strip": "# text", 
   "clip": "# text\n", 
   "keep": "# text\n"
}

Chomping ใน YAML ควบคุมการแบ่งสุดท้ายและการลากเส้นว่างซึ่งตีความในรูปแบบต่างๆ

ปอก

ในกรณีนี้การแบ่งบรรทัดสุดท้ายและบรรทัดว่างจะไม่รวมสำหรับเนื้อหาสเกลาร์ มีการระบุโดยตัวบ่งชี้ chomping“ -“

การตัด

การคลิปถือเป็นลักษณะการทำงานเริ่มต้นหากไม่มีการระบุตัวบ่งชี้การจับคู่อย่างชัดเจน อักขระตัวแบ่งสุดท้ายจะถูกเก็บไว้ในเนื้อหาของสเกลาร์ ตัวอย่างที่ดีที่สุดของการตัดจะแสดงให้เห็นในตัวอย่างด้านบน จะสิ้นสุดด้วยการขึ้นบรรทัดใหม่“\n” ตัวละคร.

การรักษา

การเก็บรักษาหมายถึงการเพิ่มด้วยการแสดงตัวบ่งชี้“ +” chomping เส้นเพิ่มเติมที่สร้างขึ้นไม่สามารถพับได้ เส้นเพิ่มเติมไม่สามารถพับได้

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

ตัวอย่าง

ให้เราพิจารณาจำนวนดาวเคราะห์ในจักรวาลเป็นลำดับซึ่งสามารถสร้างเป็นคอลเลกชันได้ รหัสต่อไปนี้แสดงวิธีการแสดงรูปแบบลำดับของดาวเคราะห์ในจักรวาล -

# Ordered sequence of nodes in YAML STRUCTURE
Block style: !!seq
- Mercury   # Rotates - no light/dark sides.
- Venus     # Deadliest. Aptly named.
- Earth     # Mostly dirt.
- Mars      # Seems empty.
- Jupiter   # The king.
- Saturn    # Pretty.
- Uranus    # Where the sun hardly shines.
- Neptune   # Boring. No rings.
- Pluto     # You call this a planet?
Flow style: !!seq [ Mercury, Venus, Earth, Mars,      # Rocks
                    Jupiter, Saturn, Uranus, Neptune, # Gas
                    Pluto ]                           # Overrated

จากนั้นคุณจะเห็นผลลัพธ์ต่อไปนี้สำหรับลำดับลำดับในรูปแบบ JSON -

{
   "Flow style": [
      "Mercury", 
      "Venus", 
      "Earth", 
      "Mars", 
      "Jupiter", 
      "Saturn", 
      "Uranus", 
      "Neptune", 
      "Pluto"
   ], 
   
   "Block style": [
      "Mercury", 
      "Venus", 
      "Earth", 
      "Mars", 
      "Jupiter", 
      "Saturn", 
      "Uranus", 
      "Neptune", 
      "Pluto"
   ]
}

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

ตัวอย่าง

ตัวอย่างโครงสร้างผังงานแสดงไว้ด้านล่าง -

%YAML 1.1
paper:
   uuid: 8a8cbf60-e067-11e3-8b68-0800200c9a66
   name: On formally undecidable propositions of  Principia Mathematica and related systems I.
   author: Kurt Gödel.
tags:
   - tag:
      uuid: 98fb0d90-e067-11e3-8b68-0800200c9a66
      name: Mathematics
   - tag:
      uuid: 3f25f680-e068-11e3-8b68-0800200c9a66
      name: Logic

ผลลัพธ์ของลำดับที่แมป (รายการที่ไม่เรียงลำดับ) ในรูปแบบ JSON มีดังที่แสดงด้านล่าง -

{
   "paper": {
      "uuid": "8a8cbf60-e067-11e3-8b68-0800200c9a66",
      "name": "On formally undecidable propositions of Principia Mathematica and related systems I.",
      "author": "Kurt Gödel."
   },
   "tags": [
      {
         "tag": {
            "uuid": "98fb0d90-e067-11e3-8b68-0800200c9a66",
            "name": "Mathematics"
         }
      },
      {
         "tag": {
            "uuid": "3f25f680-e068-11e3-8b68-0800200c9a66",
            "name": "Logic"
         }
      }
   ]
}

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

ลำดับบล็อกของ YAML แสดงชุดของโหนด แต่ละรายการจะแสดงด้วยตัวบ่งชี้ "-" นำหน้า โปรดทราบว่าตัวบ่งชี้“ -” ใน YAML ควรแยกออกจากโหนดด้วยช่องว่าง

การแสดงพื้นฐานของลำดับบล็อกได้รับด้านล่าง -

block sequence:
··- one↓
  - two : three↓

ตัวอย่าง

ดูตัวอย่างต่อไปนี้เพื่อความเข้าใจที่ดีขึ้นเกี่ยวกับลำดับบล็อก

ตัวอย่าง 1

port: &ports
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  <<: *ports

ผลลัพธ์ของลำดับบล็อกในรูปแบบ JSON ได้รับด้านล่าง -

{
   "port": {
      "adapter": "postgres",
      "host": "localhost"
   },
   "development": {
      "database": "myapp_development",
      "adapter": "postgres",
      "host": "localhost"
   }
}

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

ประเภท

สคีมาที่ไม่ปลอดภัยมีสองประเภท: Generic Mapping และ Generic Sequence

การทำแผนที่ทั่วไป

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

ตัวอย่างสำหรับการแสดงการทำแผนที่ทั่วไปแสดงไว้ด้านล่าง -

Clark : Evans
Ingy : döt Net
Oren : Ben-Kiki
Flow style: !!map { Clark: Evans, Ingy: döt Net, Oren: Ben-Kiki }

ผลลัพธ์ของโครงสร้างการทำแผนที่ทั่วไปในรูปแบบ JSON แสดงอยู่ด้านล่าง -

{
   "Oren": "Ben-Kiki", 
   "Ingy": "d\u00f6t Net", 
   "Clark": "Evans", 
   "Flow style": {
      "Oren": "Ben-Kiki", 
      "Ingy": "d\u00f6t Net", 
      "Clark": "Evans"
   }
}

ลำดับทั่วไป

มันแสดงถึงประเภทของลำดับ ประกอบด้วยคอลเล็กชันที่จัดทำดัชนีโดยจำนวนเต็มตามลำดับที่เริ่มต้นด้วยศูนย์ มันแสดงด้วย!!seq แท็ก

Clark : Evans
Ingy : döt Net
Oren : Ben-Kiki
Flow style: !!seq { Clark: Evans, Ingy: döt Net, Oren: Ben-Kiki }

เอาต์พุตสำหรับลำดับทั่วไปของการป้องกันความผิดพลาดนี้

schema is shown below:
{
   "Oren": "Ben-Kiki", 
   "Ingy": "d\u00f6t Net", 
   "Clark": "Evans", 
   "Flow style": {
      "Oren": "Ben-Kiki", 
      "Ingy": "d\u00f6t Net", 
      "Clark": "Evans"
   }
}

สคีมา JSON ใน YAML ถือเป็นตัวส่วนร่วมของภาษาคอมพิวเตอร์สมัยใหม่ส่วนใหญ่ อนุญาตให้แยกวิเคราะห์ไฟล์ JSON ขอแนะนำอย่างยิ่งใน YAML ว่าควรพิจารณาสคีมาอื่น ๆ ในสคีมา JSON เหตุผลหลักคือการรวมค่าคีย์ที่เป็นมิตรกับผู้ใช้ ข้อความสามารถเข้ารหัสเป็นคีย์และสามารถใช้เป็นและเมื่อจำเป็น

สคีมา JSON เป็นสเกลาร์และไม่มีค่า รายการการแมปในสคีมา JSON จะแสดงในรูปแบบของคู่คีย์และค่าบางคู่โดยที่ค่าว่างถือว่าถูกต้อง

ตัวอย่าง

สคีมา null JSON แสดงดังที่แสดงด้านล่าง -

!!null null: value for null key
key with null value: !!null null

ผลลัพธ์ของการเป็นตัวแทน JSON ถูกกล่าวถึงด้านล่าง -

{
   "null": "value for null key", 
   "key with null value": null
}

ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงถึงสคีมา Boolean JSON -

YAML is a superset of JSON: !!bool true
Pluto is a planet: !!bool false

ต่อไปนี้เป็นผลลัพธ์ที่เหมือนกันในรูปแบบ JSON -

{
   "YAML is a superset of JSON": true, 
   "Pluto is a planet": false
}

ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงสคีมา JSON จำนวนเต็ม -

negative: !!int -12
zero: !!int 0
positive: !!int 34

{
   "positive": 34, 
   "zero": 0, 
   "negative": -12
}

ตัวอย่าง

แท็กในสคีมา JSON แสดงด้วยตัวอย่างต่อไปนี้ -

A null: null
Booleans: [ true, false ]
Integers: [ 0, -0, 3, -19 ]
Floats: [ 0., -0.0, 12e03, -2E+05 ]
Invalid: [ True, Null, 0o7, 0x3A, +12.3 ]

คุณสามารถค้นหา JSON Output ดังที่แสดงด้านล่าง -

{
   "Integers": [
      0, 
      0, 
      3, 
      -19
   ], 
   
   "Booleans": [
      true, 
      false
   ], 
   "A null": null, 

   "Invalid": [
         true, 
         null, 
         "0o7", 
         58, 
         12.300000000000001
   ], 
   
   "Floats": [
      0.0, 
      -0.0, 
      "12e03", 
      "-2E+05"
   ]
}