Travajs के साथ नक़्क़ाशी डेटा

अपनी पिछली पोस्ट में, मैंने एक और ओपनसोर्स लाइब्रेरी विकसित करते समय मुख्य बिंदुओं का वर्णन किया। मैं एक और बात का उल्लेख करना भूल गया: यदि आप किसी को पुस्तकालय के बारे में नहीं बताते हैं, चाहे वह कुछ भी हो, सबसे अधिक संभावना है कि कोई भी इसके बारे में नहीं जानता होगा।

इसलिए, परियोजना के लाभ के लिए trava.js - रसदार सत्यापन को पूरा करें। वैसे, हम छह महीने से अधिक समय से घास का उपयोग कर रहे हैं, और मुझे लगा कि इसका उपयोग करने के लाभों के बारे में आपको बताने का समय आ गया है। पहले से ही सूख गया है, इसलिए अपनी सांस पकड़ो। और आगे बढ़ो।

संकल्पना

पहली नज़र में, ऐसा लगता है कि सत्यापन एक तुच्छ विषय है जिसे विशेष ध्यान देने की आवश्यकता नहीं है। मान या तो सत्य है या नहीं, जो सरल हो सकता है:

function validate (value) { // any checking... if (!check(value)) return false; return true; } 

लेकिन आमतौर पर यह जानना अच्छा होगा कि वास्तव में क्या गलत हुआ:

 function validate (value) { if (!check1(value)) return 'ERROR_1'; if (!check2(value)) return 'ERROR_2'; } 

वास्तव में यह सब है, समस्या हल हो गई है।

यदि एक के लिए नहीं "लेकिन"

वास्तविक अनुप्रयोगों को विकसित करने के अनुभव से, यह देखा गया कि मामला सत्यापन के साथ समाप्त नहीं होता है। आमतौर पर, इस डेटा को एक विशिष्ट प्रारूप में बदलने की आवश्यकता होती है, जो किसी कारण से बॉक्स से बाहर धारावाहिक द्वारा समर्थित नहीं है, उदाहरण के लिए, दिनांक, सेट, या अन्य कस्टम डेटा प्रकार। यह देखते हुए कि यह मुख्य रूप से JSON है, व्यवहार में यह पता चला है कि आपको सत्यापन और परिवर्तन के दौरान इनपुट डेटा संरचना के माध्यम से एक डबल पास करना होगा। विचार आया, क्यों न इन दोनों अवस्थाओं को एक में मिला दिया जाए। एक संभावित प्लस भी एक स्पष्ट घोषणात्मक डेटा स्कीमा की उपस्थिति होगी।

किसी विशिष्ट प्रारूप में किसी मान को परिवर्तित करने के लिए, सत्यापनकर्ता को न केवल एक त्रुटि, बल्कि एक कम मूल्य वापस करने में सक्षम होना चाहिए। जेएस की दुनिया में, कई इंटरफ़ेस विकल्प संभावित त्रुटि रिटर्न के साथ काफी सामान्य हैं।

1. संभवतः सबसे आम है [त्रुटि, डेटा] टपल की वापसी:
   
   

    function validate (value) { if (!check1(value)) return ['ERROR_1']; if (!check2(value)) return ['ERROR_2']; return [null, value]; } 

   
   एक समान विकल्प भी है जहां कोई सरणी वापस नहीं की जाती है, लेकिन {त्रुटि, डेटा} ऑब्जेक्ट, लेकिन कोई मूलभूत अंतर नहीं हैं। इस दृष्टिकोण का लाभ स्पष्टता है, माइनस यह है कि अब हर जगह आपको इस अनुबंध को बनाए रखने की आवश्यकता है। सत्यापन के लिए, यह असुविधा का कारण नहीं बनता है, लेकिन परिवर्तनों के लिए यह स्पष्ट रूप से शानदार है।
   
2. अपवादों का उपयोग करें। हालांकि मेरी राय में एक सत्यापन त्रुटि आवेदन में एक मानक स्थिति है, कुछ भी असाधारण नहीं है। ईमानदारी से, मुझे लगता है कि अपवाद केवल सबसे अच्छा उपयोग किया जाता है जहां कुछ वास्तव में गलत हो गया है। इसके अलावा, अपवादों को आकस्मिक रूप से सत्यापनकर्ताओं में स्वयं कहा जा सकता है, और फिर आप यह बिल्कुल नहीं जानते होंगे कि यह कोड में एक त्रुटि थी, और मूल्य में नहीं। दृष्टिकोण का लाभ इंटरफ़ेस का सरलीकरण है - अब हमेशा सामान्य तरीके से मूल्य वापस किया जाता है, और त्रुटि को अपवाद के रूप में फेंक दिया जाता है।
   
3. वैश्विक चर में त्रुटि डालने का विकल्प है। लेकिन मैं राज्य को अनावश्यक रूप से नहीं खींचूंगा।
   
4. त्रुटियों के लिए एक अलग प्रकार का उपयोग करें। यह अपवादों के साथ विकल्प की तरह दिखता है, यदि आप उनसे त्रुटि का प्रकार लेते हैं, लेकिन इसे फेंक न दें।
   
   

    function validate (value) { if (!check1(value)) return new Trava.ValidationError({ code: 401 }); if (!check2(value)) return new Trava.ValidationError({ code: 405 }); return parseOrTransform(value); // apply some parse or transform } 

   
   

मैं बाद वाले विकल्प पर बस गया, हालांकि यह भी एक समझौता है, लेकिन कुल मिलाकर बुरा नहीं है। Trava.ValidationError को त्रुटि के लिए एक प्रकार के रूप में प्रस्तावित किया गया है, जो मानक त्रुटि से विरासत में मिला है और एक त्रुटि की रिपोर्ट करने के लिए एक मनमाना डेटा प्रकार का उपयोग करने की क्षमता को जोड़ता है। Trava.ValidationError का उपयोग करना आवश्यक नहीं है, आप मानक त्रुटि का उपयोग कर सकते हैं, लेकिन यह मत भूलो कि तब त्रुटि संदेश केवल तार है।

संक्षेप में, हम कह सकते हैं कि सत्यापनकर्ता एक स्वच्छ, तुल्यकालिक फ़ंक्शन है, जो मूल्य के अतिरिक्त, एक त्रुटि वापस कर सकता है। बेहद सरल। और यह सिद्धांत पुस्तकालयों के बिना अच्छी तरह से काम करता है। व्यवहार में, सत्यापनकर्ताओं को जंजीरों और पदानुक्रमों में जोड़ा जाता है, और यहां घास निश्चित रूप से काम में आएगी।

रचना

संभवत: सत्यापनकर्ताओं के साथ काम करने का सबसे सामान्य मामला रचना है। रचना का कार्यान्वयन अलग हो सकता है। उदाहरण के लिए, प्रसिद्ध जॉय और v8n पुस्तकालयों में, यह एक वस्तु और विधियों की एक श्रृंखला के माध्यम से किया जाता है:

 Joi.string().alphanum().min(0).max(255) 

हालांकि यह पहली नज़र में सुंदर लगता है, इस दृष्टिकोण में कई कमियां हैं, और एक घातक है। और यहाँ बात है। मेरे अनुभव में, एक सत्यापनकर्ता हमेशा एक विशिष्ट अनुप्रयोग के लिए एक चीज़ है, इसलिए पुस्तकालय में मुख्य ध्यान मौजूदा दृष्टिकोण के साथ सत्यापनकर्ताओं और एकीकरण का विस्तार करने की सुविधा पर होना चाहिए, न कि बुनियादी प्राथमिकताओं की संख्या पर, जो, मेरी राय में, केवल पुस्तकालय के लिए वजन है, लेकिन अधिकांश का उपयोग नहीं किया जाएगा। उदाहरण के लिए स्ट्रिंग के लिए समान सत्यापनकर्ता लें। फिर यह पता चला है कि आपको छोरों से रिक्त स्थान को ट्रिम करने की आवश्यकता है, फिर अचानक आपको एक ही मामले में विशेष वर्णों के उपयोग की अनुमति देने की आवश्यकता है, और कहीं न कहीं आपको लोअरकेस आदि का नेतृत्व करने की आवश्यकता है। वास्तव में, इस तरह के कई आदिम हो सकते हैं, और मैं उन्हें पुस्तकालय में जोड़ने के लिए शुरू करने की बात भी नहीं देखता। मेरी राय में, वस्तुओं का उपयोग भी बेमानी है और विस्तार के दौरान जटिलता में वृद्धि की ओर जाता है, हालांकि पहली नज़र में यह जीवन को आसान बनाने के लिए लगता है। उदाहरण के लिए, c joi अपने सत्यापनकर्ता को लिखना इतना आसान नहीं है।

यहां एक कार्यात्मक दृष्टिकोण और घास मदद कर सकती है। 0 से 255 तक की सीमा में निर्दिष्ट संख्या को मान्य करने का एक ही उदाहरण:

 //    const isNumber = n => typeof n == 'number' && !isNaN(n); //  const numberValidator = Trava.Check(isNumber); const byteValidator = Trava.Compose([ numberValidator, Trava.Check(n => 0 <= n && n < 256), ]); byteValidator(-1); // ! 

चेक स्टेटमेंट सत्य जांच (मान => सत्य / असत्य) से बाहर एक सत्यापनकर्ता बनाता है। और वैधीकों को जंजीर बांधो। जब निष्पादित किया जाता है, तो पहली त्रुटि के बाद श्रृंखला बाधित होती है। महत्वपूर्ण बात यह है कि सामान्य कार्यों का उपयोग हर जगह किया जाता है, जो विस्तार और उपयोग करने के लिए बहुत सरल हैं। यह मेरी राय में विस्तार की आसानी है, यह एक मान्य सत्यापन पुस्तकालय की एक प्रमुख विशेषता है।

परंपरागत रूप से, मान्यता में एक अलग जगह पर अशक्त और अपरिभाषित की जाँच करके कब्जा कर लिया जाता है। इसके लिए घास में सहायक संचालक हैं:

 //   null  undefined const requiredNumberValidator = Trava.Required(numberValidator); requiredNumberValidator(undefined); // ! const optNumberValidator = Trava.Optional(numberValidator, 2); // 2 is default optNumberValidator(undefined); // 2 optNumberValidator(null); // null const nullNumberValidator = Trava.Nullable(numberValidator, 3); // 3 is default nullNumberValidator(undefined); // 3 nullNumberValidator(null); // 3 

घास में कई और सहायक सहायक हैं, और वे सभी सुंदर और आश्चर्यजनक रूप से विस्तार करते हैं। सामान्य कार्यों की तरह :)

अनुक्रम

सरल डेटा प्रकार एक पदानुक्रम में व्यवस्थित होते हैं। सबसे सामान्य मामले ऑब्जेक्ट और सरणियाँ हैं। घास में ऐसे ऑपरेटर हैं जो उनके साथ काम करना आसान बनाते हैं:

 //   const byteArrayValidator = Trava.Each(byteValidator); byteArrayValidator([1, -1, 2, -3]); // ValidationError: {"1":"Incorrect value","3":"Incorrect value"} //   const pointValidator = Trava.Keys({ x: numberValidator, y: numberValidator, }); pointValidator({x: 1, y: 'a'}); // ValidationError: {"y":"Incorrect value"} 

वस्तुओं को मान्य करते समय, परिभाषा की गंभीरता पर जोर देने का निर्णय लिया गया था: सभी कुंजी डिफ़ॉल्ट रूप से आवश्यक हैं ( आवश्यक में लिपटे)। सत्यापनकर्ता में निर्दिष्ट कुंजी खारिज नहीं की जाती हैं।

कुछ jsonschema , चतुर्थांश समाधान डेटा के रूप में सत्यापनकर्ताओं का वर्णन करना पसंद करते हैं, उदाहरण के लिए {x: 'नंबर', y: 'नंबर'}, लेकिन यह विस्तार करते समय समान कठिनाइयों की ओर जाता है। इस दृष्टिकोण का एक महत्वपूर्ण लाभ सर्किट के क्रमांकन और विनिमय की संभावना है, जो कार्यों के साथ असंभव है। हालांकि, यह कार्यात्मक इंटरफ़ेस पर आसानी से लागू किया जा सकता है। लाइनों के पीछे कार्यों को छिपाने की आवश्यकता नहीं है! फ़ंक्शंस में पहले से ही नाम हैं और जिनकी ज़रूरत है।

सत्यापनकर्ताओं के अंदर उपयोग में आसानी के लिए, कम्पोज़ और कीज़ ऑपरेटरों को छोड़ा जा सकता है; यह रूट सत्यापनकर्ता को ट्रावा में लपेटने के लिए भी सुविधाजनक है:

 const pointValidator = Trava({ //  -> Keys x: [numberValidator, Trava.Check(v => v > 180)], //  -> Compose y: [numberValidator, Trava.Check(v => v < 180)], }); 

यदि आप दूसरे तर्क के साथ ट्रावा कहते हैं, तो रिटर्न वैल्यू सत्यापनकर्ता को लागू करने का परिणाम होगा:

 const point = Trava({ x: [numberValidator, Trava.Check(v => v > 180)], y: [numberValidator, Trava.Check(v => v < 180)], }, //      { x: 200, y: 100, }); // { x: 200, y: 100 } 

अब तक, समर्थन केवल सरणियों और वस्तुओं के लिए लागू किया गया है, जैसा कि मूल रूप से JSON और वह पर्याप्त जहर है। वेलकम के लिए अनुरोध निवेदन करें!

प्रसंग

अंतिम पैरामीटर के रूप में सत्यापनकर्ता का उपयोग करते समय, आप उस संदर्भ को पारित कर सकते हैं जो अंतिम पैरामीटर के रूप में सभी वैध सत्यापनकर्ताओं से सुलभ होगा। व्यक्तिगत रूप से, यह अवसर अभी तक मेरे लिए काम नहीं आया है, लेकिन यह संभव है।

कुछ सत्यापनकर्ताओं के लिए जो त्रुटि वापस कर सकते हैं, विभिन्न स्तरों पर त्रुटि संदेश को परिभाषित करना संभव है। एक उदाहरण:

 const pos = Trava.Check(v => v > 0); pos(-1); // ValidationError: "Incorrect value" (by default) 

किसी एक मामले के लिए ओवरराइड करें:

 const pos = Trava.Check(v => v > 0, "    "); pos(-1); // ValidationError: "    " 

सभी मामलों के लिए ओवरराइड करें:

 Trava.Check.ErrorMessage = " "; pos(-1); // ValidationError: " " 

इसके अलावा, अधिक विस्तृत कॉन्फ़िगरेशन के लिए, आप त्रुटि के स्थान पर एक फ़ंक्शन स्थानांतरित कर सकते हैं, जिसे एक त्रुटि वापस करनी चाहिए और सत्यापनकर्ता मापदंडों के साथ बुलाया जाएगा।

मामले का उपयोग करें

ज्यादातर हम कोस के साथ बैकसन पर जोंस को जहर देते हैं। सामने वाला भी धीरे-धीरे उठता है। दोनों सिरों पर सामान्य सत्यापनकर्ता होना सुविधाजनक है। और अब मैं लगभग वास्तविक उपयोग का मामला दिखाऊंगा। मान लीजिए कि आप रोगी डेटा बनाने और अद्यतन करने के लिए एक एपीआई लागू करना चाहते हैं।

 // validators.js const trava = require('trava'); const { isFilledString, isDate, isNumber } = require('../common/validators'); const patientSchema = { name: isFilledString, dateOfBirth: isDate, height: isNumber, } //        //      const patientNew = trava(patientSchema); //      const patientPatch = trava(mapValues(patientSchema, trava.Optional)); module.exports = { patientNew, patientPatch, }; // controllers.js const validate = require('./validators'); const { ValidationError } = require('../common/errors'); function create (ctx) { const patientData = validate.patientNew(ctx.request.body); //       Error,             Error if (patientData instanceof Error) return ValidationError(ctx, patientData); // ...create new patient } function update (ctx) { const patientData = validate.patientPatch(ctx.request.body); if (patientData instanceof Error) return ValidationError(ctx, patientData); // ...update patient data } 

हालांकि उदाहरण बहुत सरल है, इसे सरलीकृत नहीं कहा जा सकता है। एक वास्तविक आवेदन में, केवल सत्यापनकर्ता जटिल होंगे। आप मिडलवेयर में सत्यापन भी कर सकते हैं - सत्यापनकर्ता को पूरी तरह से संदर्भ या अनुरोध निकाय पर लागू किया जाता है।

सत्यापन के काम और उपयोग की प्रक्रिया में, हम इस निष्कर्ष पर पहुंचे कि सरल तुल्यकालिक सत्यापनकर्ता और सरल त्रुटि संदेश काफी पर्याप्त हैं। वास्तव में, हम इस निष्कर्ष पर पहुंचे कि हम केवल दो संदेशों का उपयोग करते हैं: "आवश्यक" और "इन्वॉल्व", जो खेतों के लिए संकेत के साथ-साथ सीमा पर स्थानीयकृत हैं। अन्य चेक जिन्हें अतिरिक्त क्रियाओं की आवश्यकता होती है (उदाहरण के लिए, पंजीकरण पर यह जाँचने के लिए कि इस तरह के मेल पहले से मौजूद हैं) सत्यापन के दायरे से बाहर हैं। किसी भी मामले में, घास इस मामले के बारे में नहीं है।

निष्कर्ष में

इस छोटे लेख में, मैंने लाइब्रेरी की लगभग पूरी कार्यक्षमता का वर्णन किया, लेख के दायरे के बाहर कई सहायक हैं जो जीवन को सरल बनाते हैं। मैं github github.com/uNmAnNeR/travajs पर विवरण मांगता हूं।

हमें एक ऐसे उपकरण की आवश्यकता थी, जिसे जितना संभव हो सके अनुकूलित किया जा सके, जिसमें कुछ भी शानदार न हो, लेकिन साथ ही साथ रोजमर्रा के काम के लिए आवश्यक सब कुछ है। और मुझे लगता है कि सामान्य तौर पर यह हासिल किया गया था, मुझे उम्मीद है कि कोई भी जीवन को आसान बना देगा। मैं इच्छाओं और सुझावों के लिए खुश रहूंगा।
स्वास्थ्य के लिए।