👨🏿‍💼 🆙 👩🏼‍💼 रेल में उन्मुख वस्तु विकास का रहस्य 🈵 🍋 🌹

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

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

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

इसे "ओल्ड सिंपल रूबी ऑब्जेक्ट" कहा जाता है

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

Copy Source | Copy HTML class Post < ActiveRecord::Base def self .as_dictionary dictionary = ( 'A' .. 'Z' ).inject({}) {|h, l| h[l] = []; h} Post .all.each do | p | dictionary[ p .title[ 0 ]] << p end dictionary end end
Copy Source | Copy HTML class Post < ActiveRecord::Base def self .as_dictionary dictionary = ( 'A' .. 'Z' ).inject({}) {|h, l| h[l] = []; h} Post .all.each do | p | dictionary[ p .title[ 0 ]] << p end dictionary end end
Copy Source | Copy HTML class Post < ActiveRecord::Base def self .as_dictionary dictionary = ( 'A' .. 'Z' ).inject({}) {|h, l| h[l] = []; h} Post .all.each do | p | dictionary[ p .title[ 0 ]] << p end dictionary end end
Copy Source | Copy HTML class Post < ActiveRecord::Base def self .as_dictionary dictionary = ( 'A' .. 'Z' ).inject({}) {|h, l| h[l] = []; h} Post .all.each do | p | dictionary[ p .title[ 0 ]] << p end dictionary end end
Copy Source | Copy HTML class Post < ActiveRecord::Base def self .as_dictionary dictionary = ( 'A' .. 'Z' ).inject({}) {|h, l| h[l] = []; h} Post .all.each do | p | dictionary[ p .title[ 0 ]] << p end dictionary end end
Copy Source | Copy HTML class Post < ActiveRecord::Base def self .as_dictionary dictionary = ( 'A' .. 'Z' ).inject({}) {|h, l| h[l] = []; h} Post .all.each do | p | dictionary[ p .title[ 0 ]] << p end dictionary end end
Copy Source | Copy HTML class Post < ActiveRecord::Base def self .as_dictionary dictionary = ( 'A' .. 'Z' ).inject({}) {|h, l| h[l] = []; h} Post .all.each do | p | dictionary[ p .title[ 0 ]] << p end dictionary end end
Copy Source | Copy HTML class Post < ActiveRecord::Base def self .as_dictionary dictionary = ( 'A' .. 'Z' ).inject({}) {|h, l| h[l] = []; h} Post .all.each do | p | dictionary[ p .title[ 0 ]] << p end dictionary end end
Copy Source | Copy HTML class Post < ActiveRecord::Base def self .as_dictionary dictionary = ( 'A' .. 'Z' ).inject({}) {|h, l| h[l] = []; h} Post .all.each do | p | dictionary[ p .title[ 0 ]] << p end dictionary end end
Copy Source | Copy HTML class Post < ActiveRecord::Base def self .as_dictionary dictionary = ( 'A' .. 'Z' ).inject({}) {|h, l| h[l] = []; h} Post .all.each do | p | dictionary[ p .title[ 0 ]] << p end dictionary end end

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

Copy Source | Copy HTML
- Post.as_dEDIA करना | पत्र, सूची |
% प = अक्षर
% उल
- list.each करो | पोस्ट |
% li = link_to पोस्ट

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

Copy Source | Copy HTML
वर्ग शब्दकोश
डीईएफ़ इनिशियलाइज़ (संग्रह)
@ कलेक्शन = संग्रह
अंत
as_dEDIA को हराया
शब्दकोश = ( 'ए' .. 'जेड' ) .inject ({}) {| h, l | h [l] = []; ज}
@ collection.each करते हैं | पी |
शब्दकोश [ p .tlele [ 0 ]] << p
अंत
शब्दकोश
अंत
अंत

अब हम DictionaryPresenter.new (Post.all) .as_dEDIA का उपयोग कर सकते हैं। इसके कई फायदे हैं: हमने प्रस्तुति तर्क को मॉडल से बाहर कर दिया। हमने पहले ही एक नई सुविधा जोड़ी है: किसी भी संग्रह को अब एक पॉइंटर के साथ प्रदर्शित किया जा सकता है। हम आसानी से इस प्रतिनिधि वर्ग के लिए अलग-अलग परीक्षण लिख सकते हैं और वे तेजी से होंगे।

प्रतिनिधि पैटर्न के लिए मेरे प्यार के बावजूद, यह पद उसके बारे में नहीं है। यह सिद्धांत अन्य स्थानों पर भी दिखाई देता है, "यह अवधारणा अपनी कक्षा के योग्य है।" दूसरे उदाहरण पर जाने से पहले, आइए इसे विस्तृत करें: यदि हम अपने पदों को नाम के अनुसार क्रमबद्ध करना चाहते हैं, तो यह वर्ग काम करेगा, लेकिन उपयोगकर्ताओं को दिखाना, कहना असंभव है, क्योंकि उपयोगकर्ताओं के पास शीर्षक (शीर्षक फ़ील्ड) नहीं हैं। इसके अलावा, हम "ए" पर बड़ी संख्या में पोस्ट प्राप्त करेंगे, क्योंकि नाम अक्सर लेख "ए" से शुरू होते हैं, और वास्तव में हमें दूसरे शब्द के पहले अक्षर की आवश्यकता होती है। हम 2 प्रकार के प्रतिनिधि बना सकते हैं, लेकिन फिर हम समुदाय को खो देंगे और एक "इंडेक्स" की अवधारणा फिर से हमारे सिस्टम में 2 प्रतिनिधि होंगे। जैसा कि आपने सही ढंग से समझा: PORO हमें बचाएगा!

आइए नीति प्रतिनिधि को स्वीकार करने के लिए अपने प्रतिनिधि को थोड़ा संशोधित करें:

Copy Source | Copy HTML
वर्ग शब्दकोश
डीईएफ़ इनिशियलाइज़ (नीति, संग्रह)
@ नीति = नीति
@ कलेक्शन = संग्रह
अंत
as_dEDIA को हराया
शब्दकोश = ( 'ए' .. 'जेड' ) .inject ({}) {| h, l | h [l] = []; ज}
@ collection.each करते हैं | पी |
शब्दकोश [@ policy.category_for ( पी )] << पी
अंत
शब्दकोश
अंत
अंत

अब हम नीतियां जोड़ सकते हैं और उन्हें अलग कर सकते हैं:

Copy Source | Copy HTML
उपयोगकर्ता को वर्गीकृत करें
def स्व। category_for (उपयोगकर्ता)
user.username [ 0 ]
अंत
अंत
वर्ग PostCategorizationPolicy
डीफ़ सेल्फ .category_for (पोस्ट)
अगर post.starts_with? ( "A" )
post.title। विभाजन [ १ ] [ ० ]
अन्यथा
पोस्ट। टाइटल [ 0 ]
अंत
अंत
अंत

वैम!

Copy Source | Copy HTML
DictionaryPresenter। नया (PostCategorizationPolicy, Post.all) .as_dEDIA

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

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

Copy Source | Copy HTML
वर्ग भाव < ActiveRecord :: बेस
# <स्निप>
सुंदर_टर्नअर्न को परिभाषित करें
वापसी "" यदि टर्नअराउंड। शून्य ?
अगर खरीदा है
भरपाई = खरीदी हुई
days_from_today = (( समय .now - buy_at.to_time) / 60/60/24) .floor + 1
अन्यथा
ऑफसेट = समय
days_from_today = टर्नअराउंड + 1
अंत
समय = ऑफसेट + (टर्नअराउंड * 60 * 60 * 24 )
अगर (time.strftime ( "% a" ) == "सत" )
समय + = 2 * 60 * 60 * 24
elsif (time.strftime ( "% a" ) == "सूर्य" )
समय + = 1 * 60 * 60 * 24
अंत
"# {time.strftime (" % A% d% B ")} (# {days_from_today} आज से व्यावसायिक दिन)"
अंत
अंत

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

तो, अब इस रीफैक्टरिंग में पहला कदम है, जिसे फेदर ("वर्किंग इफेक्टिवली विद लिगेसी कोड" के लेखक "ब्रेक आउट मेथड ऑब्जेक्ट" कहते हैं। आप पेज 330 पर “वर्किंग इफेक्टिवली विद लिगेसी कोड” की अपनी कॉपी खोल सकते हैं और अधिक पढ़ सकते हैं। यदि आपके पास एक नहीं है, तो :) खरीदें। दरअसल, मैं विचलित हो गया। ये है एक्शन प्लान:
1. एक नया गणना वर्ग बनाएं।
2. इसमें परिभाषित करें एक नए तरीके से काम करने की विधि।
3. पुरानी पद्धति के शरीर को कॉपी करें और ऑब्जेक्ट के साथ पॉइंटर्स के संदर्भों को बदलें।
4. इसके लिए एक कंस्ट्रक्टर बनाएं जो चरण 3 में उपयोग किए गए चर को असाइन करने के लिए तर्क लेता है।
5. पुरानी विधि को नए वर्ग और विधि में बदल दें।

मैंने रूबी के लिए मूल टेम्प्लेट को थोड़ा बदल दिया, क्योंकि हम कंपाइलर (लीन ऑन द कंपाइलर) पर भरोसा नहीं कर सकते हैं और इसके साथ कई कदम फ़ीचर डील करते हैं। वैसे भी, आइए इस कोड पर प्रयास करें। एक कदम:

Copy Source | Copy HTML
वर्ग भाव < ActiveRecord :: बेस
सुंदर_टर्नअर्न को परिभाषित करें
#snip
अंत
क्लास टर्नअराउंड कैक्लकुलर
अंत
अंत

दूसरा:

Copy Source | Copy HTML
क्लास टर्नअराउंड कैक्लकुलर
डीईएफ़ गणना
अंत
अंत

तीसरा:

Copy Source | Copy HTML
क्लास टर्नअराउंड कैक्लकुलर
डीईएफ़ गणना
वापसी अगर " @ पलटा " । शून्य ?
अगर @purchased_at
ऑफसेट = @purchased_at
days_from_today = (( समय .now - buy_at.to_time) / 60/60/24) .floor + 1
अन्यथा
ऑफसेट = समय
days_from_today = @turnaround + 1
अंत
समय = ऑफसेट + (@ पूर्णांक * 60 * 60 * 24 )
अगर (time.strftime ( "% a" ) == "सत" )
समय + = 2 * 60 * 60 * 24
elsif (time.strftime ( "% a" ) == "सूर्य" )
समय + = 1 * 60 * 60 * 24
अंत
"# {time.strftime (" % A% d% B ")} (# {days_from_today} आज से व्यावसायिक दिन)"
अंत
अंत

मुझे शुरुआत में सामान्य नाम देना पसंद है, और फिर चरण 5 में उन्हें बदलने के बाद यह स्पष्ट है कि वह वास्तव में क्या करता है। सबसे अधिक संभावना है, हमारा कोड खुद हमें एक अच्छा नाम बताएगा।

चौथा:

Copy Source | Copy HTML
क्लास टर्नअराउंड कैक्लकुलर
आरंभीकृत करें (ख़रीदा गया, टर्नअराउंड)
@purchased_at = ख़रीदा गया
@ टर्नअराउंड = टर्नअराउंड
अंत
डीईएफ़ गणना
#snip
अंत
अंत

पांचवें:

Copy Source | Copy HTML
वर्ग भाव < ActiveRecord :: बेस
सुंदर_टर्नअर्न को परिभाषित करें
TurnaroundCalculator। नया (ख़रीदा गया), टर्नअराउंड) .calculate
अंत
अंत

हो गया! हमें परीक्षणों को चलाने और यह देखने की आवश्यकता है कि वे कैसे गुजरते हैं। यहां तक कि अगर "परीक्षण चलाने" का अर्थ है मैन्युअल रूप से जाँच ...

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

Copy Source | Copy HTML
क्लास टर्नअराउंड कैक्लकुलर
डीईएफ़ गणना
वापसी अगर " @ पलटा " । शून्य ?
"" {आगमन_डेट} (# {days_from_today} आज से व्यावसायिक दिन) "
अंत
संरक्षित
आगमन आगमन
real_turnaround_time .strftime ( "% A% d% B" )
अंत
def real_turnaround_time
समायोजन_समय_प्रत्येक कार्य ( प्रारंभ_ समय + बदलाव_में_सुविधाएँ )
अंत
डीफ़ एडजस्ट_टाइम_फ़ॉर_वेकेंड (समय)
यदि शनिवार है तो (समय)
समय + २ * ६० * ६० * २४
एलीसिफ़ रविवार (समय)
समय + 1 * 60 * 60 * 24
अन्यथा
समय
अंत
अंत
शनिवार को हराया (समय)
time.strftime ( "% a" ) == "सत"
अंत
रविवार को (समय)
time.strftime ( "% a" ) == "सूर्य"
अंत
टर्नअराउंड_ in_seconds को परिभाषित करें
@ टर्नअराउंड * 60 * 60 * 24
अंत
def start_time
@purchased_at या समय .now
अंत
def_from_today
अगर @purchased_at
(( समय .now - @ खरीदी_at.to_time) / 60/60/24) .floor + 1
अन्यथा
@ टर्नअराउंड + 1
अंत
अंत
अंत

वाह! यह कोड जो मैंने 3 साल पहले लिखा था, वह सही नहीं है, लेकिन इसे लगभग समझा जा सकता है। और हर टुकड़ा समझ में आता है। यह रिफैक्टरिंग की 2 या 3 तरंगों के बाद है, जिसे मैं एक अलग पोस्ट में प्रकट कर सकता हूं, क्योंकि अब जो कुछ हुआ है, वह मेरे विचार से कुछ अधिक स्पष्ट है। किसी भी मामले में, आप विचार को समझते हैं। इसका मतलब यह है कि जब मैं कहता हूं कि मैं रूबी में पांच-पंक्ति विधियों पर केंद्रित हूं; यदि आपका कोड स्पष्ट है, तो आप इसे आसानी से संपादित कर सकते हैं।

रूबी की स्वच्छ वस्तुओं को प्राप्त करने का विचार रेल में सच है। इस मार्ग पर एक नज़र डालें:

Copy Source | Copy HTML
रूट: से => 'डैशबोर्ड # इंडेक्स' :: बाधाओं => लॉग इन करेंकस्ट्रैटिन

और? LoggedInConstraint?

Copy Source | Copy HTML
वर्ग लॉगइनकोनस्ट्रैटिन
स्वयं को सुरक्षित रखें। (अनुरोध)
current_user
अंत
अंत

उ। हाँ। एक वस्तु जो रूटिंग नीति का वर्णन करती है। अद्भुत। इसके अलावा सत्यापन उदाहरण बेशर्मी से omgbloglol के साथ चोरी:

Copy Source | Copy HTML
def SomeClass < ActiveRecord :: बेस
मान्य: श्रेणी_नि:, उचित_श्रेणी => सत्य
अंत
श्रेणी ProperCategoryValidator <ActiveModel :: EveryValidator
defate_each (रिकॉर्ड, विशेषता, मान)
जब तक record.user.category_ids। शामिल हैं । (मूल्य)
रिकॉर्ड है। त्रुटियाँ .add विशेषता, 'बुरी श्रेणी है।'
अंत
अंत
अंत

यह एक शुद्ध रूबी वर्ग नहीं है, लेकिन आप इस विचार को समझते हैं।

अब आप शायद सोचते हैं: "स्टीव, यह केवल रेल के लिए नहीं है, आपने झूठ बोला!" ठीक है, हाँ, वास्तव में, आपने मुझे पकड़ लिया: यह ऑब्जेक्ट-ओरिएंटेड रेल के लिए एक रहस्य नहीं है, यह एक सामान्य वस्तु-उन्मुख दृष्टिकोण है। लेकिन रेलों के लिए कुछ विशिष्ट है जो आपको कभी न टूटने वाली कक्षाओं के जाल में फंसाने के लिए लगता है। शायद इस तरह के कचरे के भंडार के लिए लिबास / लगता है। यह संभव है कि 15 मिनट के उदाहरणों में केवल ActiveRecord मॉडल शामिल हैं। शायद खुले नॉन-रेल की तुलना में अधिक बंद रेल अनुप्रयोग हैं, (नोट: केवल मेरी अपनी राय), इसलिए हमारे पास भरोसा करने के लिए कई अच्छे उदाहरण नहीं हैं। (मेरे पास यह कूबड़ है, क्योंकि रेल अक्सर कंपनियों के लिए साइटों को विकसित करने के लिए उपयोग किया जाता है। रत्न? सटीक रूप से? मेरा वेब अनुप्रयोग? इतना भी नहीं। फिर भी, मेरे पास पुष्टि करने के लिए आँकड़े नहीं हैं।)

सामान्य तौर पर: डोमेन ऑब्जेक्ट को पुनः प्राप्त करना अच्छा है। वे आपके परीक्षणों को तेज़, आपके कोड को छोटा और भविष्य में परिवर्तनों को आसान बनाते हैं। मुझे अभी भी इस बारे में कुछ कहना है, विशेष रूप से "त्वरित परीक्षणों" के बारे में, लेकिन मैंने पहले ही पोस्ट की संभावित लंबाई समाप्त कर दी है। अगली बार तक!

रेल में उन्मुख वस्तु विकास का रहस्य

More articles: