JSON Patch உருவாக்கி
இரண்டு JSON ஆவணங்களை ஒப்பிட்டு, முதலாவதை இரண்டாவதாக மாற்றும் RFC 6902 ஒட்டைப் பெறுங்கள். அனைத்தும் உங்கள் உலாவியில் இயங்குகிறது.
இந்தக் கருவி செய்வது என்ன
இது இரண்டு JSON ஆவணங்களை ஒப்பிட்டு, முதலாவதை இரண்டாவதாக மாற்றும் செயல்களின் பட்டியலை RFC 6902 வரையறுத்த வடிவத்தில் எழுதுகிறது. ஒரு புலம் மாறிவிட்டது எனச் சொல்ல முழு ஆவணத்தையும் அனுப்புவதற்குப் பதிலாக, மாற்றத்தையே அனுப்புகிறீர்கள்.
எப்போது பயன்படும்
PATCH கோரிக்கையின் உடலை உருவாக்க, ஓர் அமைவுக் கோப்பின் இரு பதிப்புகளுக்கு இடையே என்ன மாறியது என்பதைப் பதிவு செய்ய, அல்லது ஒவ்வொரு முழு நகலையும் வைத்திருப்பதைவிட மிகச் சிறிய தணிக்கைப் பதிவை வைக்க. ஒரே மாதிரித் தோன்றும் இரு ஆவணங்களுக்கு இடையே உண்மையில் என்ன வேறுபாடு என்பதை விரைவாக அறியவும் இது உதவும்.
இது உருவாக்கும் செயல்கள்
| செயல் | அதன் பொருள் |
|---|---|
| add | மதிப்பே இல்லாத இடத்தில் ஒரு மதிப்பைச் சேர்க்கிறது, அல்லது ஓர் அணியில் நுழைக்கிறது. |
| remove | அந்த இடத்தில் உள்ள மதிப்பை நீக்குகிறது. |
| replace | ஏற்கெனவே உள்ள ஓர் இடத்தின் மதிப்பை மேலெழுதுகிறது. |
| move | ஒரு மதிப்பை ஓர் இடத்திலிருந்து இன்னோர் இடத்திற்கு நகர்த்துகிறது. |
| copy | ஒரு மதிப்பை இன்னோர் இடத்திற்கு நகலெடுக்கிறது. |
| test | ஒரு மதிப்பைச் சரிபார்த்து, பொருந்தவில்லை என்றால் ஒட்டு முழுவதையும் கைவிடுகிறது. |
இந்தக் கருவி add, remove, replace ஆகியவற்றை மட்டுமே எழுதுகிறது. இந்த மூன்றும் எந்த மாற்றத்தையும் வெளிப்படுத்தப் போதுமானவை; வரிக்கு வரி படிக்கக்கூடிய ஒட்டு, யோசித்துப் புரிந்துகொள்ள வேண்டிய சுருக்கமான ஒட்டைவிட மதிப்புமிக்கது. மற்ற மூன்றும் RFC 6902-இன் பகுதியே; விதிகளைப் பின்பற்றும் எந்தச் சேவையகமும் அவற்றை ஏற்கும்.
பாதைகள் எப்படி இயங்குகின்றன
ஒவ்வொரு பாதையும் ஒரு JSON Pointer (RFC 6901): ஆவணத்தின் வேரிலிருந்து சாய்வுக்கோடுகளால் பிரிக்கப்பட்ட வழி; “/address/zipCode” என்பது address-க்குள் உள்ள zipCode புலத்தைக் குறிக்கிறது. அணியின் இடங்கள் எண்களாக இருப்பதால் “/skills/0” முதல் உறுப்பு; கோடு அணியின் முடிவைக் குறிக்கிறது: “/skills/-” இறுதியில் சேர்க்கிறது. சாய்வுக்கோடே பிரிப்பான் என்பதால், சாய்வுக்கோடு கொண்ட விசை ~1 எனவும், உண்மையான டில்டு ~0 எனவும் எழுதப்படும்.
வெளியீடு குறித்த குறிப்புகள்
ஒப்பீடு அப்படியே நடக்கிறது: மதிப்புகள் இடத்துக்கு இடம் ஒப்பிடப்படுகின்றன, எனவே ஓர் அணியின் தொடக்கத்தில் ஓர் உறுப்பைச் சேர்த்தால் ஒரே நுழைப்புக்குப் பதிலாக அதற்குப் பின் வரும் ஒவ்வொரு உறுப்புக்கும் replace உருவாகும். நிலையான அடையாளங்கள் கொண்ட பொருள்களின் அணிகளுக்கு, அடையாளங்களிலிருந்து உருவாக்கப்பட்ட ஒட்டு இடங்களிலிருந்து உருவாக்கப்பட்டதைவிட எப்போதும் சிறியதாகவே இருக்கும்.
JSON Patch-ஐ எப்படி உருவாக்குவது
இரண்டு JSON ஆவணங்களை ஒட்டி ஒட்டை உருவாக்குங்கள்.
- மூல JSON-ஐ இடதுபுறம் ஒட்டுங்கள்.
- மாற்றப்பட்ட JSON-ஐ வலதுபுறம் ஒட்டுங்கள்.
- உருவாக்கு என்பதை அழுத்தி, ஒட்டை நகலெடுங்கள்.
அடிக்கடி கேட்கப்படும் கேள்விகள்
இந்தக் கருவி என் தரவை எங்காவது அனுப்புகிறதா?
இல்லை. இரு ஆவணங்களும் உங்கள் உலாவியிலேயே இருக்கின்றன; ஒட்டு உங்கள் சொந்தக் கணினியில் உருவாக்கப்படுகிறது.
வெளியீடு RFC 6902-க்கு இணங்குகிறதா?
ஆம். ஒவ்வொரு செயலும் op, path கொண்ட ஒரு பொருள்; add, replace-க்கு value-ம் உண்டு. பாதைகள் RFC 6901 வரையறுக்கும் JSON Pointer-களே.
move, copy செயல்கள் இதில் உள்ளனவா?
இல்லை. இது add, remove, replace ஆகியவற்றை எழுதுகிறது; இவை எந்த மாற்றத்திற்கும் போதுமானவை, படிப்பதற்கும் மிக எளிதானவை. ஒரு move என்பது remove-ஐத் தொடர்ந்து வரும் add மட்டுமே.
ஒட்டை எப்படிப் பயன்படுத்துவது?
application/json-patch+json-ஐ ஏற்கும் API-க்கு அனுப்புங்கள், அல்லது ஒரு நூலகத்தைப் பயன்படுத்துங்கள்: பைத்தானில் jsonpatch, ஜாவாஸ்கிரிப்ட்டில் json-patch, .NET-இல் JsonPatchDocument, ஜாவாவில் json-patch, இப்படியே.
JSON Merge Patch-இலிருந்து என்ன வேறுபாடு?
JSON Merge Patch (RFC 7386) ஆவணத்தைப் போலவே தோற்றமளிக்கிறது; அதில் null என்பது “நீக்கு” எனப் பொருள்படும். இதனால் படிப்பதற்கு எளிது, ஆனால் உண்மையான null-ஐச் சேமிக்கவோ அணியின் ஒரே ஓர் உறுப்பை மாற்றவோ முடியாது. JSON Patch நீளமானது, ஆனால் எதையும் வெளிப்படுத்த வல்லது.
Wikipedia — JSON Patch
Wikipedia — JSON
Wikipedia — Patch (computing)
Wikipedia — Diff
Wikipedia — REST