एक ही कोड को कई बार लिखने पर दो दिन कैसे बिताएं इसकी कहानी।

प्रविष्टि

इस लेख में, मैं हापी, जॉय के बारे में विवरण छोड़ देता हूं, रूटिंग और validate: { payload: ... } , यह अर्थ देते हुए कि आप पहले से ही समझते हैं कि यह क्या है, साथ ही साथ शब्दावली, एक ला "इंटरफेस", "प्रकार" और जैसे । मैं आपको केवल एक टर्न-आधारित के बारे में बताता हूं, न कि सबसे सफल रणनीति, इन चीजों में मेरा प्रशिक्षण।

थोड़ी पृष्ठभूमि

अब मैं परियोजना पर केवल बैकेंड डेवलपर (अर्थात्, कोड लिखना) हूं। कार्यक्षमता सार नहीं है, लेकिन मुख्य सार व्यक्तिगत डेटा के साथ एक लंबा प्रोफ़ाइल है। कोड की गति और गुणवत्ता स्क्रैच से परियोजनाओं पर स्वतंत्र रूप से काम करने के मेरे छोटे अनुभव पर आधारित है, यहां तक ​​कि जेएस (केवल 4 वें महीने) के साथ काम करने का कम अनुभव, और साथ ही, बहुत टेढ़े-मेढ़े तरीके से, मैं टाइपस्क्रिप्ट (इसके बाद: टीएस) में लिखता हूं। तिथियां संकुचित हैं, रोल संपीड़ित हैं, संपादन लगातार आ रहे हैं और यह पहले व्यापार तर्क कोड लिखने के लिए निकलता है, और फिर ऊपर से इंटरफेस। फिर भी, एक तकनीकी कर्तव्य कैप को पकड़ने और दोहन करने में सक्षम है, जो लगभग, हमारे साथ हुआ है।

परियोजना पर 3 महीने के काम के बाद, मैं आखिरकार अपने सहयोगियों के साथ एक ही शब्दकोष पर स्विच करने के लिए सहमत हो गया, ताकि ऑब्जेक्ट के गुणों का नाम दिया जाए और हर जगह समान लिखा जाए। इस व्यवसाय के तहत, निश्चित रूप से, मैंने एक इंटरफ़ेस लिखने का बीड़ा उठाया और दो व्यावसायिक दिनों के लिए इसके साथ मजबूती से फंस गया।

समस्या

एक साधारण उपयोगकर्ता प्रोफाइल एक अमूर्त उदाहरण होगा।

• पहले एक अच्छे डेवलपर का शून्य कदम: डेटा का वर्णन करें परीक्षण लिखें;
• पहला कदम: परीक्षण लिखें डेटा का वर्णन करें
• और इसी तरह।

मान लीजिए कि इस कोड के लिए परीक्षण पहले ही लिखे जा चुके हैं, यह डेटा का वर्णन करने के लिए बना हुआ है:

 interface IUser { name: string; age: number; phone: string | number; } const aleg: IUser = { name: 'Aleg', age: 45, phone: '79001231212' }; 

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

 const joiUserValidator = { name: Joi.string(), age: Joi.number(), phone: Joi.alternatives([Joi.string(), Joi.number()]) }; 

"माथे पर" समाधान तैयार है। इस दृष्टिकोण का स्पष्ट माइनस यह है कि सत्यापनकर्ता इंटरफ़ेस से पूरी तरह से तलाकशुदा है। यदि आवेदन के जीवन के दौरान फ़ील्ड बदलते हैं / उनके प्रकार बदलते हैं, तो इस परिवर्तन को मैन्युअल रूप से ट्रैक करने और सत्यापनकर्ता में इंगित करने की आवश्यकता होगी। मुझे लगता है कि कुछ गिरने तक ऐसे जिम्मेदार डेवलपर्स नहीं होंगे। इसके अलावा, हमारी परियोजना में प्रश्नावली में घोंसले के तीन स्तरों पर 50+ क्षेत्र होते हैं और इसे समझना बहुत मुश्किल है, यहां तक ​​कि दिल से सब कुछ जानते हुए भी।

हम केवल const joiUserValidator: IUser निर्दिष्ट नहीं कर सकते हैं, क्योंकि Joi अपने डेटा प्रकारों का उपयोग करता है, जो टाइप करते समय त्रुटियों को उत्पन्न करता है Type 'NumberSchema' is not assignable to type 'number' । लेकिन इंटरफ़ेस पर सत्यापन करने का एक तरीका होना चाहिए?

शायद मैंने इसे सही ढंग से Google नहीं किया है, या खराब तरीके से उत्तरों का अध्ययन किया है, लेकिन सभी निर्णय extractTypes और कुछ प्रकार की भयंकर साइकिलों के लिए नीचे आए, जैसे:

 type ValidatedValueType<T extends joi.Schema> = T extends joi.StringSchema ? string : T extends joi.NumberSchema ? number : T extends joi.BooleanSchema ? boolean : T extends joi.ObjectSchema ? ValidatedObjectType<T> : /* ... more schemata ... */ never; 

निर्णय

तृतीय-पक्ष पुस्तकालयों का उपयोग करें

क्यों नहीं? जब मैंने अपने कार्य के बारे में लोगों से पूछा, तो मुझे एक उत्तर मिला, और बाद में, और यहाँ, टिप्पणियों में ( keenondrums के लिए धन्यवाद), इन पुस्तकालयों के लिंक:
https://github.com/typestack/class-validator
https://github.com/typestack/class-transformer

हालांकि, टीएस के काम को बेहतर तरीके से समझने के लिए, इसे स्वयं समझने का प्रयास किया गया था, और इस समस्या को हल करने के लिए कुछ भी आग्रह नहीं किया गया था।

सभी गुण प्राप्त करें

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

 interface IUser { name: string; age: number; phone: string | number; } type UserKeys<T> = { [key in keyof T]; } const evan: UserKeys<IUser> = { name: 'Evan', age: 32, phone: 791234567890 }; const joiUser: UserKeys<IUser> = { name: Joi.string(), age: Joi.number(), phone: Joi.alternatives([Joi.string(), Joi.number()]) }; 

TypeScript बल्कि मुश्किल और रहस्यमय परिस्थितियों में, आपको उदाहरण के लिए, इंटरफ़ेस से कुंजियों को प्राप्त करने की अनुमति देता है, जैसे कि यह एक सामान्य जेएस ऑब्जेक्ट था, हालांकि, केवल type निर्माण में और key in keyof T माध्यम से और केवल जेनरिक के माध्यम से। UserKeys प्रकार के परिणामस्वरूप, इंटरफ़ेस को लागू करने वाली सभी वस्तुओं में गुणों का समान सेट होना चाहिए, लेकिन मानों के प्रकार मनमाने ढंग से हो सकते हैं। इसमें आईडीई में संकेत शामिल हैं, लेकिन फिर भी मूल्यों के प्रकारों का स्पष्ट संकेत नहीं देता है।

यहां एक और दिलचस्प मामला है जिसका मैं उपयोग नहीं कर सका। शायद आप मुझे बता सकते हैं कि यह क्यों आवश्यक है (हालांकि मैं आंशिक रूप से अनुमान लगाता हूं, पर्याप्त लागू उदाहरण नहीं है):

 interface IUser { name: string; age: number; phone: string | number; } interface IUserJoi { name: Joi.StringSchema, age: Joi.NumberSchema, phone: Joi.AlternativesSchema } type UserKeys<T> = { [key in keyof T]: T[key]; } const evan: UserKeys<IUser> = { name: 'Evan', age: 32, phone: 791234567890 }; const userJoiValidator: UserKeys<IUserJoi> = { name: Joi.string(), age: Joi.number(), phone: Joi.alternatives([Joi.string(), Joi.number()]) }; 

परिवर्तनशील प्रकारों का उपयोग करें

आप स्पष्ट रूप से प्रकार सेट कर सकते हैं, और "OR" का उपयोग कर सकते हैं और गुणों को निकाल सकते हैं, स्थानीय रूप से काम कर रहे कोड प्राप्त कर सकते हैं:

 type TString = string | Joi.StringSchema; type TNumber = number | Joi.NumberSchema; type TStdAlter = TString | TNumber; type TAlter = TStdAlter | Joi.AlternativesSchema; export interface IUser { name: TString; age: TNumber; phone: TAlter; } type UserKeys<T> = { [key in keyof T]; } const olex: UserKeys<IUser> = { name: 'Olex', age: 67, phone: '79998887766' }; const joiUser: UserKeys<IUser> = { name: Joi.string(), age: Joi.number(), phone: Joi.alternatives([Joi.string(), Joi.number()]) }; 

इस कोड की समस्या तब प्रकट होती है जब हम किसी मान्य ऑब्जेक्ट को चुनना चाहते हैं, उदाहरण के लिए, डेटाबेस से, अर्थात, TS को पहले से पता नहीं है कि डेटा किस प्रकार का होगा - सरल या जोई। जब number रूप में अपेक्षित फ़ील्ड पर गणितीय कार्य करने का प्रयास करते समय यह त्रुटि हो सकती है:

 const someUser: IUser = getUserFromDB({ name: 'Aleg' }); const someWeirdMath = someUser.age % 10; // error TS2362: The left-hand side of an arithmetic operation must be of type'any', 'number', 'bigint' or an enum type 

यह त्रुटि Joi.NumberSchema से आती है क्योंकि उम्र केवल number नहीं हो सकती है। वे किस लिए लड़े और भागे।

एक में दो समाधान मिलाएं?

इस बिंदु पर कहीं, कार्य दिवस अपने तार्किक निष्कर्ष के करीब पहुंच रहा था। मैंने एक सांस ली, कॉफी पी ली और कमबख्त चुदाई को मिटा दिया। यह आपके इंटरनेट को कम पढ़ने के लिए आवश्यक है! समय आ गया एक बन्दूक ले लो और poraskinut दिमाग:

1. एक वस्तु को स्पष्ट मूल्य प्रकारों के साथ बनाया जाना चाहिए;
2. आप एकल इंटरफ़ेस में प्रकार फेंकने के लिए जेनरिक का उपयोग कर सकते हैं;
3. सामान्य समर्थन डिफ़ॉल्ट प्रकार;
4. type निर्माण स्पष्ट रूप से कुछ और करने में सक्षम है।

हम सामान्य प्रकार के साथ सामान्य इंटरफ़ेस लिखते हैं:

 interface IUser < TName = string, TAge = number, TAlt = string | number > { name: TName; age: TAge; phone: TAlt; } 

जोई के लिए, आप एक दूसरा इंटरफ़ेस बना सकते हैं, जो इस तरह से मुख्य है:

 interface IUserJoi extends IUser < Joi.StringSchema, Joi.NumberSchema, Joi.AlternativesSchema > {} 

पर्याप्त अच्छा नहीं है, क्योंकि अगले डेवलपर हल्के दिल या बदतर के साथ IUserJoi विस्तार कर सकते हैं। समान व्यवहार प्राप्त करने के लिए एक अधिक सीमित विकल्प है:

 type IUserJoi = IUser<Joi.StringSchema, Joi.NumberSchema, Joi.AlternativesSchema>; 

हम कोशिश करते हैं:

 const aleg: IUser = { name: 'Aleg', age: 45, phone: '79001231212' }; const joiUser: IUserJoi = { name: Joi.string(), age: Joi.number(), phone: Joi.alternatives([Joi.string(), Joi.number()]) }; 

युपीडी:
Joi.object में रैप करने के लिए Joi.object मुझे Joi.object से लड़ना पड़ा और सबसे सरल उपाय यही था। मुझे लगता है कि यह एक महत्वपूर्ण धारणा नहीं है, क्योंकि उपरोक्त वस्तु अभी भी इंटरफ़ेस पर है।

 const joiUserInfo = { info: Joi.object(joiUser as any).required() }; 

यह संकलन करता है, उपयोग की जगह पर साफ-सुथरा दिखता है, और विशेष परिस्थितियों के अभाव में हमेशा डिफ़ॉल्ट प्रकार सेट करता है! सौंदर्य ...

... मैंने दो कार्यदिवस क्या बिताए

सारांश

इस सब से क्या निष्कर्ष निकाला जा सकता है:

1. जाहिर है, मैंने यह नहीं सीखा कि प्रश्नों के उत्तर कैसे खोजे जाएँ। निश्चित रूप से, एक सफल अनुरोध के साथ, यह समाधान (या इससे भी बेहतर) खोज इंजन के पहले 5k लिंक में है;
2. गतिशील से स्थिर सोच पर स्विच करना इतना आसान नहीं है, बहुत बार मैं ऐसे झुंड पर सिर्फ हथौड़ा चलाता हूं;
3. जेनरिक शांत हैं। हेब्रा और स्टैकओवरफ़्लो पर भरा हुआ है साइकिलों की गैर-स्पष्ट समाधान मजबूत टाइपिंग के निर्माण के लिए ... रनटाइम के बाहर।

हमने क्या जीता:

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

नैतिक: अनुभव अनमोल है, बाकी के लिए, एक विश्व मानचित्र है।

आप अंतिम परिणाम देख सकते हैं, छू सकते हैं, भाग सकते हैं:
https://repl.it/@Melodyn/Joi-by-interface