YAML Zen ਲਈ 10 ਕਦਮ

ਅਸੀਂ ਸਾਰੇ ਜਵਾਬਦੇਹ ਨੂੰ ਪਿਆਰ ਕਰਦੇ ਹਾਂ, ਪਰ ਜਵਾਬੀ YAML ਹੈ. ਸੰਰਚਨਾ ਫਾਈਲਾਂ ਲਈ ਬਹੁਤ ਸਾਰੇ ਫਾਰਮੈਟ ਹਨ: ਮੁੱਲਾਂ ਦੀਆਂ ਸੂਚੀਆਂ, ਪੈਰਾਮੀਟਰ-ਮੁੱਲ ਜੋੜੇ, INI ਫਾਈਲਾਂ, YAML, JSON, XML ਅਤੇ ਕਈ ਹੋਰ। ਹਾਲਾਂਕਿ, ਇਹਨਾਂ ਸਾਰਿਆਂ ਵਿੱਚੋਂ ਕਈ ਕਾਰਨਾਂ ਕਰਕੇ, YAML ਨੂੰ ਅਕਸਰ ਖਾਸ ਤੌਰ 'ਤੇ ਮੁਸ਼ਕਲ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਲੜੀਵਾਰ ਮੁੱਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਇਸਦੀ ਤਾਜ਼ਗੀ ਭਰਪੂਰ ਘੱਟੋ-ਘੱਟਤਾ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਸਮਰੱਥਾਵਾਂ ਦੇ ਬਾਵਜੂਦ, YAML ਸੰਟੈਕਸ ਇੰਡੈਂਟੇਸ਼ਨ ਲਈ ਇਸਦੇ ਪਾਈਥਨ-ਵਰਗੇ ਪਹੁੰਚ ਨਾਲ ਤੰਗ ਹੋ ਸਕਦਾ ਹੈ।

ਜੇ YAML ਤੁਹਾਨੂੰ ਪਰੇਸ਼ਾਨ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ-ਅਤੇ ਤੁਹਾਨੂੰ ਚਾਹੀਦਾ ਹੈ! - ਆਪਣੀ ਨਿਰਾਸ਼ਾ ਨੂੰ ਸਵੀਕਾਰਯੋਗ ਪੱਧਰ ਤੱਕ ਘਟਾਉਣ ਅਤੇ YAML ਨਾਲ ਪਿਆਰ ਕਰਨ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ 10 ਕਦਮ ਚੁੱਕੋ। ਇਸ ਸੂਚੀ ਦੇ ਅਨੁਕੂਲ ਹੋਣ ਦੇ ਨਾਤੇ, ਸਾਡੇ ਦਸ ਸੁਝਾਵਾਂ ਨੂੰ ਸਕ੍ਰੈਚ ਤੋਂ ਗਿਣਿਆ ਜਾਵੇਗਾ, ਅਸੀਂ ਮਰਜ਼ੀ ਨਾਲ ਧਿਆਨ ਅਤੇ ਅਧਿਆਤਮਿਕ ਅਭਿਆਸਾਂ ਨੂੰ ਜੋੜਾਂਗੇ 😉

0. ਆਪਣੇ ਸੰਪਾਦਕ ਨੂੰ ਕੰਮ ਦਿਓ

ਇਸ ਨਾਲ ਕੋਈ ਫਰਕ ਨਹੀਂ ਪੈਂਦਾ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਕਿਹੜਾ ਟੈਕਸਟ ਐਡੀਟਰ ਹੈ, ਸ਼ਾਇਦ YAML ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਘੱਟੋ ਘੱਟ ਇੱਕ ਪਲੱਗਇਨ ਹੈ. ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਤੁਰੰਤ ਲੱਭੋ ਅਤੇ ਸਥਾਪਿਤ ਕਰੋ। ਤੁਹਾਨੂੰ YAML ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਨ ਲਈ ਹਰ ਵਾਰ ਖੋਜ ਕਰਨ ਅਤੇ ਸਥਾਪਤ ਕਰਨ ਵਿੱਚ ਬਿਤਾਇਆ ਗਿਆ ਸਮਾਂ ਕਈ ਵਾਰ ਭੁਗਤਾਨ ਕਰੇਗਾ।

ਉਦਾਹਰਨ ਲਈ, ਸੰਪਾਦਕ ਐਟਮ ਮੂਲ ਰੂਪ ਵਿੱਚ YAML ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਪਰ GNU Emacs ਲਈ ਤੁਹਾਨੂੰ ਵਾਧੂ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨੇ ਪੈਣਗੇ, ਉਦਾਹਰਨ ਲਈ, yaml-ਮੋਡ.

YAML ਮੋਡ ਅਤੇ ਡਿਸਪਲੇ ਸਪੇਸ ਵਿੱਚ Emacs।

ਜੇਕਰ ਤੁਹਾਡੇ ਮਨਪਸੰਦ ਸੰਪਾਦਕ ਕੋਲ YAML ਮੋਡ ਨਹੀਂ ਹੈ, ਤਾਂ ਸੈਟਿੰਗਾਂ ਨਾਲ ਕੰਮ ਕਰਕੇ ਕੁਝ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਮਿਆਰੀ ਗਨੋਮ ਟੈਕਸਟ ਐਡੀਟਰ Gedit ਕੋਲ YAML ਮੋਡ ਨਹੀਂ ਹੈ, ਪਰ ਮੂਲ ਰੂਪ ਵਿੱਚ ਇਹ YAML ਸੰਟੈਕਸ ਨੂੰ ਉਜਾਗਰ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਇੰਡੈਂਟੇਸ਼ਨਾਂ ਨਾਲ ਕੰਮ ਦੀ ਸੰਰਚਨਾ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ:

ਜੀਐਡਿਟ ਵਿੱਚ ਇੰਡੈਂਟ ਸੈੱਟ ਕਰਨਾ।

ਇੱਕ ਪਲੱਗਇਨ ਡਰਾਅ ਸਪੇਸ ਜੀਐਡਿਟ ਲਈ, ਸਪੇਸ ਨੂੰ ਬਿੰਦੀਆਂ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਇੰਡੈਂਟੇਸ਼ਨ ਪੱਧਰਾਂ ਨਾਲ ਅਸਪਸ਼ਟਤਾ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ।

ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਆਪਣੇ ਮਨਪਸੰਦ ਸੰਪਾਦਕ ਬਾਰੇ ਸਿੱਖਣ ਵਿੱਚ ਸਮਾਂ ਬਿਤਾਓ। ਇਹ ਪਤਾ ਲਗਾਓ ਕਿ ਉਸਨੂੰ ਜਾਂ ਉਸਦੇ ਵਿਕਾਸ ਭਾਈਚਾਰੇ ਨੂੰ YAML ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਕੀ ਪੇਸ਼ਕਸ਼ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਉਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਤੁਹਾਨੂੰ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਇਸ ਦਾ ਪਛਤਾਵਾ ਨਹੀਂ ਹੋਵੇਗਾ।

1. ਲਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰੋ

ਆਦਰਸ਼ਕ ਤੌਰ 'ਤੇ, ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਅਤੇ ਮਾਰਕਅੱਪ ਭਾਸ਼ਾਵਾਂ ਪੂਰਵ ਅਨੁਮਾਨਯੋਗ ਸੰਟੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ। ਕੰਪਿਊਟਰ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਵਿੱਚ ਚੰਗੇ ਹੁੰਦੇ ਹਨ, ਜਿਸ ਕਾਰਨ ਇਹ ਸੰਕਲਪ ਹੈ lintera. ਜੇ ਇਸਦੀ ਹੋਂਦ ਦੇ 40 ਸਾਲਾਂ ਵਿੱਚ ਇਹ ਤੁਹਾਡੇ ਦੁਆਰਾ ਲੰਘ ਗਿਆ ਹੈ ਅਤੇ ਤੁਸੀਂ ਅਜੇ ਵੀ YAML ਲਿੰਟਰ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ yamllint ਨੂੰ ਅਜ਼ਮਾਉਣ ਦਾ ਸਮਾਂ ਹੈ।

ਇੰਸਟਾਲ ਕਰਨ ਲਈ yamllint ਤੁਸੀਂ ਸਟੈਂਡਰਡ ਲੀਨਕਸ ਪੈਕੇਜ ਮੈਨੇਜਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਵਿੱਚ Red Hat Enterprise Linux 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 ਫਾਈਲ 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 ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ। ਮੰਨ ਲਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ 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 ਨਫ਼ਰਤ ਕਰਨ ਵਾਲਾ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਣਦਾ ਹੈ, ਤੁਸੀਂ ਸਕ੍ਰੀਨ 'ਤੇ ਟੈਬਾਂ ਅਤੇ ਸਪੇਸ ਵਿਚਕਾਰ ਅੰਤਰ ਨਹੀਂ ਦੇਖ ਸਕਦੇ ਹੋ। ਅਤੇ ਜਦੋਂ ਕੋਈ ਚੀਜ਼ ਦਿਖਾਈ ਨਹੀਂ ਦਿੰਦੀ ਹੈ, ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਆਖਰੀ ਚੀਜ਼ ਹੁੰਦੀ ਹੈ ਜੋ ਲੋਕ ਯਾਦ ਰੱਖਦੇ ਹਨ, ਜਦੋਂ ਉਹਨਾਂ ਨੇ ਹੋਰ ਸਾਰੀਆਂ ਸੰਭਾਵਿਤ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕੀਤਾ, ਜਾਂਚਿਆ ਅਤੇ ਖਤਮ ਕੀਤਾ. ਇੱਕ ਟੇਬਲੇਸ਼ਨ ਕਰਵ ਜਾਂ ਸਪੇਸ ਦੇ ਇੱਕ ਬਲਾਕ ਦੀ ਖੋਜ ਕਰਨ ਵਿੱਚ ਬਿਤਾਇਆ ਗਿਆ ਸਮਾਂ ਸਿਰਫ਼ ਚੀਕਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਤੁਰੰਤ ਇੱਕ ਜਾਂ ਦੂਜੇ ਦੀ ਵਰਤੋਂ ਲਈ ਇੱਕ ਨੀਤੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ, ਅਤੇ ਫਿਰ ਇਸਦੀ ਪਾਲਣਾ ਲਈ ਇੱਕ ਮਜ਼ਬੂਤ ​​​​ਕੰਕਰੀਟ ਜਾਂਚ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ (ਉਦਾਹਰਨ ਲਈ, ਦੁਆਰਾ ਇੱਕ ਲਿੰਟਰ ਦੁਆਰਾ ਇਸਨੂੰ ਮਜਬੂਰ ਕਰਨ ਲਈ ਇੱਕ ਗਿੱਟ ਹੁੱਕ)।

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