YAML Zen ಗೆ 10 ಹಂತಗಳು

ನಾವೆಲ್ಲರೂ ಅನ್ಸಿಬಲ್ ಅನ್ನು ಪ್ರೀತಿಸುತ್ತೇವೆ, ಆದರೆ ಅನ್ಸಿಬಲ್ YAML ಆಗಿದೆ. ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳಿಗಾಗಿ ಹಲವು ಫಾರ್ಮ್ಯಾಟ್‌ಗಳಿವೆ: ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಗಳು, ಪ್ಯಾರಾಮೀಟರ್-ಮೌಲ್ಯ ಜೋಡಿಗಳು, INI ಫೈಲ್‌ಗಳು, YAML, JSON, XML ಮತ್ತು ಇತರ ಹಲವು. ಆದಾಗ್ಯೂ, ಅವುಗಳಲ್ಲಿ ಹಲವು ಕಾರಣಗಳಿಗಾಗಿ, YAML ಅನ್ನು ವಿಶೇಷವಾಗಿ ಕಷ್ಟಕರವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಅದರ ರಿಫ್ರೆಶ್ ಕನಿಷ್ಠೀಯತೆ ಮತ್ತು ಶ್ರೇಣೀಕೃತ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಪ್ರಭಾವಶಾಲಿ ಸಾಮರ್ಥ್ಯಗಳ ಹೊರತಾಗಿಯೂ, YAML ಸಿಂಟ್ಯಾಕ್ಸ್ ಇಂಡೆಂಟೇಶನ್‌ಗೆ ಅದರ ಪೈಥಾನ್ ತರಹದ ವಿಧಾನದಿಂದ ಕಿರಿಕಿರಿ ಉಂಟುಮಾಡಬಹುದು.

YAML ನಿಮ್ಮನ್ನು ಕೆರಳಿಸಿದರೆ, ನೀವು ಮಾಡಬಹುದು-ಮತ್ತು ನೀವು ಮಾಡಬೇಕು! - ನಿಮ್ಮ ಹತಾಶೆಯನ್ನು ಸ್ವೀಕಾರಾರ್ಹ ಮಟ್ಟಕ್ಕೆ ತಗ್ಗಿಸಲು ಮತ್ತು YAML ನೊಂದಿಗೆ ಪ್ರೀತಿಯಲ್ಲಿ ಬೀಳಲು ಕೆಳಗಿನ 10 ಹಂತಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ. ಈ ಪಟ್ಟಿಗೆ ಸರಿಹೊಂದುವಂತೆ, ನಮ್ಮ ಹತ್ತು ಸಲಹೆಗಳನ್ನು ಮೊದಲಿನಿಂದ ಎಣಿಸಲಾಗುವುದು, ನಾವು ಇಚ್ಛೆಯಂತೆ ಧ್ಯಾನ ಮತ್ತು ಆಧ್ಯಾತ್ಮಿಕ ಅಭ್ಯಾಸಗಳನ್ನು ಸೇರಿಸುತ್ತೇವೆ 😉

0. ನಿಮ್ಮ ಸಂಪಾದಕವನ್ನು ಕೆಲಸ ಮಾಡುವಂತೆ ಮಾಡಿ

ನೀವು ಯಾವ ಪಠ್ಯ ಸಂಪಾದಕವನ್ನು ಹೊಂದಿದ್ದೀರಿ ಎಂಬುದು ಮುಖ್ಯವಲ್ಲ, ಬಹುಶಃ YAML ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಕನಿಷ್ಠ ಒಂದು ಪ್ಲಗಿನ್ ಇರುತ್ತದೆ. ನೀವು ಒಂದನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, ಅದನ್ನು ತಕ್ಷಣವೇ ಹುಡುಕಿ ಮತ್ತು ಸ್ಥಾಪಿಸಿ. ನೀವು YAML ಅನ್ನು ಸಂಪಾದಿಸಲು ಪ್ರತಿ ಬಾರಿ ಹುಡುಕಲು ಮತ್ತು ಹೊಂದಿಸಲು ಕಳೆದ ಸಮಯವು ಹಲವು ಬಾರಿ ಪಾವತಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, ಸಂಪಾದಕ ಆಯ್ಟಮ್ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ YAML ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಆದರೆ GNU Emacs ಗಾಗಿ ನೀವು ಹೆಚ್ಚುವರಿ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, ಯಾಮಲ್-ಮೋಡ್.

YAML ಮೋಡ್‌ನಲ್ಲಿ ಇಮ್ಯಾಕ್ಸ್ ಮತ್ತು ಸ್ಪೇಸ್‌ಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ನಿಮ್ಮ ನೆಚ್ಚಿನ ಸಂಪಾದಕರು YAML ಮೋಡ್ ಅನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಮೂಲಕ ಕೆಲವು ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಪ್ರಮಾಣಿತ GNOME ಪಠ್ಯ ಸಂಪಾದಕ Gedit YAML ಮೋಡ್ ಅನ್ನು ಹೊಂದಿಲ್ಲ, ಆದರೆ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಇದು YAML ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಹೈಲೈಟ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಇಂಡೆಂಟೇಶನ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ:

ಗೆಡಿಟ್‌ನಲ್ಲಿ ಇಂಡೆಂಟ್‌ಗಳನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ.

ಒಂದು ಪ್ಲಗಿನ್ ಡ್ರಾಸ್ಪೇಸ್ಗಳು Gedit ಗಾಗಿ, ಸ್ಥಳಗಳನ್ನು ಚುಕ್ಕೆಗಳಂತೆ ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಇಂಡೆಂಟೇಶನ್ ಮಟ್ಟಗಳೊಂದಿಗೆ ಅಸ್ಪಷ್ಟತೆಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.

ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನಿಮ್ಮ ನೆಚ್ಚಿನ ಸಂಪಾದಕರ ಬಗ್ಗೆ ಕಲಿಯಲು ಸಮಯ ಕಳೆಯಿರಿ. YAML ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅವನು ಅಥವಾ ಅವನ ಅಭಿವೃದ್ಧಿ ಸಮುದಾಯವು ಏನನ್ನು ನೀಡುತ್ತದೆ ಎಂಬುದನ್ನು ಕಂಡುಕೊಳ್ಳಿ ಮತ್ತು ಆ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಿ. ನೀವು ಖಂಡಿತವಾಗಿಯೂ ವಿಷಾದಿಸುವುದಿಲ್ಲ.

1. ಲಿಂಟರ್ ಬಳಸಿ

ತಾತ್ತ್ವಿಕವಾಗಿ, ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಮತ್ತು ಮಾರ್ಕ್ಅಪ್ ಭಾಷೆಗಳು ಊಹಿಸಬಹುದಾದ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸುತ್ತವೆ. ಕಂಪ್ಯೂಟರುಗಳು ಊಹಿಸಲು ಉತ್ತಮವಾಗಿವೆ, ಅದಕ್ಕಾಗಿಯೇ ಪರಿಕಲ್ಪನೆ ಲಿಂಟೆರಾ. ಅದರ ಅಸ್ತಿತ್ವದ 40 ವರ್ಷಗಳಲ್ಲಿ ಅದು ನಿಮ್ಮನ್ನು ಹಾದು ಹೋಗಿದ್ದರೆ ಮತ್ತು ನೀವು ಇನ್ನೂ YAML ಲಿಂಟರ್ ಅನ್ನು ಬಳಸದಿದ್ದರೆ, ಯಾಮ್ಲಿಂಟ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸಲು ಇದು ಸಮಯ.

ಸ್ಥಾಪಿಸಿ ಯಾಮ್ಲಿಂಟ್ ನೀವು ಪ್ರಮಾಣಿತ ಲಿನಕ್ಸ್ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಇನ್ Red Hat ಎಂಟರ್ಪ್ರೈಸ್ ಲಿನಕ್ಸ್ 8 ಅಥವಾ ಫೆಡೋರಾ ಇದನ್ನು ಈ ರೀತಿ ಮಾಡಲಾಗಿದೆ:

$ sudo dnf install yamllint

ನಂತರ ನೀವು yamllint ಅನ್ನು ಚಲಾಯಿಸಿ, ಅದನ್ನು ಪರಿಶೀಲಿಸಲು YAML ಫೈಲ್ ಅನ್ನು ರವಾನಿಸಿ. ನೀವು ದೋಷದೊಂದಿಗೆ ಫೈಲ್ ಅನ್ನು ಲಿಂಟರ್‌ಗೆ ರವಾನಿಸಿದರೆ ಅದು ಹೇಗೆ ಕಾಣುತ್ತದೆ:

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

ಎಡಭಾಗದಲ್ಲಿರುವ ಸಂಖ್ಯೆಗಳು ಸಮಯವಲ್ಲ, ಆದರೆ ದೋಷದ ನಿರ್ದೇಶಾಂಕಗಳು: ಸಾಲು ಮತ್ತು ಕಾಲಮ್ ಸಂಖ್ಯೆ. ದೋಷದ ವಿವರಣೆಯು ನಿಮಗೆ ಏನನ್ನೂ ಹೇಳದಿರಬಹುದು, ಆದರೆ ಅದು ಎಲ್ಲಿದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ. ಕೋಡ್‌ನಲ್ಲಿ ಈ ಸ್ಥಳವನ್ನು ನೋಡಿ, ಮತ್ತು ಹೆಚ್ಚಾಗಿ ಎಲ್ಲವೂ ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ.

yamllint ಫೈಲ್‌ನಲ್ಲಿ ಯಾವುದೇ ದೋಷಗಳನ್ನು ಕಂಡುಕೊಂಡಾಗ, ಪರದೆಯ ಮೇಲೆ ಏನನ್ನೂ ಮುದ್ರಿಸಲಾಗುವುದಿಲ್ಲ. ಅಂತಹ ಮೌನವು ನಿಮ್ಮನ್ನು ಹೆದರಿಸಿದರೆ ಮತ್ತು ನೀವು ಸ್ವಲ್ಪ ಹೆಚ್ಚಿನ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಬಯಸಿದರೆ, ನೀವು ಷರತ್ತುಬದ್ಧ ಪ್ರತಿಧ್ವನಿ ಆಜ್ಞೆಯೊಂದಿಗೆ ಡಬಲ್ ಆಂಪರ್ಸೆಂಡ್ (&&) ಮೂಲಕ ಲಿಂಟರ್ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು:

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

POSIX ನಲ್ಲಿ, ಹಿಂದಿನ ಆಜ್ಞೆಯು 0 ಅನ್ನು ಹಿಂದಿರುಗಿಸಿದರೆ ಮತ್ತು ಮಾತ್ರ ಡಬಲ್ ಆಂಪರ್ಸೆಂಡ್ ಫೈರ್ ಆಗುತ್ತದೆ. ಮತ್ತು yamllint ಕೇವಲ ಕಂಡುಬರುವ ದೋಷಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಅದಕ್ಕಾಗಿಯೇ ಈ ಸಂಪೂರ್ಣ ಷರತ್ತುಬದ್ಧ ರಚನೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

2. ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆಯಿರಿ, YAML ಅಲ್ಲ

YAML ನಿಜವಾಗಿಯೂ ನಿಮ್ಮನ್ನು ಕೆರಳಿಸಿದರೆ, ಅಕ್ಷರಶಃ ಅದರಲ್ಲಿ ಬರೆಯಬೇಡಿ. ಅಪ್ಲಿಕೇಶನ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಏಕೈಕ ಸ್ವರೂಪ YAML ಆಗಿದೆ. ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸಹ, YAML ಫೈಲ್ ಅನ್ನು ರಚಿಸುವುದು ಅನಿವಾರ್ಯವಲ್ಲ. ನೀವು ಇಷ್ಟಪಡುವದನ್ನು ಬರೆಯಿರಿ ಮತ್ತು ನಂತರ ಪರಿವರ್ತಿಸಿ. ಉದಾಹರಣೆಗೆ, ಪೈಥಾನ್‌ಗಾಗಿ ಉತ್ತಮ ಗ್ರಂಥಾಲಯವಿದೆ pyyaml ಮತ್ತು ಎರಡು ಪರಿವರ್ತನೆ ವಿಧಾನಗಳು: ಸ್ವ-ಪರಿವರ್ತನೆ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಮೂಲಕ ಪರಿವರ್ತನೆ.

ಸ್ವಯಂ ಪರಿವರ್ತನೆ

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಡೇಟಾ ಫೈಲ್ ಕೂಡ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಆಗಿದ್ದು ಅದು YAML ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಸಣ್ಣ ಡೇಟಾ ಸೆಟ್‌ಗಳಿಗೆ ಈ ವಿಧಾನವು ಸೂಕ್ತವಾಗಿರುತ್ತದೆ. ನೀವು ಕೇವಲ JSON ಡೇಟಾವನ್ನು ಪೈಥಾನ್ ವೇರಿಯೇಬಲ್‌ಗೆ ಬರೆಯಿರಿ, ಆಮದು ನಿರ್ದೇಶನದೊಂದಿಗೆ ಮುನ್ನುಡಿ ಮಾಡಿ ಮತ್ತು ಫೈಲ್‌ನ ಕೊನೆಯಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮೂರು ಸಾಲುಗಳನ್ನು ಸೇರಿಸಿ.

#!/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

ಈಗ ನಾವು ಈ ಫೈಲ್ ಅನ್ನು ಪೈಥಾನ್‌ನಲ್ಲಿ ರನ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು 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 ನಿಮಗೆ ಎಚ್ಚರಿಕೆ ನೀಡುತ್ತದೆ -. ಸರಿ, ಇದನ್ನು ಸುಲಭವಾಗಿ ಕೈಯಾರೆ ಸರಿಪಡಿಸಬಹುದು ಅಥವಾ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸ್ವಲ್ಪ ಮಾರ್ಪಡಿಸಬಹುದು.

ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಮೂಲಕ ಪರಿವರ್ತನೆ

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಮೊದಲು JSON ನಲ್ಲಿ ಬರೆಯುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಪರಿವರ್ತಕವನ್ನು ಪ್ರತ್ಯೇಕ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಆಗಿ ರನ್ ಮಾಡುತ್ತೇವೆ, ಅದು YAML ಅನ್ನು ಔಟ್‌ಪುಟ್ ಆಗಿ ಉತ್ಪಾದಿಸುತ್ತದೆ. ಹಿಂದಿನ ವಿಧಾನಕ್ಕೆ ಹೋಲಿಸಿದರೆ, ಈ ವಿಧಾನವು ಉತ್ತಮವಾಗಿದೆ, ಏಕೆಂದರೆ ಪರಿವರ್ತನೆಯು ಡೇಟಾದಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿದೆ.

ಮೊದಲಿಗೆ, JSON ಫೈಲ್ ಅನ್ನು ಉದಾಹರಣೆಗೆ.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 ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಬಳಕೆದಾರ-ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ 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 ಗೆ ಪರಿವರ್ತಿಸಬಹುದು. ನೀವು 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 ಮತ್ತು ವಿಶೇಷಣಗಳನ್ನು (ಸ್ಪೆಕ್ಸ್) ಪುನಃ ಓದಿರಿ. ನೀವು YAML ನೊಂದಿಗೆ ತೊಂದರೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಆದರೆ ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ತಲುಪದಿದ್ದರೆ, ಈ ಪರಿಸ್ಥಿತಿಯನ್ನು ಸರಿಪಡಿಸಲು ಇದು ಸಮಯ. ಸ್ಪೆಕ್ಸ್ ಬರೆಯಲು ಆಶ್ಚರ್ಯಕರವಾಗಿ ಸುಲಭ, ಮತ್ತು ಸಿಂಟ್ಯಾಕ್ಸ್ ಅವಶ್ಯಕತೆಗಳನ್ನು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ವಿವರಿಸಲಾಗಿದೆ ಅಧ್ಯಾಯ 6.

5. ಹುಸಿ ಸಂರಚನೆಗಳು

ಪುಸ್ತಕ ಅಥವಾ ಲೇಖನವನ್ನು ಬರೆಯುವಾಗ, ಮೊದಲು ಪ್ರಾಥಮಿಕ ರೂಪರೇಖೆಯನ್ನು ಸ್ಕೆಚ್ ಮಾಡುವುದು ಯಾವಾಗಲೂ ಉಪಯುಕ್ತವಾಗಿದೆ, ಕನಿಷ್ಠ ವಿಷಯಗಳ ಕೋಷ್ಟಕದ ರೂಪದಲ್ಲಿ. ಇದು YAML ನಂತೆಯೇ ಇರುತ್ತದೆ. ಹೆಚ್ಚಾಗಿ, YAML ಫೈಲ್‌ಗೆ ಯಾವ ಡೇಟಾವನ್ನು ಬರೆಯಬೇಕು ಎಂಬ ಕಲ್ಪನೆಯನ್ನು ನೀವು ಹೊಂದಿದ್ದೀರಿ, ಆದರೆ ಅದನ್ನು ಪರಸ್ಪರ ಹೇಗೆ ಸಂಪರ್ಕಿಸುವುದು ಎಂದು ನಿಮಗೆ ನಿಜವಾಗಿಯೂ ಅರ್ಥವಾಗುತ್ತಿಲ್ಲ. ಆದ್ದರಿಂದ, YAML ಅನ್ನು ಕೆತ್ತಿಸುವ ಮೊದಲು, ಹುಸಿ ಸಂರಚನೆಯನ್ನು ಎಳೆಯಿರಿ.

ಹುಸಿ-ಸಂರಚನೆಯು ಹುಸಿ-ಕೋಡ್ ಅನ್ನು ಹೋಲುತ್ತದೆ, ಅಲ್ಲಿ ನೀವು ರಚನೆ ಅಥವಾ ಇಂಡೆಂಟೇಶನ್, ಪೋಷಕ-ಮಕ್ಕಳ ಸಂಬಂಧಗಳು, ಆನುವಂಶಿಕತೆ ಮತ್ತು ಗೂಡುಕಟ್ಟುವ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಕಾಗಿಲ್ಲ. ಇದು ಇಲ್ಲಿ ಒಂದೇ ಆಗಿರುತ್ತದೆ: ನಿಮ್ಮ ತಲೆಯಲ್ಲಿ ಉದ್ಭವಿಸುವ ಡೇಟಾದ ಪುನರಾವರ್ತನೆಗಳನ್ನು ನೀವು ಸೆಳೆಯುತ್ತೀರಿ.

ಸ್ಯೂಡೋ-ಕಾನ್ಫಿಗ್ ಲಿಸ್ಟಿಂಗ್ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು (ಮಾರ್ಟಿನ್ ಮತ್ತು ತಬಿತಾ) ಮತ್ತು ಅವರ ಕೌಶಲ್ಯಗಳು (ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು: ಪೈಥಾನ್, ಪರ್ಲ್, ಪ್ಯಾಸ್ಕಲ್ ಮತ್ತು ಲಿಸ್ಪ್, ಫೋರ್ಟ್ರಾನ್, ಎರ್ಲಾಂಗ್, ಕ್ರಮವಾಗಿ).

ಕಾಗದದ ತುಂಡು ಮೇಲೆ ಹುಸಿ ಸಂರಚನೆಯನ್ನು ಚಿತ್ರಿಸಿದ ನಂತರ, ಅದನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ವಿಶ್ಲೇಷಿಸಿ ಮತ್ತು ಎಲ್ಲವೂ ಕ್ರಮದಲ್ಲಿದ್ದರೆ, ಅದನ್ನು ಮಾನ್ಯವಾದ YAML ಫೈಲ್ ರೂಪದಲ್ಲಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿ.

6. ಟ್ಯಾಬ್‌ಗಳು ವರ್ಸಸ್ ಸ್ಪೇಸ್‌ಗಳ ಸಂದಿಗ್ಧತೆ

ನೀವು ಸಂದಿಗ್ಧತೆಯನ್ನು ಪರಿಹರಿಸಬೇಕಾಗಿದೆ "ಟ್ಯಾಬ್ಗಳು ಅಥವಾ ಸ್ಥಳಗಳು?". ಜಾಗತಿಕ ಅರ್ಥದಲ್ಲಿ ಅಲ್ಲ, ಆದರೆ ನಿಮ್ಮ ಸಂಸ್ಥೆಯ ಮಟ್ಟದಲ್ಲಿ ಅಥವಾ ಕನಿಷ್ಠ ಯೋಜನೆಯಲ್ಲಿ ಮಾತ್ರ. ಇದು ಸೆಡ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಪೋಸ್ಟ್-ಪ್ರೊಸೆಸಿಂಗ್ ಅನ್ನು ಬಳಸುವುದು, ಪ್ರೋಗ್ರಾಮರ್‌ಗಳ ಯಂತ್ರಗಳಲ್ಲಿ ಪಠ್ಯ ಸಂಪಾದಕಗಳನ್ನು ಹೊಂದಿಸುವುದು ಅಥವಾ ವಜಾಗೊಳಿಸುವ ಬೆದರಿಕೆಯ ಅಡಿಯಲ್ಲಿ ಲಿಂಟರ್‌ನ ಸೂಚನೆಗಳೊಂದಿಗೆ ಕಟ್ಟುನಿಟ್ಟಾದ ಅನುಸರಣೆಯ ರಶೀದಿಗಳನ್ನು ಸಾರ್ವತ್ರಿಕವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಆದರೆ ನಿಮ್ಮ ತಂಡದ ಎಲ್ಲಾ ಸದಸ್ಯರು YAML ಗೆ ಸಂಬಂಧಿಸಿದ ಒಂದು ರೀತಿಯಲ್ಲಿ ಅಥವಾ ಇನ್ನೊಂದು ಸ್ಥಳವನ್ನು ಮಾತ್ರ ಬಳಸಬೇಕು (YAML ನಿರ್ದಿಷ್ಟತೆಯ ಅಗತ್ಯವಿರುವಂತೆ).

ಯಾವುದೇ ಸಾಮಾನ್ಯ ಪಠ್ಯ ಸಂಪಾದಕದಲ್ಲಿ, ನೀವು ಸ್ವಯಂ-ಸರಿಪಡಿಸುವ ಟ್ಯಾಬ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಸ್ಥಳಗಳಿಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು, ಆದ್ದರಿಂದ ಪ್ರಮುಖ ಅನುಯಾಯಿಗಳ ದಂಗೆ ಟ್ಯಾಬ್ ನೀವು ಭಯಪಡಬೇಕಾಗಿಲ್ಲ.

ಪ್ರತಿ YAML ದ್ವೇಷಿಯು ಚೆನ್ನಾಗಿ ತಿಳಿದಿರುವಂತೆ, ಪರದೆಯ ಮೇಲೆ ಟ್ಯಾಬ್‌ಗಳು ಮತ್ತು ಸ್ಥಳಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ನೀವು ನೋಡಲಾಗುವುದಿಲ್ಲ. ಮತ್ತು ಏನಾದರೂ ಗೋಚರಿಸದಿದ್ದಾಗ, ಇತರ ಸಂಭವನೀಯ ಸಮಸ್ಯೆಗಳನ್ನು ಅವರು ವಿಂಗಡಿಸಿದ ನಂತರ, ಪರಿಶೀಲಿಸಿದ ಮತ್ತು ತೆಗೆದುಹಾಕಿದ ನಂತರ ಜನರು ಸಾಮಾನ್ಯವಾಗಿ ಕೊನೆಯದಾಗಿ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ. ಟ್ಯಾಬ್ಯುಲೇಶನ್ ಕರ್ವ್ ಅಥವಾ ಸ್ಪೇಸ್‌ಗಳ ಬ್ಲಾಕ್ ಅನ್ನು ಹುಡುಕಲು ಕಳೆದ ಒಂದು ಗಂಟೆಯ ಸಮಯವನ್ನು ನೀವು ತುರ್ತಾಗಿ ಒಂದು ಅಥವಾ ಇನ್ನೊಂದರ ಬಳಕೆಗಾಗಿ ನೀತಿಯನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ ಎಂದು ಕಿರುಚುತ್ತದೆ, ತದನಂತರ ಅದರ ಅನುಸರಣೆಗಾಗಿ ಬಲವರ್ಧಿತ ಕಾಂಕ್ರೀಟ್ ಪರಿಶೀಲನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ (ಉದಾಹರಣೆಗೆ, ಮೂಲಕ ಒಂದು ಲಿಂಟರ್ ಮೂಲಕ ಅದನ್ನು ಒತ್ತಾಯಿಸಲು Git ಹುಕ್).

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 ವಿವರಣೆಯ ಪ್ರಕಾರ ಅದನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ಕಡಿಮೆ ಮಾಡಿ. ಉದಾಹರಣೆಗೆ, ಅನ್ಸಿಬಲ್ ದಸ್ತಾವೇಜನ್ನು ಮೇಲಿನ ಫೈಲ್ ಅನ್ನು ಯಾವುದೇ ನಷ್ಟವಿಲ್ಲದೆ ಈ ರೀತಿ ಪುನಃ ಬರೆಯಬಹುದು:

---
- 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 ಅನ್ನು ಬೇರೆ ಸ್ವರೂಪಕ್ಕೆ ಬದಲಾಯಿಸುವುದು ಯೋಗ್ಯವಾಗಿರುತ್ತದೆ. ಕಾಲಾನಂತರದಲ್ಲಿ, ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳು ತಾವಾಗಿಯೇ ಬೆಳೆಯಬಹುದು ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ಲುವಾ ಅಥವಾ ಪೈಥಾನ್‌ನಲ್ಲಿ ಸರಳ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುವುದು ಉತ್ತಮ.

YAML ಅದರ ಕನಿಷ್ಠೀಯತೆ ಮತ್ತು ಸರಳತೆಗಾಗಿ ಅನೇಕ ಜನರು ಇಷ್ಟಪಡುವ ಒಂದು ದೊಡ್ಡ ವಿಷಯವಾಗಿದೆ, ಆದರೆ ಇದು ನಿಮ್ಮ ಆರ್ಸೆನಲ್‌ನಲ್ಲಿರುವ ಏಕೈಕ ಸಾಧನದಿಂದ ದೂರವಿದೆ. ಆದ್ದರಿಂದ ಕೆಲವೊಮ್ಮೆ ನೀವು ಅದನ್ನು ನಿರಾಕರಿಸಬಹುದು. YAML ಗಾಗಿ ಪಾರ್ಸಿಂಗ್ ಲೈಬ್ರರಿಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಸುಲಭ, ಆದ್ದರಿಂದ ನೀವು ಸುಲಭವಾದ ವಲಸೆ ಆಯ್ಕೆಗಳನ್ನು ನೀಡಿದರೆ, ನಿಮ್ಮ ಬಳಕೆದಾರರು ಈ ವೈಫಲ್ಯವನ್ನು ತುಲನಾತ್ಮಕವಾಗಿ ನೋವುರಹಿತವಾಗಿ ಬದುಕುತ್ತಾರೆ.

YAML ಇಲ್ಲದೆ ನಿಮಗೆ ಮಾಡಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ, ಈ 10 ಸಲಹೆಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ ಮತ್ತು YAML ನ ನಿಮ್ಮ ಇಷ್ಟವಿಲ್ಲದಿರುವಿಕೆಯನ್ನು ಒಮ್ಮೆ ಮತ್ತು ಎಲ್ಲರಿಗೂ ನಿವಾರಿಸಿ!

ಮೂಲ: www.habr.com