👩‍👦 🤵🏼 👨🏿‍💻 सिद्धांत के बजाय सिद्धांत: सीमांत डेवलपर्स के रूप में बेहतर हो रहा है 🐁 👩‍👧‍👧 🙆🏿

उत्तराधिकार के बजाय बुनियादी बातों का उपयोग करते हुए एक बेहतर फ्रंट-एंड डेवलपर बनना

हमारा अनुभव बताता है कि गैर-तकनीकी शिक्षक और स्व-शिक्षित लोग अक्सर सैद्धांतिक सिद्धांतों पर नहीं, बल्कि अनुमानी तरीकों पर भरोसा करते हैं।

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

"उपयोग $(document).ready(function(){}) कोड को jQuery साइटों पर आरंभ करने के लिए"
" var self = this कॉलबैक फ़ंक्शन में किसी विधि को कॉल करने के लिए var self = this निर्माण की आवश्यकता होती है"
"एरो फ़ंक्शंस में return नहीं हैं"

उसी समय, सैद्धांतिक सिद्धांत का उपयोग अन्य समस्याओं के समाधान खोजने के लिए किया जा सकता है। वह हमेशा के लिए वफादार है और अक्सर एक या किसी अन्य तत्व के उपकरण को निर्धारित करता है। उदाहरण के लिए सैद्धांतिक सिद्धांत शामिल हैं:

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

एक सैद्धांतिक दृष्टिकोण के लिए तर्क

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

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

इसके अलावा, विधर्मी तरीकों पर भरोसा करते हुए, आप कभी नहीं सीखेंगे कि वास्तविक के लिए समस्याओं को कैसे हल किया जाए। आप अक्सर एक कार्यशील समाधान खोजने का प्रबंधन कर सकते हैं, लेकिन जितनी जल्दी या बाद में आप एक ठहराव के लिए आएंगे, जहां से आपको कोई रास्ता नहीं दिखाई देगा। सी एंड पी प्रोग्रामर अपने काम में उत्तराधिकार पर भरोसा करते हैं।

डेवलपर कौशल स्तर मानदंड

फ्रंटएंड डेवलपर्स का साक्षात्कार करते समय, हम उनके लिए एक प्रोग्रामिंग कार्य निर्धारित करते हैं और कहते हैं कि वे किसी भी स्रोत का उपयोग करने के लिए स्वतंत्र हैं, चाहे वह Google हो या स्टेट ओवरफ्लो। इस तरह, यह निर्धारित करना आसान है कि क्या डेवलपर उत्तराधिकार या सिद्धांत का पालन करता है।

पूर्व, अपवाद के बिना, स्टैक ओवरफ्लो के साथ अधिक या कम उपयुक्त उदाहरणों से प्रतिलिपि कोड। केवल जब कोड योजना के अनुसार काम नहीं करता है तो उन्होंने इसे अपने लिए ठीक करना शुरू कर दिया। अक्सर वे असफल हो जाते हैं।

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

पहले से ही साक्षात्कार के पहले पांच मिनट में आप यह निर्धारित कर सकते हैं कि उम्मीदवार किस प्रकार के प्रोग्रामर हैं।

उदाहरण

उदाहरण के तौर पर बिल को ही लें। उन्होंने कई प्रशिक्षण पाठ्यक्रम पूरे किए, जावास्क्रिप्ट में कई कार्यों को हल किया और अपने खाली समय में वेबसाइटों को लिखा, लेकिन उन्होंने वास्तव में जावास्क्रिप्ट नहीं सीखा।

एक बार बिल एक वस्तु की तरह आता है:

 const usersById = { "5": { "id": "5", "name": "Adam", "registered": true }, "27": { "id": "27", "name": "Bobby", "registered": true }, "32": { "id": "32", "name": "Clarence", "registered": false }, "39": { "id": "39", "name": "Danielle", "registered": true }, "42": { "id": "42", "name": "Ekaterina", "registered": false } }

ऐसी वस्तु उपयोगकर्ताओं की एक सूची प्रदर्शित कर सकती है और क्या उन्होंने किसी विशेष घटना के लिए पंजीकरण किया है।

मान लीजिए कि बिल को पंजीकृत उपयोगकर्ताओं की सूची को पुनः प्राप्त करने की आवश्यकता है। दूसरे शब्दों में, उन्हें फ़िल्टर करें। वह कोड में आया था जिसमें सूची को फ़िल्टर करने के लिए .filter() विधि का उपयोग किया गया था। तो वह कुछ इस तरह की कोशिश करता है:

 const attendees = usersById.filter(user => user.registered);

और यहाँ है कि वह क्या हो जाता है:

 TypeError: usersById.filter is not a function

"कुछ बकवास है," बिल सोचता है, क्योंकि उसने कोड देखा है जिसमें .filter() एक फिल्टर के रूप में काम करता है।

समस्या यह है कि विधेयक विधर्मी पद्धति पर निर्भर है। वह यह नहीं समझता है कि filter सरणियों पर परिभाषित एक विधि है, जबकि usersById एक नियमित ऑब्जेक्ट है जिसमें filter विधि नहीं है।

उलझा हुआ बिल " जावास्क्रिप्ट फ़िल्टर " बताता है। वह सरणियों के कई संदर्भ पाता है और महसूस करता है कि उसे usersById को एक सरणी में बदलने की आवश्यकता है। फिर, " जावास्क्रिप्ट को किसी ऑब्जेक्ट को एक सरणी में बदलने के लिए " पूछकर, वह Object.keys() ओवरफ़्लो पर Object.keys() का उपयोग करके उदाहरणों को Object.keys() । उसके बाद, वह कोशिश करता है:

 const attendees = Object.keys(usersById).filter(user => user.registered);

इस बार त्रुटि प्रदर्शित नहीं की गई है, लेकिन, बिल के आश्चर्य के लिए, attendees क्षेत्र खाली है।

तथ्य यह है कि Object.keys() ऑब्जेक्ट की कुंजी लौटाता है, लेकिन इसका मूल्य नहीं। वास्तव में, user चर नाम आसानी से भ्रामक है, क्योंकि यह एक user वस्तु नहीं है, लेकिन एक पहचानकर्ता, यानी एक स्ट्रिंग है। चूंकि registered विशेषता तार के लिए परिभाषित नहीं है, इसलिए filter प्रत्येक प्रविष्टि को झूठा मानता है और सरणी खाली छोड़ देता है।

बिल स्टैक ओवरफ्लो उत्तरों पर एक करीब से नज़र डालता है और निम्नलिखित परिवर्तन करता है:

 const attendees = Object.keys(usersById).filter(id => usersById[id].registered);

इस बार परिणाम बेहतर है: ["5", "27", "39"] । लेकिन बिल आगंतुक वस्तुओं को प्राप्त करना चाहते थे, न कि उनकी आईडी को।

आगंतुकों को फ़िल्टर करने के तरीके को समझने के लिए, " जावास्क्रिप्ट ऑब्जेक्ट फ़िल्टर " से नाराज बिल खोज, स्टैक ओवरफ्लो के लिए खोज परिणामों की जांच करती है और निम्नलिखित कोड के साथ इस उत्तर को ढूंढती है:

 Object.filter = (obj, predicate) => Object.keys(obj) .filter( key => predicate(obj[key]) ) .reduce( (res, key) => (res[key] = obj[key], res), {} );

बिल इन पंक्तियों को कॉपी करता है और कोशिश करता है:

 const attendees = Object.filter(usersById, user => user.registered);

सब कुछ काम करता है - हालांकि यह स्पष्ट नहीं है कि क्यों। बिल समझ में नहीं आता है कि reduce आवश्यकता क्यों reduce और इसका उपयोग कैसे किया जाता है। इसके अलावा, बिल यह नहीं समझता है कि उसने वैश्विक Object लिए एक नए गैर-मानक तरीके को परिभाषित किया है।

लेकिन बिल का ध्यान नहीं है - यह काम करता है! परिणाम उसके लिए अभी तक हित के नहीं हैं।

बिल ने क्या गलत किया?

विधेयक ने समस्या को हल करने के लिए एक विधर्मी तरीका आजमाया और निम्नलिखित समस्याओं में भाग गया:

एक चर पर .filter() का उपयोग करते हुए, बिल को एक .filter() मिला। वह यह नहीं समझ पाया कि filter साधारण वस्तुओं पर परिभाषित नहीं है।
उन्होंने Object.keys() का उपयोग "ऑब्जेक्ट को एक सरणी में बदलने के लिए" किया, लेकिन यह अकेले कोई परिणाम नहीं लाया। उसे ऑब्जेक्ट वैल्यू की एक सरणी बनाने की आवश्यकता थी।
मूल्यों को प्राप्त करने और फ़िल्टर करने के लिए एक शर्त के रूप में उपयोग करने के बाद भी, उन्हें इन पहचानकर्ताओं से जुड़े उपयोगकर्ता ऑब्जेक्ट के बजाय केवल पहचानकर्ता प्राप्त हुए। ऐसा इसलिए है क्योंकि फ़िल्टर की गई सरणी में एक ID होती है, उपयोगकर्ता ऑब्जेक्ट नहीं।
समय के साथ, बिल ने इस दृष्टिकोण को छोड़ दिया और इंटरनेट पर काम करने का हल ढूंढ लिया। फिर भी, वह अभी भी यह नहीं समझ पाया कि यह कैसे काम करता है - और इसे हल करने में समय बर्बाद नहीं करेगा, क्योंकि उसके पास करने के लिए अन्य चीजें हैं।

यह एक कृत्रिम उदाहरण है, लेकिन हम कई बार डेवलपर्स के सामने आए हैं जो एक ही तरीके से समस्याओं को हल करते हैं। उन्हें प्रभावी ढंग से हल करने के लिए, आपको विधर्मी तरीकों से दूर जाने और सिद्धांत का अध्ययन करने की आवश्यकता है।

आइए बुनियादी बातों पर आगे बढ़ें

यदि बिल एक सैद्धांतिक दृष्टिकोण का प्रस्तावक था, तो प्रक्रिया इस तरह दिखाई देगी:

दिए गए इनपुट डेटा की पहचान करने और वांछित आउटपुट का निर्धारण करने के लिए - उनके गुणों के अर्थ में: “मेरे पास एक ऑब्जेक्ट है जिसकी कुंजी आईडी का प्रतिनिधित्व करने वाले तार हैं, और मान उपयोगकर्ताओं का प्रतिनिधित्व करने वाले ऑब्जेक्ट हैं। मैं एक ऐसा सरणी प्राप्त करना चाहता हूं, जिसके मूल्य उपयोगकर्ता ऑब्जेक्ट होंगे - लेकिन केवल पंजीकृत उपयोगकर्ताओं की वस्तुएं "
किसी वस्तु के अंदर खोज करने के तरीके को समझने के लिए: “मुझे पता है कि मुझे Object.keys() कॉल करके किसी ऑब्जेक्ट में कुंजियों की एक सरणी मिल सकती है। मैं एक सरणी प्राप्त करना चाहता हूं क्योंकि सरणियाँ गणन का समर्थन करती हैं । "
यह महसूस करने के लिए कि यह विधि कुंजियों को प्राप्त करने में मदद करती है, और आपको कुंजियों को मूल्यों में बदलने की जरूरत है, और map बारे में याद रखें - एक और सरणी के मूल्यों को बदलकर एक नई सरणी बनाने की एक स्पष्ट विधि:
```
 Object.keys(usersById).map(id => usersById[id]) 
```
यह देखने के लिए कि आपके पास अब उपयोगकर्ता ऑब्जेक्ट की एक सरणी है जिसे फ़िल्टर किया जा सकता है और जिसमें वास्तविक मान हैं जिन्हें आप फ़िल्टर करना चाहते हैं:
```
 Object.keys(usersById).map(id => usersById[id]).filter(user => user.registered) 
```

इस तरह से बिल जाओ, वह हमारे लिए काम कर सकता है।

लोग अधिक बार सिद्धांत का सहारा क्यों नहीं लेते हैं?

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

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

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