निर्माण और निर्माण कैसे करें

प्रागितिहास

जावास्क्रिप्ट विकास में कई स्थानों पर उन स्थितियों के साथ मुलाकात की गई जहां मूल्यों को मान्य करना आवश्यक था, यह स्पष्ट हो गया कि किसी भी तरह इस मुद्दे को हल करना आवश्यक था। इस कार्य के लिए, निम्नलिखित कार्य निर्धारित किया गया था:
एक पुस्तकालय विकसित करें जो सक्षम करेगा:

• मान्य डेटा प्रकार ;
• अमान्य फ़ील्ड या तत्वों के बजाय डिफ़ॉल्ट मान सेट करें;
• किसी वस्तु या सरणी के अमान्य भागों को हटाना ;
• एक त्रुटि संदेश प्राप्त करें

जिसका आधार होगा:

• सीखना आसान है
• प्राप्त कोड की पठनीयता।
• कोड संशोधन में आसानी

इन लक्ष्यों को प्राप्त करने के लिए, एक चौकड़ी मान्यता पुस्तकालय विकसित किया गया है।

मूल मान्यता ईंटें

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

सत्यापनकर्ता

चौकड़ी पुस्तकालय एक सत्यापनकर्ता की अवधारणा पर आधारित है। इस लाइब्रेरी में सत्यापनकर्ता निम्नलिखित फॉर्म के कार्य हैं

function validator( value: any, { key: string|int, parent: any }, { key: string|int, parent: any }, ... ): boolean 

इस परिभाषा में कई बातें हैं जिन्हें अधिक विस्तार से वर्णित किया जाना चाहिए:

function(...): boolean - कहता है कि सत्यापनकर्ता - सत्यापन के परिणाम की गणना करता है, और सत्यापन का परिणाम एक बुलियन मूल्य है - सही या गलत , क्रमशः मान्य या मान्य नहीं

value: any - इंगित करता है कि सत्यापनकर्ता - एक मूल्य को मान्य करने के परिणाम की गणना करता है, जो किसी भी जावास्क्रिप्ट मूल्य हो सकता है। सत्यापनकर्ता या तो मान्य मूल्य को वैध या अमान्य बताता है।

{ key: string|int, parent: any }, ... - इंगित करता है कि वैल्यूड नेस्टिंग करने के स्तर के आधार पर वेरिफाइड वैल्यू अलग-अलग संदर्भों में हो सकती है। आइए इसे उदाहरणों के साथ दिखाएं

बिना किसी संदर्भ के उदाहरण मूल्य

 const value = 4; //         . //         : const isValueValid = validator(4) 

एक सरणी संदर्भ में उदाहरण मूल्य

 //  0 1 2 3 4 const arr = [1, 2, 3, value, 5] //       (k): 3 //      : [1, 2, 3, value, 5] //    value -      const isValueValid = validator(4, { key: 3, parent: [1,2,3,4,5] }) 

किसी वस्तु के संदर्भ में उदाहरण मूल्य

 const obj = { a: 1, b: 2, c: value, d: 8 } //        'c' //       : { a: 1, b: 2, c: 4, d: 8 } //    value -   //   : const isValueValid = validator(4, { key: 'c', parent: { a: 1, b: 2, c: 4, d: 8 } }) 

चूंकि किसी ऑब्जेक्ट में संरचनाओं में अधिक से अधिक घोंसले के शिकार हो सकते हैं, यह विभिन्न संदर्भों के बारे में बात करने के लिए समझ में आता है

 const arrOfObj = [{ a: 1, b: 2, c: value, d: 8 }, // ... ] //   c     'c' //    : { a: 1, b: 2, c: 4, d: 8 } //        arrOfObj, //       0. //    value -      const isValueValid = validator( 4, { key: 'c', parent: { a: 1, b: 2, c: 4, d: 8 } } { key: 0, parent: [{ a: 1, b: 2, c: 4, d: 8 }] } ) 

और इसी तरह।

हमें क्या घर बनाना चाहिए?

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

ऑब्जेक्ट सत्यापन के गगनचुंबी इमारत का निर्माण कैसे करें?

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

 //    quartet const quartet = require('quartet') //    (v -  validator) const v = quartet() //      , //     const objectSchema = { a: a => typeof a ==='string', //   'string' b: b => typeof b === 'number', //   'number' // ... } const compositeObjValidator = v(objectSchema) const obj = { a: 'some text', b: 2 } const isObjValid = compositeObjValidator(obj) console.log(isObjValid) // => true 

जैसा कि आप देख सकते हैं, विशिष्ट क्षेत्रों के लिए परिभाषित विभिन्न सत्यापनकर्ता ईंटों से, हम एक वस्तु सत्यापनकर्ता को इकट्ठा कर सकते हैं - कुछ "छोटी इमारत" जिसमें यह अभी भी काफी तंग है - लेकिन इसके बिना बेहतर है। इसके लिए, हम सत्यापनकर्ताओं v के कंपोजर का उपयोग करते हैं। हर बार, सत्यापनकर्ता के स्थान पर ऑब्जेक्ट शाब्दिक v को पूरा करते हुए, इसे एक वस्तु रचना के रूप में माना जाएगा, इसे अपने क्षेत्रों में एक वस्तु सत्यापनकर्ता में बदल देगा।

कभी-कभी हम सभी क्षेत्रों का वर्णन नहीं कर सकते हैं । उदाहरण के लिए, जब कोई वस्तु डेटा डिक्शनरी होती है:

 const quartet = require('quartet') const v = quartet() const isStringValidator = name => typeof name === 'string' const keyValueValidator = (value, { key }) => value.length === 1 && key.length === 1 const dictionarySchema= { dictionaryName: isStringValidator, ...v.rest(keyValueValidator) } const compositeObjValidator = v(dictionarySchema) const obj = { dictionaryName: 'next letter', b: 'c', c: 'd' } const isObjValid = compositeObjValidator(obj) console.log(isObjValid) // => true const obj2 = { dictionaryName: 'next letter', b: 'a', a: 'invalid value', notValidKey: 'a' } const isObj2Valid = compositeObjValidator(obj2) console.log(isObj2Valid) // => false 

निर्माण समाधान का पुन: उपयोग कैसे करें?

जैसा कि हमने ऊपर देखा, सरल सत्यापनकर्ताओं का पुन: उपयोग करने की आवश्यकता है। इन उदाहरणों में, हमें पहले से ही "स्ट्रिंग प्रकार के सत्यापनकर्ता" का दो बार पहले ही उपयोग करना था।

रिकॉर्ड को छोटा करने और इसकी पठनीयता बढ़ाने के लिए, चौकड़ी पुस्तकालय सत्यापनकर्ताओं के स्ट्रिंग समानार्थी शब्द का उपयोग करता है। जब भी एक सत्यापनकर्ता संगीतकार उस स्थान पर एक स्ट्रिंग का सामना करता है जहां सत्यापनकर्ता होना चाहिए, तो यह अपने सत्यापनकर्ता के लिए शब्दकोश खोजता है और इसका उपयोग करता है ।

डिफ़ॉल्ट रूप से, सबसे आम सत्यापनकर्ता पहले से ही पुस्तकालय में परिभाषित हैं।

निम्नलिखित उदाहरणों पर विचार करें:

 v('number')(1) // => true v('number')('1') // => false v('string')('1') // => true v('string')(null) // => false v('null')(null) // => true v('object')(null) // => true v('object!')(null) // => false // ... 

और प्रलेखन में वर्णित कई अन्य।

प्रत्येक आर्क में ईंटों का अपना प्रकार होता है?

सत्यापनकर्ता संगीतकार (फ़ंक्शन v ) भी एक सत्यापनकर्ता कारखाना है। इस अर्थ में कि इसमें कई उपयोगी विधियां शामिल हैं जो वापस आती हैं

• फ़ंक्शन सत्यापनकर्ता
• वैल्यूज़ बनाने के लिए कंपोज़र योजनाओं के रूप में जो मानेंगे, वे मान

उदाहरण के लिए, हम सरणी सत्यापन को देखते हैं: बहुधा इसमें सरणी के प्रकार की जाँच करना और उसके सभी तत्वों की जाँच करना शामिल है। हम इसके लिए v.arrayOf(elementValidator) विधि का उपयोग करेंगे। उदाहरण के लिए, नामों के साथ एक सरणी लें।

  const a = [ {x: 1, y: 1, name: 'A'}, {x: 2, y: 1, name: 'B'}, {x: -1, y: 2, name: 'C'}, {x: 1, y: 3, name: 'D'}, ] 

चूंकि अंकों का एक सरणी वस्तुओं का एक सरणी है, इसलिए यह सरणी के तत्वों को मान्य करने के लिए ऑब्जेक्ट रचना का उपयोग करने के लिए समझ में आता है।

 const namedPointSchema = { x: 'number', // number -       y: 'number', name: 'string' // string -       } 

अब, फैक्ट्री मेथड v.arrayOf का उपयोग करते हुए, पूरे ऐरे के लिए एक v.arrayOf बनाएँ

 const isArrayValid = v.arrayOf({ x: 'number', y: 'number', name: 'string' }) 

आइए देखें कि यह सत्यापनकर्ता कैसे काम करता है:

 isArrayValid(0) // => false isArrayValid(null) // => false isArrayValid([]) // => true isArrayValid([1, 2, 3]) // => false isArrayValid([ {x: 1, y: 1, name: 'A'}, {x: 2, y: 1, name: 'B'}, {x: -1, y: 2, name: 'C'}, {x: 1, y: 3, name: 'D'}, ]) // => true 

यह कारखाने के तरीकों में से एक है, जिनमें से प्रत्येक को प्रलेखन में वर्णित किया गया है।

जैसा कि आपने ऊपर देखा, v.rest भी एक फैक्ट्री मेथड है जो ऑब्जेक्ट v.rest लौटाता है जो ऑब्जेक्ट v.rest निर्दिष्ट सभी फील्ड्स को चेक करता है। इसका मतलब है कि इसे spread-operator का उपयोग करके किसी अन्य ऑब्जेक्ट रचना में एम्बेड किया जा सकता है।

आइए हम उदाहरण के रूप में उनमें से कई का उपयोग करते हैं:

 //    quartet const quartet = require('quartet') //    (v -  validator) const v = quartet() //   ,    const max = { name: 'Maxim', sex: 'male', age: 34, status: 'grandpa', friends: [ { name: 'Dima', friendDuration: '1 year'}, { name: 'Semen', friendDuration: '3 months'} ], workExperience: 2 } //  ,   "" , // ""  , ""   -  const nameSchema = v.and( 'not-empty', 'string', //   name => name[0].toUpperCase() === name[0] // - ) const maxSchema = { name: nameSchema, //       sex: v.enum('male', 'female'), //  -   . //       "" age: v.and('non-negative', 'safe-integer'), status: v.enum('grandpa', 'non-grandpa'), friends: v.arrayOf({ name: nameSchema, //      friendDuration: v.regex(/^[1-9]\d? (years?|months?)$/) }), workExperience: v.and('non-negative', 'safe-integer') } console.log(v(maxSchema)(max)) // => true 

होना है, या नहीं होना है?

अक्सर ऐसा होता है कि वैध डेटा विभिन्न रूप लेता है, उदाहरण के लिए:

• id एक संख्या हो सकती है, या यह एक स्ट्रिंग हो सकती है।
• आयाम के आधार पर point वस्तु में कुछ निर्देशांक हो सकते हैं या नहीं भी हो सकते हैं।
• और कई अन्य मामले।

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

पहचानकर्ता सत्यापन के साथ एक उदाहरण पर विचार करें:

  const isValidId = v([ v.and('not-empty', 'string'), //       v.and('positive', 'safe-integer') //    ]) isValidId('') // => false isValidId('asdba32bas321ab321adb321abds546ba98s7') // => true isValidId(0) // => false isValidId(1) // => true isValidId(1123124) // => true 

बिंदु सत्यापन उदाहरण:

 const isPointValid = v([ { //    -    x  dimension: v.enum(1), x: 'number', // v.rest    false // ,    -  ...v.rest(() => false) }, //   -    { dimension: v.enum(2), x: 'number', y: 'number', ...v.rest(() => false) }, //   - x, y  z { dimension: v.enum(3), x: 'number', y: 'number', z: 'number', ...v.rest(() => false) }, ]) // ,    ,      ,     -  -    isPointValid(1) // => false isPointValid(null) // => false isPointValid({ dimension: 1, x: 2 }) // => true isPointValid({ dimension: 1, x: 2, y: 3 //   }) // => false isPointValid({ dimension: 2, x: 2, y: 3 }) // => true isPointValid({ dimension: 3, x: 2, y: 3, z: 4 }) // => true // ... 

इस प्रकार, जब भी कोई संगीतकार किसी सरणी को देखता है, तो वह इसे इस सरणी के सत्यापनकर्ता तत्वों की एक रचना पर इस तरह से विचार करेगा कि जब उनमें से कोई मान को वैध मानता है, तो सत्यापन की गणना बंद हो जाएगी और मान को मान्य माना जाएगा।

जैसा कि हम देखते हैं, संगीतकार न केवल सत्यापनकर्ता फ़ंक्शन को एक सत्यापनकर्ता मानता है, बल्कि वह सब कुछ भी है जो सत्यापनकर्ता फ़ंक्शन को जन्म दे सकता है।

ये सभी सत्यापनकर्ता विकल्प वैध हैं और स्कीमा के भीतर कहीं भी उपयोग किए जा सकते हैं जहां सत्यापनकर्ता होना चाहिए।

नतीजतन, ऑपरेशन योजना हमेशा इस तरह होती है: v(schema) एक सत्यापन फ़ंक्शन देता है। अगला, यह सत्यापन फ़ंक्शन विशिष्ट मूल्यों पर कहा जाता है:
v(schema)(value[, ...parents])

क्या आपके पास निर्माण स्थल पर कोई दुर्घटना हुई है?

- अभी नहीं, एक नहीं
- वे!

ऐसा होता है कि डेटा अमान्य है और हमें अमान्य का कारण निर्धारित करने में सक्षम होना चाहिए।

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

इन उद्देश्यों के लिए, सत्यापनकर्ता v के संगीतकार के दूसरे तर्क का v । यह अमान्य डेटा के मामले में v.explanation सरणी में व्याख्यात्मक नोट भेजने का साइड इफेक्ट जोड़ता है।

उदाहरण, हमें एक ऐरे को मान्य करते हैं, और उन सभी तत्वों की संख्या का पता लगाना चाहते हैं जो अमान्य हैं और उनका मूल्य है:

  //   -     //   const getExplanation = (value, { key: index }) => ({ invalidValue: value, index }) // ,       . //         v.explanation //    const arrValidator = v.arrayOf( v( 'number', //   getExplanation //   "",   "" ) ) // ,     ""  //     ,     //         //   ,       const explainableArrValidator = v(arrValidator, 'this array is not valid') const arr = [1, 2, 3, 4, '5', '6', 7, '8'] explainableArrValidator(arr) // => false v.explanation // [ // { invalidValue: '5', index: 4 }, // { invalidValue: '6', index: 5 }, // { invalidValue: '8', index: 7 }, // 'this array is not valid' // ] 

जैसा कि आप देख सकते हैं, स्पष्टीकरण का विकल्प कार्य पर निर्भर करता है। कभी-कभी यह आवश्यक भी नहीं होता है।

कभी-कभी हमें अमान्य क्षेत्रों के साथ कुछ करने की आवश्यकता होती है। ऐसे मामलों में, एक स्पष्टीकरण के रूप में अमान्य क्षेत्र के नाम का उपयोग करना समझ में आता है:

 const objSchema = { a: v('number', 'a'), b: v('number', 'b'), c: v('string', 'c') } const isObjValid = v(objSchema) let invalidObj = { a: 1, b: '1', c: 3 } isObjValid(invalidObj) // => false v.explanation // ['b', 'c'] //     console.error(`${v.explanation.join(', ')} is not valid`) // => b, c is not valid //       (. ) invalidObj = v.omitInvalidProps(objSchema)(invalidObj) console.log(invalidObj) // => { a: 1 } 

स्पष्टीकरण के इस तंत्र के होने पर, आप सत्यापन के परिणामों से जुड़े किसी भी व्यवहार को लागू कर सकते हैं।

एक स्पष्टीकरण कुछ भी हो सकता है:

• आवश्यक जानकारी युक्त एक वस्तु;
• फ़ंक्शन जो त्रुटि को ठीक करता है। ( getExplanation => function(invalid): valid );
• अमान्य फ़ील्ड का नाम, या अमान्य तत्व का सूचकांक;
• त्रुटि कोड
• और वह सब आपकी कल्पना के लिए पर्याप्त है।

जब चीजें नहीं बन रही हों तो क्या करें?

सत्यापन त्रुटियों को ठीक करना एक दुर्लभ कार्य नहीं है। इन उद्देश्यों के लिए, पुस्तकालय एक साइड इफेक्ट के साथ सत्यापनकर्ताओं का उपयोग करता है जो त्रुटि के स्थान को याद रखता है और इसे कैसे ठीक करना है।

• v.default(validator, value) - अमान्य मान को याद रखने वाला सत्यापनकर्ता लौटाता है, और v.fix के समय - डिफ़ॉल्ट मान सेट करता है
• v.filter(validator) - एक v.filter(validator) लौटाता है जो एक अमान्य मान को याद रखता है, और v.fix के समय - माता-पिता से इस मान को निकालता है
• v.addFix(validator, fixFunc) - एक वैध मान लौटाता है जो अमान्य मान को याद रखता है, और v.fix के समय - पैरामीटर (मान, {key, parent}, ...) के साथ fixFunc कॉल करता है। fixFunc - मूल्य को बदलने के लिए - भागीदारों में से एक को बदलना होगा

 const toPositive = (negativeValue, { key, parent }) => { parent[key] = -negativeValue } const objSchema = { a: v.default('number', 1), b: v.filter('string', ''), c: v.default('array', []), d: v.default('number', invalidValue => Number(invalidValue)), //    pos: v.and( v.default('number', 0), //     -  0 v.addFix('non-negative', toPositive) //     -   ) } const invalidObj = { a: 1, b: 2, c: 3, d: '4', pos: -3 } v.resetExplanation() //   v() v(objSchema)(invalidObj) // => false // v.hasFixes() => true const validObj = v.fix(invalidObj) console.log(validObj) // => { a: 1, b: '', c: [], d: 4 } 

काम अभी भी काम में आते हैं

इस पुस्तकालय में सत्यापन कार्यों के लिए उपयोगिता विधियाँ भी हैं:

परिणाम

कार्यों को निम्नलिखित तरीकों से हल किया गया था:

अंतभाषण

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