YAML జెన్‌కి 10 మెట్లు

మనమందరం అన్సిబుల్‌ని ప్రేమిస్తాము, కానీ అన్సిబుల్ అనేది YAML. కాన్ఫిగరేషన్ ఫైల్‌ల కోసం అనేక ఫార్మాట్‌లు ఉన్నాయి: విలువల జాబితాలు, పారామీటర్-విలువ జతలు, INI ఫైల్‌లు, YAML, JSON, XML మరియు అనేక ఇతరాలు. అయినప్పటికీ, అన్నింటిలో అనేక కారణాల వల్ల, YAML తరచుగా చాలా కష్టంగా పరిగణించబడుతుంది. ప్రత్యేకించి, దాని రిఫ్రెష్ మినిమలిజం మరియు క్రమానుగత విలువలతో పనిచేయడానికి ఆకట్టుకునే సామర్థ్యాలు ఉన్నప్పటికీ, YAML సింటాక్స్ ఇండెంటేషన్‌కి దాని పైథాన్-వంటి విధానంతో బాధించేది.

YAML మీకు కోపం తెప్పిస్తే, మీరు చేయవచ్చు-మరియు మీరు చేయాలి! - మీ నిరాశను ఆమోదయోగ్యమైన స్థాయికి తగ్గించడానికి మరియు YAMLతో ప్రేమలో పడేందుకు క్రింది 10 దశలను అనుసరించండి. ఈ జాబితాకు తగినట్లుగా, మా పది చిట్కాలు మొదటి నుండి లెక్కించబడతాయి, మేము ధ్యానం మరియు ఆధ్యాత్మిక అభ్యాసాలను ఇష్టానుసారం జోడిస్తాము 😉

0. మీ ఎడిటర్ పని చేసేలా చేయండి

మీరు ఏ టెక్స్ట్ ఎడిటర్‌ని కలిగి ఉన్నారనేది పట్టింపు లేదు, YAMLతో పని చేయడానికి కనీసం ఒక ప్లగిన్ అయినా ఉండవచ్చు. మీకు ఒకటి లేకుంటే, వెంటనే దాన్ని కనుగొని ఇన్‌స్టాల్ చేయండి. మీరు YAMLని సవరించాల్సిన ప్రతిసారి శోధించడం మరియు సెటప్ చేయడం కోసం వెచ్చించిన సమయం చాలా రెట్లు చెల్లించబడుతుంది.

ఉదాహరణకు, ఎడిటర్ ఆటమ్ డిఫాల్ట్‌గా YAMLకి మద్దతు ఇస్తుంది, కానీ GNU Emacs కోసం మీరు అదనపు ప్యాకేజీలను ఇన్‌స్టాల్ చేయాలి, ఉదాహరణకు, యమల్-మోడ్.

YAML మోడ్‌లో Emacs మరియు ఖాళీలను ప్రదర్శిస్తోంది.

మీకు ఇష్టమైన ఎడిటర్‌కు YAML మోడ్ లేకపోతే, సెట్టింగ్‌లతో పని చేయడం ద్వారా కొన్ని సమస్యలను పరిష్కరించవచ్చు. ఉదాహరణకు, ప్రామాణిక GNOME టెక్స్ట్ ఎడిటర్ Geditకు YAML మోడ్ లేదు, కానీ డిఫాల్ట్‌గా ఇది YAML సింటాక్స్‌ను హైలైట్ చేస్తుంది మరియు ఇండెంటేషన్‌లతో పనిని కాన్ఫిగర్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది:

Geditలో ఇండెంట్లను సెట్ చేస్తోంది.

ఒక ప్లగ్ఇన్ డ్రా ఖాళీలు Gedit కోసం, ఖాళీలను చుక్కలుగా ప్రదర్శిస్తుంది, ఇండెంటేషన్ స్థాయిలతో అస్పష్టతలను తొలగిస్తుంది.

మరో మాటలో చెప్పాలంటే, మీకు ఇష్టమైన ఎడిటర్ గురించి తెలుసుకోవడానికి సమయాన్ని వెచ్చించండి. YAMLతో పని చేయడానికి అతను లేదా అతని డెవలప్‌మెంట్ కమ్యూనిటీ ఏమి ఆఫర్ చేస్తుందో కనుగొని, ఆ లక్షణాలను ఉపయోగించండి. మీరు ఖచ్చితంగా చింతించరు.

1. ఒక లిన్టర్ ఉపయోగించండి

ఆదర్శవంతంగా, ప్రోగ్రామింగ్ భాషలు మరియు మార్కప్ భాషలు ఊహాజనిత వాక్యనిర్మాణాన్ని ఉపయోగిస్తాయి. కంప్యూటర్లు ప్రెడిక్టబిలిటీలో మంచివి, అందుకే భావన లింటెరా. దాని ఉనికి యొక్క 40 సంవత్సరాలలో అది మిమ్మల్ని దాటిపోయి ఉంటే మరియు మీరు ఇప్పటికీ YAML లిన్టర్‌ను ఉపయోగించకపోతే, యమ్‌లింట్‌ని ప్రయత్నించడానికి ఇది సమయం.

ఏర్పాటు యమ్లింట్ మీరు ప్రామాణిక Linux ప్యాకేజీ నిర్వాహికిని ఉపయోగించవచ్చు. ఉదాహరణకు, లో Red Hat Enterprise Linux 8 లేదా Fedora ఇది ఇలా జరిగింది:

$ 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 ఫైల్ 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 పైథాన్ మాడ్యూల్‌లను దిగుమతి చేస్తుంది మరియు వినియోగదారు పేర్కొన్న JSON ఫైల్‌ను లోడ్ చేస్తుంది, మార్పిడిని చేస్తుంది మరియు అవుట్‌పుట్.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 స్పెసిఫికేషన్ ప్రకారం సాధ్యమైనంత తక్కువగా ఉంచండి. ఉదాహరణకు, 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ని వేరే ఫార్మాట్‌కి మార్చడం విలువైనదే కావచ్చు. కాలక్రమేణా, కాన్ఫిగరేషన్ ఫైల్‌లు తమను తాము అధిగమించగలవు మరియు వాటిని లువా లేదా పైథాన్‌లో సాధారణ స్క్రిప్ట్‌లుగా మార్చడం మంచిది.

YAML అనేది దాని మినిమలిజం మరియు సరళత కోసం చాలా మంది ఇష్టపడే గొప్ప విషయం, కానీ ఇది మీ ఆయుధశాలలోని ఏకైక సాధనానికి దూరంగా ఉంది. కాబట్టి కొన్నిసార్లు మీరు దానిని తిరస్కరించవచ్చు. పార్సింగ్ లైబ్రరీలను YAML కోసం సులభంగా కనుగొనవచ్చు, కాబట్టి మీరు సులభమైన మైగ్రేషన్ ఎంపికలను అందిస్తే, మీ వినియోగదారులు ఈ వైఫల్యాన్ని సాపేక్షంగా నొప్పిలేకుండా తప్పించుకుంటారు.

మీరు YAML లేకుండా చేయలేకపోతే, ఈ 10 చిట్కాలను తీసుకోండి మరియు YAML పట్ల మీకున్న అయిష్టతను ఒక్కసారి అధిగమించండి!

మూలం: www.habr.com