10 ជំហានទៅ YAML Zen

យើងទាំងអស់គ្នាស្រឡាញ់ Ansible ប៉ុន្តែ Ansible គឺ YAML ។ មានទម្រង់ជាច្រើនសម្រាប់ឯកសារកំណត់រចនាសម្ព័ន្ធ៖ បញ្ជីតម្លៃ ប៉ារ៉ាម៉ែត្រ-តម្លៃគូ ឯកសារ INI, YAML, JSON, XML និងផ្សេងៗទៀត។ ទោះយ៉ាងណាក៏ដោយ សម្រាប់ហេតុផលមួយចំនួនក្នុងចំណោមពួកគេទាំងអស់ YAML តែងតែត្រូវបានចាត់ទុកថាជាការលំបាកជាពិសេស។ ជាពិសេស ទោះបីជាមានភាពស្រស់ស្រាយតិចតួច និងសមត្ថភាពគួរឱ្យចាប់អារម្មណ៍សម្រាប់ធ្វើការជាមួយតម្លៃឋានានុក្រមក៏ដោយ វាក្យសម្ព័ន្ធ YAML អាចរំខានជាមួយនឹងវិធីសាស្រ្តដូច Python ក្នុងការចូលបន្ទាត់។

ប្រសិនបើ YAML ខឹងអ្នក អ្នកអាចធ្វើបាន ហើយអ្នកគួរតែ! - អនុវត្តជំហានទាំង 10 ខាងក្រោមដើម្បីកាត់បន្ថយការខកចិត្តរបស់អ្នកដល់កម្រិតដែលអាចទទួលយកបាន ហើយធ្លាក់ក្នុងអន្លង់ស្នេហ៍ជាមួយ YAML ។ ដូចដែលសមនឹងបញ្ជីនេះ គន្លឹះទាំងដប់របស់យើងនឹងត្រូវបានរាប់តាំងពីដំបូង យើងនឹងបន្ថែមការធ្វើសមាធិ និងការអនុវត្តខាងវិញ្ញាណតាមឆន្ទៈ 😉

0. ធ្វើឱ្យកម្មវិធីនិពន្ធរបស់អ្នកដំណើរការ

វាមិនមានបញ្ហាអ្វីដែលអ្នកមានកម្មវិធីនិពន្ធអត្ថបទនោះទេ ប្រហែលជាមានយ៉ាងហោចណាស់កម្មវិធីជំនួយមួយសម្រាប់ធ្វើការជាមួយ YAML ។ ប្រសិនបើអ្នកមិនមានទេ សូមស្វែងរក ហើយដំឡើងវាភ្លាមៗ។ ពេលវេលាដែលបានចំណាយក្នុងការស្វែងរក និងបង្កើតនឹងទូទាត់ច្រើនដង រាល់ពេលដែលអ្នកត្រូវកែសម្រួល YAML ។

ឧទាហរណ៍អ្នកកែសម្រួល អាតូម គាំទ្រ YAML តាមលំនាំដើម ប៉ុន្តែសម្រាប់ GNU Emacs អ្នកនឹងត្រូវដំឡើងកញ្ចប់បន្ថែមឧទាហរណ៍ yaml-mode.

Emacs នៅក្នុងរបៀប YAML និងបង្ហាញចន្លោះ។

ប្រសិនបើអ្នកកែសម្រួលដែលអ្នកចូលចិត្តមិនមានរបៀប YAML នោះបញ្ហាមួយចំនួនអាចត្រូវបានដោះស្រាយដោយធ្វើការជាមួយការកំណត់។ ឧទាហរណ៍ កម្មវិធីកែអត្ថបទ GNOME ស្តង់ដារ Gedit មិនមានរបៀប YAML ទេ ប៉ុន្តែតាមលំនាំដើម វារំលេចវាក្យសម្ព័ន្ធ YAML និងអនុញ្ញាតឱ្យអ្នកកំណត់រចនាសម្ព័ន្ធការងារជាមួយនឹងការចូលបន្ទាត់៖

ការកំណត់ការចូលបន្ទាត់នៅក្នុង Gedit ។

កម្មវិធីជំនួយមួយ។ ចន្លោះ សម្រាប់ Gedit បង្ហាញចន្លោះជាចំនុច បំបាត់ភាពមិនច្បាស់លាស់ជាមួយនឹងកម្រិតចូលបន្ទាត់។

ម្យ៉ាងវិញទៀត ចំណាយពេលសិក្សាអំពីកម្មវិធីនិពន្ធដែលអ្នកចូលចិត្ត។ ស្វែងយល់ពីអ្វីដែលគាត់ ឬសហគមន៍អភិវឌ្ឍន៍របស់គាត់ផ្តល់ជូនសម្រាប់ធ្វើការជាមួយ YAML ហើយប្រើប្រាស់មុខងារទាំងនោះ។ អ្នកប្រាកដជាមិនសោកស្តាយវាទេ។

1. ប្រើធុងសំរាម

តាមឧត្ដមគតិ ភាសាសរសេរកម្មវិធី និងភាសាសម្គាល់ប្រើវាក្យសម្ព័ន្ធដែលអាចព្យាករណ៍បាន។ កុំព្យូទ័រគឺល្អក្នុងការទស្សន៍ទាយដែលជាមូលហេតុដែលគំនិតនៃ អក្សរសិល្ប៍. ប្រសិនបើក្នុងរយៈពេល 40 ឆ្នាំនៃអត្ថិភាពរបស់វា វាបានឆ្លងកាត់អ្នក ហើយអ្នកនៅតែមិនប្រើធុងសំរាម YAML នោះដល់ពេលដែលត្រូវសាកល្បង yamllint ។

ដំឡើង យ៉ាមលីន អ្នកអាចប្រើកម្មវិធីគ្រប់គ្រងកញ្ចប់លីនុចស្តង់ដារ។ ឧទាហរណ៍នៅក្នុង លីនុចសហគ្រាសលីនុចក្រហម។ 8 ឬ។ Fedora វាត្រូវបានធ្វើដូចនេះ:

$ sudo dnf install yamllint

បន្ទាប់មកអ្នកគ្រាន់តែដំណើរការ yamllint ដោយឆ្លងកាត់ឯកសារ YAML ដើម្បីពិនិត្យ។ នេះ​ជា​អ្វី​ដែល​វា​មើល​ទៅ​ដូច​ជា​ប្រសិន​បើ​អ្នក​ហុច​ឯកសារ​មួយ​ដែល​មាន​កំហុស​ទៅ​នឹង linter៖

$ yamllint errorprone.yaml
errorprone.yaml
23:10     error    syntax error: mapping values are not allowed here
23:11     error    trailing spaces  (trailing-spaces)

លេខនៅខាងឆ្វេងមិនមែនជាពេលវេលាទេប៉ុន្តែកូអរដោនេនៃកំហុស: លេខជួរដេកនិងជួរឈរ។ ការពិពណ៌នាអំពីកំហុសប្រហែលជាមិនប្រាប់អ្នកអ្វីទាំងអស់ ប៉ុន្តែអ្នកដឹងច្បាស់ថាវានៅទីណា។ គ្រាន់តែមើលកន្លែងនេះនៅក្នុងកូដ ហើយភាគច្រើនទំនងជាអ្វីៗនឹងច្បាស់។

នៅពេលដែល yamllint រកមិនឃើញកំហុសនៅក្នុងឯកសារ គ្មានអ្វីត្រូវបានបោះពុម្ពលើអេក្រង់ទេ។ ប្រសិនបើភាពស្ងៀមស្ងាត់បែបនេះធ្វើឱ្យអ្នកភ័យខ្លាច ហើយអ្នកចង់បានមតិកែលម្អបន្តិចទៀតនោះ អ្នកអាចដំណើរការ linter ដោយប្រើពាក្យបញ្ជាអេកូតាមលក្ខខណ្ឌតាមរយៈ ampersand ទ្វេ (&&) ដូចនេះ៖

$ yamllint perfect.yaml && echo "OK"
OK

នៅក្នុង POSIX អំពែរទ្វេនឹងបាញ់ប្រសិនបើពាក្យបញ្ជាមុនត្រឡប់ 0 ។ ហើយ yamllint គ្រាន់តែត្រឡប់ចំនួននៃកំហុសដែលបានរកឃើញ ដែលជាមូលហេតុដែលការសាងសង់តាមលក្ខខណ្ឌទាំងមូលដំណើរការ។

2. សរសេរក្នុង Python មិនមែន YAML ទេ។

ប្រសិនបើ YAML ពិតជាធ្វើឱ្យអ្នកខឹង សូមកុំសរសេរវាតាមន័យត្រង់។ វាកើតឡើងថា YAML គឺជាទម្រង់តែមួយគត់ដែលកម្មវិធីយល់។ ប៉ុន្តែសូម្បីតែក្នុងករណីនេះវាមិនចាំបាច់ក្នុងការបង្កើតឯកសារ YAML ទេ។ សរសេរលើអ្វីដែលអ្នកចូលចិត្តហើយបន្ទាប់មកបម្លែង។ ជាឧទាហរណ៍ មានបណ្ណាល័យដ៏អស្ចារ្យមួយសម្រាប់ Python pyyaml និងវិធីបំប្លែងពីរ៖ ការបំប្លែងដោយខ្លួនឯង និងការបំប្លែងតាមរយៈស្គ្រីប។

ការបំប្លែងខ្លួនឯង

ក្នុងករណីនេះ ឯកសារទិន្នន័យក៏ជាស្គ្រីប Python ដែលបង្កើត YAML ផងដែរ។ វិធីសាស្រ្តនេះគឺសមបំផុតសម្រាប់សំណុំទិន្នន័យតូចៗ។ អ្នកគ្រាន់តែសរសេរទិន្នន័យ JSON ទៅជាអថេរ Python នាំវាជាមួយការណែនាំនាំចូល ហើយនៅចុងបញ្ចប់នៃឯកសារបន្ថែមបីបន្ទាត់ដើម្បីអនុវត្តលទ្ធផល។

#!/usr/bin/python3	
import yaml 

d={
"glossary": {
  "title": "example glossary",
  "GlossDiv": {
	"title": "S",
	"GlossList": {
	  "GlossEntry": {
		"ID": "SGML",
		"SortAs": "SGML",
		"GlossTerm": "Standard Generalized Markup Language",
		"Acronym": "SGML",
		"Abbrev": "ISO 8879:1986",
		"GlossDef": {
		  "para": "A meta-markup language, used to create markup languages such as DocBook.",
		  "GlossSeeAlso": ["GML", "XML"]
		  },
		"GlossSee": "markup"
		}
	  }
	}
  }
}

f=open('output.yaml','w')
f.write(yaml.dump(d))
f.close

ឥឡូវនេះយើងដំណើរការឯកសារនេះនៅក្នុង Python ហើយទទួលបានឯកសារ output.yaml៖

$ python3 ./example.json
$ cat output.yaml
glossary:
  GlossDiv:
	GlossList:
	  GlossEntry:
		Abbrev: ISO 8879:1986
		Acronym: SGML
		GlossDef:
		  GlossSeeAlso: [GML, XML]
		  para: A meta-markup language, used to create markup languages such as DocBook.
		GlossSee: markup
		GlossTerm: Standard Generalized Markup Language
		ID: SGML
		SortAs: SGML
	title: S
  title: example glossary

នេះគឺជា YAML ដែលមានសុពលភាពឥតខ្ចោះ ប៉ុន្តែ yamllint នឹងព្រមានអ្នកថាវាមិនចាប់ផ្តើមជាមួយ -. ជាការប្រសើរណាស់ វាអាចត្រូវបានកែតម្រូវយ៉ាងងាយស្រួលដោយដៃ ឬកែប្រែបន្តិចបន្តួចនៅក្នុងស្គ្រីប Python ។

ការបំប្លែងតាមរយៈស្គ្រីប

ក្នុងករណីនេះ ដំបូងយើងសរសេរជា JSON ហើយបន្ទាប់មកដំណើរការកម្មវិធីបម្លែងជាស្គ្រីប Python ដាច់ដោយឡែក ដែលផលិត YAML ជាលទ្ធផល។ បើប្រៀបធៀបទៅនឹងវិធីសាស្ត្រមុន វិធីសាស្ត្រនេះមានមាត្រដ្ឋានប្រសើរជាងមុន ដោយសារការបំប្លែងគឺដាច់ដោយឡែកពីទិន្នន័យ។

ជាដំបូង ចូរយើងបង្កើតឯកសារ JSON example.json ជាឧទាហរណ៍ អ្នកអាចយកវាពី json.org:

{
	"glossary": {
	  "title": "example glossary",
	  "GlossDiv": {
		"title": "S",
		"GlossList": {
		  "GlossEntry": {
			"ID": "SGML",
			"SortAs": "SGML",
			"GlossTerm": "Standard Generalized Markup Language",
			"Acronym": "SGML",
			"Abbrev": "ISO 8879:1986",
			"GlossDef": {
			  "para": "A meta-markup language, used to create markup languages such as DocBook.",
			  "GlossSeeAlso": ["GML", "XML"]
			  },
			"GlossSee": "markup"
			}
		  }
		}
	  }
	}

បន្ទាប់​មក​យើង​នឹង​បង្កើត​ស្គ្រីប​បំប្លែង​សាមញ្ញ ហើយ​រក្សា​ទុក​វា​ក្រោម​ឈ្មោះ json2yaml.py ។ ស្គ្រីបនេះនាំចូលទាំងម៉ូឌុល YAML និង JSON Python ហើយផ្ទុកឯកសារ JSON ដែលបញ្ជាក់ដោយអ្នកប្រើប្រាស់ ដំណើរការការបំប្លែង និងសរសេរទិន្នន័យទៅឯកសារ output.yaml ។

#!/usr/bin/python3
import yaml
import sys
import json

OUT=open('output.yaml','w')
IN=open(sys.argv[1], 'r')

JSON = json.load(IN)
IN.close()
yaml.dump(JSON, OUT)
OUT.close()

រក្សាទុកស្គ្រីបនេះក្នុងផ្លូវប្រព័ន្ធ ហើយដំណើរការវាតាមតម្រូវការ៖

$ ~/bin/json2yaml.py example.json

3. ញែកច្រើន និងញឹកញាប់

ពេលខ្លះវាមានប្រយោជន៍ក្នុងការមើលបញ្ហាពីមុំផ្សេង។ ប្រសិនបើអ្នកមានបញ្ហាក្នុងការតំណាងឱ្យទំនាក់ទំនងរវាងទិន្នន័យរបស់អ្នកនៅក្នុង YAML អ្នកអាចបំប្លែងវាទៅជាអ្វីដែលធ្លាប់ស្គាល់ជាបណ្តោះអាសន្ន។

ឧទាហរណ៍ ប្រសិនបើអ្នកមានផាសុកភាពក្នុងការធ្វើការជាមួយបញ្ជីវចនានុក្រម ឬ JSON អ្នកអាចបំប្លែង YAML ទៅជា JSON ដោយគ្រាន់តែប្រើពាក្យបញ្ជាពីរនៅក្នុងសែល Python អន្តរកម្ម។ ចូរនិយាយថាអ្នកមានឯកសារ YAML mydata.yaml បន្ទាប់មកនេះជាអ្វីដែលវានឹងមើលទៅ៖

$ python3
>>> f=open('mydata.yaml','r')
>>> yaml.load(f)
{'document': 34843, 'date': datetime.date(2019, 5, 23), 'bill-to': {'given': 'Seth', 'family': 'Kenlon', 'address': {'street': '51b Mornington Roadn', 'city': 'Brooklyn', 'state': 'Wellington', 'postal': 6021, 'country': 'NZ'}}, 'words': 938, 'comments': 'Good article. Could be better.'}

អ្នកអាចរកឃើញឧទាហរណ៍ជាច្រើនទៀតលើប្រធានបទនេះ។ លើសពីនេះទៀត មានកម្មវិធីបំប្លែងតាមអ៊ីនធឺណិត និងឧបករណ៍ញែកក្នុងស្រុកជាច្រើនដែលអាចរកបាន។ ដូច្នេះកុំស្ទាក់ស្ទើរក្នុងការធ្វើកំណែទម្រង់ទិន្នន័យ នៅពេលអ្នកឃើញតែភាពច្របូកច្របល់ដែលមិនអាចយល់បាននៅក្នុងវា។

4. អានលក្ខណៈបច្ចេកទេស

ត្រលប់ទៅ YAML វិញបន្ទាប់ពីសម្រាកយូរ វាមានប្រយោជន៍ក្នុងការទស្សនា yaml.org ហើយអានឡើងវិញនូវលក្ខណៈបច្ចេកទេស (Specs)។ ប្រសិនបើអ្នកមានការលំបាកជាមួយ YAML ប៉ុន្តែមិនទាន់ទទួលបានព័ត៌មានជាក់លាក់ទេ នោះដល់ពេលដែលត្រូវកែតម្រូវស្ថានភាពនេះ។ លក្ខណៈបច្ចេកទេសគឺងាយស្រួលសរសេរគួរឱ្យភ្ញាក់ផ្អើល ហើយតម្រូវការវាក្យសម្ព័ន្ធត្រូវបានបង្ហាញជាមួយនឹងឧទាហរណ៍មួយចំនួនធំនៅក្នុង អិល ៣.

5. Pseudo-configs

នៅពេលសរសេរសៀវភៅ ឬអត្ថបទ វាតែងតែមានប្រយោជន៍ក្នុងការគូសវាសចេញនូវគ្រោងបឋម យ៉ាងហោចណាស់ក្នុងទម្រង់ជាតារាងមាតិកា។ វាដូចគ្នាជាមួយ YAML ដែរ។ ភាគច្រើន អ្នកមានគំនិតអំពីអ្វីដែលទិន្នន័យត្រូវសរសេរទៅក្នុងឯកសារ YAML ប៉ុន្តែអ្នកពិតជាមិនយល់ពីរបៀបភ្ជាប់វាជាមួយគ្នាទៅវិញទៅមកទេ។ ដូច្នេះមុននឹងឆ្លាក់ YAML សូមគូររូប pseudo-config ។

Pseudo-config គឺស្រដៀងទៅនឹង pseudo-code ដែលអ្នកមិនចាំបាច់ព្រួយបារម្ភអំពីរចនាសម្ព័ន្ធ ឬការចូលបន្ទាត់ ទំនាក់ទំនងឪពុកម្តាយ និងកូន មរតក និងការដាក់សំបុក។ វាដូចគ្នានៅទីនេះ៖ អ្នកគូរឡើងវិញនូវទិន្នន័យ ដូចដែលពួកវាកើតឡើងនៅក្នុងក្បាលរបស់អ្នក។

អ្នកសរសេរកម្មវិធីដែលបានចុះបញ្ជី Pseudo-config (ម៉ាទីន និងតាប៊ីថា) និងជំនាញរបស់ពួកគេ (ភាសាសរសេរកម្មវិធី៖ Python, Perl, Pascal និង Lisp, Fortran, Erlang រៀងគ្នា)។

បន្ទាប់ពីគូររូប pseudo-config នៅលើក្រដាសមួយ សូមវិភាគវាដោយប្រុងប្រយ័ត្ន ហើយប្រសិនបើអ្វីៗមានសណ្តាប់ធ្នាប់ សូមធ្វើទ្រង់ទ្រាយវាជាទម្រង់ឯកសារ YAML ត្រឹមត្រូវ។

6. The Tabs vs. Spaces Dilemma

អ្នកនឹងត្រូវដោះស្រាយវិបត្តិ "ផ្ទាំង ឬចន្លោះ?". មិន​មែន​ក្នុង​ន័យ​សកល​ទេ ប៉ុន្តែ​មាន​តែ​កម្រិត​នៃ​ស្ថាប័ន​របស់​អ្នក ឬ​យ៉ាង​ហោច​ណាស់​គម្រោង​មួយ។ វាមិនមានបញ្ហាថាតើវាពាក់ព័ន្ធនឹងការប្រើការដំណើរការក្រោយដោយប្រើស្គ្រីប sed ការដំឡើងកម្មវិធីនិពន្ធអត្ថបទនៅលើម៉ាស៊ីនរបស់អ្នកសរសេរកម្មវិធី ឬទទួលយកការទទួលជាសកលនៃការអនុលោមតាមការណែនាំរបស់ linter ក្រោមការគំរាមកំហែងនៃការបណ្តេញចេញ ប៉ុន្តែសមាជិកទាំងអស់នៃក្រុមរបស់អ្នកដែលនៅក្នុង វិធីមួយ ឬវិធីផ្សេងទៀតដែលទាក់ទងនឹង YAML ត្រូវតែប្រើតែចន្លោះ (តាមតម្រូវការដោយការកំណត់របស់ YAML)។

នៅក្នុងកម្មវិធីនិពន្ធអត្ថបទធម្មតាណាមួយ អ្នកអាចកំណត់រចនាសម្ព័ន្ធផ្ទាំងកែដោយស្វ័យប្រវត្តិទៅចំនួនចន្លោះដែលបានបញ្ជាក់ ដូច្នេះការបះបោរនៃអ្នកប្រកាន់ខ្ជាប់គន្លឹះ ថេប អ្នកមិនចាំបាច់ភ័យខ្លាចទេ។

ដូចដែលអ្នកស្អប់ YAML គ្រប់រូបដឹងយ៉ាងច្បាស់ អ្នកមិនអាចមើលឃើញភាពខុសគ្នារវាងផ្ទាំង និងចន្លោះនៅលើអេក្រង់នោះទេ។ ហើយនៅពេលដែលអ្វីមួយដែលមើលមិនឃើញ ជាធម្មតាវាជារឿងចុងក្រោយដែលមនុស្សចងចាំ បន្ទាប់ពីពួកគេបានតម្រៀប ពិនិត្យ និងលុបបំបាត់បញ្ហាដែលអាចកើតមានផ្សេងទៀត។ មួយម៉ោងនៃពេលវេលាដែលបានចំណាយក្នុងការស្វែងរកខ្សែកោងតារាង ឬប្លុកនៃចន្លោះមួយគ្រាន់តែស្រែកថាអ្នកត្រូវការជាបន្ទាន់ដើម្បីបង្កើតគោលការណ៍សម្រាប់ការប្រើប្រាស់មួយ ឬផ្សេងទៀត ហើយបន្ទាប់មកអនុវត្តការត្រួតពិនិត្យបេតុងដែលបានពង្រឹងសម្រាប់ការអនុលោមតាមវា (ឧទាហរណ៍តាមរយៈ ទំពក់ Git ដើម្បីបង្ខំវាតាមរយៈ linter) ។

7. តិចគឺច្រើន (ឬច្រើនគឺតិច)

មនុស្សមួយចំនួនចូលចិត្តសរសេរក្នុង YAML ព្រោះវាសង្កត់ធ្ងន់លើរចនាសម្ព័ន្ធ។ ក្នុងពេលជាមួយគ្នានេះ ពួកគេប្រើការចូលបន្ទាត់យ៉ាងសកម្មដើម្បីរំលេចប្លុកទិន្នន័យ។ នេះ​ជា​ប្រភេទ​នៃ​ការ​ឆបោក​ដើម្បី​យក​តម្រាប់​តាម​ភាសា​សម្គាល់​ដែល​ប្រើ​សញ្ញា​កំណត់​ច្បាស់លាស់។

នេះគឺជាឧទាហរណ៍នៃរចនាសម្ព័ន្ធបែបនេះពី ឯកសារដែលអាចយល់បាន។:

# Employee records
-  martin:
        name: Martin D'vloper
        job: Developer
        skills:
            - python
            - perl
            - pascal
-  tabitha:
        name: Tabitha Bitumen
        job: Developer
        skills:
            - lisp
            - fortran
            - erlang

សម្រាប់អ្នកខ្លះ ជម្រើសនេះជួយឱ្យពួកគេតម្រៀបរចនាសម្ព័ន្ធ YAML នៅក្នុងក្បាលរបស់ពួកគេ ផ្ទុយទៅវិញ វាធ្វើឱ្យពួកគេឆាប់ខឹងជាមួយនឹងការចូលបន្ទាត់ដែលមិនចាំបាច់ច្រើនតាមគំនិតរបស់ពួកគេ។

ប៉ុន្តែប្រសិនបើអ្នកជាម្ចាស់ឯកសារ YAML ហើយទទួលខុសត្រូវក្នុងការថែរក្សាវា នោះហើយ។ អ្នកនិងតែអ្នកប៉ុណ្ណោះ។ ត្រូវតែកំណត់ពីរបៀបប្រើការចូលបន្ទាត់។ ប្រសិនបើអ្នកមានការរំខានដោយទ្រនាប់ធំ សូមរក្សាវាឱ្យតិចបំផុតតាមដែលអាចធ្វើទៅបាន យោងទៅតាមការបញ្ជាក់របស់ YAML ។ ឧទាហរណ៍ ឯកសារខាងលើពីឯកសារ Ansible អាចត្រូវបានសរសេរឡើងវិញដូចនេះដោយមិនបាត់បង់អ្វីឡើយ៖

---
- martin:
   name: Martin D'vloper
   job: Developer
   skills:
   - python
   - perl
   - pascal
- tabitha:
   name: Tabitha Bitumen
   job: Developer
   skills:
   - lisp
   - fortran
   - erlang

8. ប្រើចន្លោះទទេ

ប្រសិនបើអ្នកធ្វើម្តងទៀតនូវកំហុសដដែលៗនៅពេលបំពេញឯកសារ YAML វាសមហេតុផលក្នុងការបញ្ចូលគំរូទៅក្នុងវាជាមតិយោបល់។ បន្ទាប់មកនៅពេលក្រោយ អ្នកអាចចម្លងគំរូនេះ ហើយបញ្ចូលទិន្នន័យពិតនៅទីនោះ ឧទាហរណ៍៖

---
# - <common name>:
#   name: Given Surname
#   job: JOB
#   skills:
#   - LANG
- martin:
  name: Martin D'vloper
  job: Developer
  skills:
  - python
  - perl
  - pascal
- tabitha:
  name: Tabitha Bitumen
  job: Developer
  skills:
  - lisp
  - fortran
  - erlang

9. ប្រើអ្វីផ្សេង

ប្រសិនបើកម្មវិធីមិនមានការច្របាច់កលើអ្នកទេ នោះវាអាចមានតម្លៃផ្លាស់ប្តូរ YAML ទៅជាទម្រង់ផ្សេង។ យូរៗទៅ ឯកសារកំណត់រចនាសម្ព័ន្ធអាចរីកធំឡើងដោយខ្លួនឯង ហើយបន្ទាប់មក វាជាការប្រសើរក្នុងការបំប្លែងពួកវាទៅជាស្គ្រីបសាមញ្ញនៅក្នុង Lua ឬ Python ។

YAML គឺជារបស់ដ៏អស្ចារ្យដែលមនុស្សជាច្រើនចូលចិត្តសម្រាប់ភាពសាមញ្ញបំផុត និងភាពសាមញ្ញរបស់វា ប៉ុន្តែវានៅឆ្ងាយពីឧបករណ៍តែមួយគត់នៅក្នុងឃ្លាំងរបស់អ្នក។ ដូច្នេះពេលខ្លះអ្នកអាចបដិសេធបាន។ បណ្ណាល័យញែកមានភាពងាយស្រួលក្នុងការស្វែងរកសម្រាប់ YAML ដូច្នេះប្រសិនបើអ្នកផ្តល់ជម្រើសក្នុងការធ្វើចំណាកស្រុកងាយស្រួល អ្នកប្រើប្រាស់របស់អ្នកនឹងរួចផុតពីការបរាជ័យនេះដោយមិនមានការឈឺចាប់។

ប្រសិនបើអ្នកមិនអាចធ្វើបានដោយគ្មាន YAML ទេ យកគន្លឹះទាំង 10 នេះហើយយកឈ្នះការមិនចូលចិត្ត YAML របស់អ្នកម្តងហើយម្តងទៀត!

ប្រភព: www.habr.com